From 822dd7f3a6b71fef472e26406fb93900e5ed0a7b Mon Sep 17 00:00:00 2001
From: spencer-lunarg <spencer@lunarg.com>
Date: Thu, 25 Jan 2024 23:08:53 +0900
Subject: [PATCH 001/106] scripts: Add struct extension re-lookup in base
 generator

---
 scripts/generators/base_generator.py | 26 ++++++++++++++++++--------
 1 file changed, 18 insertions(+), 8 deletions(-)

diff --git a/scripts/generators/base_generator.py b/scripts/generators/base_generator.py
index 75ce610..2d8635e 100644
--- a/scripts/generators/base_generator.py
+++ b/scripts/generators/base_generator.py
@@ -1,9 +1,9 @@
 #!/usr/bin/python3 -i
 #
-# Copyright 2023 The Khronos Group Inc.
-# Copyright 2023 Valve Corporation
-# Copyright 2023 LunarG, Inc.
-# Copyright 2023 RasterGrid Kft.
+# Copyright 2023-2024 The Khronos Group Inc.
+# Copyright 2023-2024 Valve Corporation
+# Copyright 2023-2024 LunarG, Inc.
+# Copyright 2023-2024 RasterGrid Kft.
 #
 # SPDX-License-Identifier: Apache-2.0
 
@@ -134,6 +134,7 @@ class BaseGenerator(OutputGenerator):
         self.enumFieldAliasMap = dict()
         self.bitmaskAliasMap = dict()
         self.flagAliasMap = dict()
+        self.structAliasMap = dict()
 
     def write(self, data):
         # Prevents having to check before writting
@@ -282,6 +283,18 @@ class BaseGenerator(OutputGenerator):
                                     extension.flags[bitmaskName] = [] # Dict needs init
                                 extension.flags[bitmaskName].extend([flag] if flag not in extension.flags[bitmaskName] else [])
 
+        # Some structs (ex VkAttachmentSampleCountInfoAMD) can have multiple alias pointing to same extension
+        for extension in self.vk.extensions.values():
+            dict = self.featureDictionary[extension.name]['struct']
+            for required in dict:
+                for group in dict[required]:
+                    for structName in dict[required][group]:
+                        isAlias = structName in self.structAliasMap
+                        structName = self.structAliasMap[structName] if isAlias else structName
+                        if structName in self.vk.structs:
+                            struct = self.vk.structs[structName]
+                            struct.extensions.extend([extension] if extension not in struct.extensions else [])
+
     def endFile(self):
         # This is the point were reg.py has ran, everything is collected
         # We do some post processing now
@@ -511,10 +524,7 @@ class BaseGenerator(OutputGenerator):
         if (category == 'struct' or category == 'union'):
             extension = [self.currentExtension] if self.currentExtension is not None else []
             if alias is not None:
-                struct = self.vk.structs[alias]
-                # Some structs (ex VkAttachmentSampleCountInfoAMD) can have multiple alias pointing to same extension
-                struct.extensions += extension if extension and extension[0] not in struct.extensions else []
-                struct.version = self.currentVersion if struct.version is None else struct.version
+                self.structAliasMap[typeName] = alias
                 return
 
             union = category == 'union'

From b6f52799ec558808c7cad9522cf3b4fe75ee97d5 Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Fri, 26 Jan 2024 00:17:38 -0800
Subject: [PATCH 002/106] build: Update to header 1.3.276

- Update known-good
- Generate source
---
 include/vulkan/utility/vk_dispatch_table.h  | 10 ++-
 include/vulkan/utility/vk_struct_helper.hpp | 16 +++--
 include/vulkan/vk_enum_string_helper.h      | 78 +++++++++++++--------
 scripts/known_good.json                     |  2 +-
 4 files changed, 69 insertions(+), 37 deletions(-)

diff --git a/include/vulkan/utility/vk_dispatch_table.h b/include/vulkan/utility/vk_dispatch_table.h
index 61d8d1e..2a10ad4 100644
--- a/include/vulkan/utility/vk_dispatch_table.h
+++ b/include/vulkan/utility/vk_dispatch_table.h
@@ -421,6 +421,8 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkWaitSemaphoresKHR WaitSemaphoresKHR;
     PFN_vkSignalSemaphoreKHR SignalSemaphoreKHR;
     PFN_vkCmdSetFragmentShadingRateKHR CmdSetFragmentShadingRateKHR;
+    PFN_vkCmdSetRenderingAttachmentLocationsKHR CmdSetRenderingAttachmentLocationsKHR;
+    PFN_vkCmdSetRenderingInputAttachmentIndicesKHR CmdSetRenderingInputAttachmentIndicesKHR;
     PFN_vkWaitForPresentKHR WaitForPresentKHR;
     PFN_vkGetBufferDeviceAddressKHR GetBufferDeviceAddressKHR;
     PFN_vkGetBufferOpaqueCaptureAddressKHR GetBufferOpaqueCaptureAddressKHR;
@@ -459,6 +461,7 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkGetRenderingAreaGranularityKHR GetRenderingAreaGranularityKHR;
     PFN_vkGetDeviceImageSubresourceLayoutKHR GetDeviceImageSubresourceLayoutKHR;
     PFN_vkGetImageSubresourceLayout2KHR GetImageSubresourceLayout2KHR;
+    PFN_vkCmdSetLineStippleKHR CmdSetLineStippleKHR;
     PFN_vkGetCalibratedTimestampsKHR GetCalibratedTimestampsKHR;
     PFN_vkCmdBindDescriptorSets2KHR CmdBindDescriptorSets2KHR;
     PFN_vkCmdPushConstants2KHR CmdPushConstants2KHR;
@@ -676,7 +679,6 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkGetPipelineIndirectMemoryRequirementsNV GetPipelineIndirectMemoryRequirementsNV;
     PFN_vkCmdUpdatePipelineIndirectBufferNV CmdUpdatePipelineIndirectBufferNV;
     PFN_vkGetPipelineIndirectDeviceAddressNV GetPipelineIndirectDeviceAddressNV;
-    PFN_vkCmdSetTessellationDomainOriginEXT CmdSetTessellationDomainOriginEXT;
     PFN_vkCmdSetDepthClampEnableEXT CmdSetDepthClampEnableEXT;
     PFN_vkCmdSetPolygonModeEXT CmdSetPolygonModeEXT;
     PFN_vkCmdSetRasterizationSamplesEXT CmdSetRasterizationSamplesEXT;
@@ -687,6 +689,7 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkCmdSetColorBlendEnableEXT CmdSetColorBlendEnableEXT;
     PFN_vkCmdSetColorBlendEquationEXT CmdSetColorBlendEquationEXT;
     PFN_vkCmdSetColorWriteMaskEXT CmdSetColorWriteMaskEXT;
+    PFN_vkCmdSetTessellationDomainOriginEXT CmdSetTessellationDomainOriginEXT;
     PFN_vkCmdSetRasterizationStreamEXT CmdSetRasterizationStreamEXT;
     PFN_vkCmdSetConservativeRasterizationModeEXT CmdSetConservativeRasterizationModeEXT;
     PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT CmdSetExtraPrimitiveOverestimationSizeEXT;
@@ -1014,6 +1017,8 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
     table->WaitSemaphoresKHR = (PFN_vkWaitSemaphoresKHR)gdpa(device, "vkWaitSemaphoresKHR");
     table->SignalSemaphoreKHR = (PFN_vkSignalSemaphoreKHR)gdpa(device, "vkSignalSemaphoreKHR");
     table->CmdSetFragmentShadingRateKHR = (PFN_vkCmdSetFragmentShadingRateKHR)gdpa(device, "vkCmdSetFragmentShadingRateKHR");
+    table->CmdSetRenderingAttachmentLocationsKHR = (PFN_vkCmdSetRenderingAttachmentLocationsKHR)gdpa(device, "vkCmdSetRenderingAttachmentLocationsKHR");
+    table->CmdSetRenderingInputAttachmentIndicesKHR = (PFN_vkCmdSetRenderingInputAttachmentIndicesKHR)gdpa(device, "vkCmdSetRenderingInputAttachmentIndicesKHR");
     table->WaitForPresentKHR = (PFN_vkWaitForPresentKHR)gdpa(device, "vkWaitForPresentKHR");
     table->GetBufferDeviceAddressKHR = (PFN_vkGetBufferDeviceAddressKHR)gdpa(device, "vkGetBufferDeviceAddressKHR");
     table->GetBufferOpaqueCaptureAddressKHR = (PFN_vkGetBufferOpaqueCaptureAddressKHR)gdpa(device, "vkGetBufferOpaqueCaptureAddressKHR");
@@ -1052,6 +1057,7 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
     table->GetRenderingAreaGranularityKHR = (PFN_vkGetRenderingAreaGranularityKHR)gdpa(device, "vkGetRenderingAreaGranularityKHR");
     table->GetDeviceImageSubresourceLayoutKHR = (PFN_vkGetDeviceImageSubresourceLayoutKHR)gdpa(device, "vkGetDeviceImageSubresourceLayoutKHR");
     table->GetImageSubresourceLayout2KHR = (PFN_vkGetImageSubresourceLayout2KHR)gdpa(device, "vkGetImageSubresourceLayout2KHR");
+    table->CmdSetLineStippleKHR = (PFN_vkCmdSetLineStippleKHR)gdpa(device, "vkCmdSetLineStippleKHR");
     table->GetCalibratedTimestampsKHR = (PFN_vkGetCalibratedTimestampsKHR)gdpa(device, "vkGetCalibratedTimestampsKHR");
     table->CmdBindDescriptorSets2KHR = (PFN_vkCmdBindDescriptorSets2KHR)gdpa(device, "vkCmdBindDescriptorSets2KHR");
     table->CmdPushConstants2KHR = (PFN_vkCmdPushConstants2KHR)gdpa(device, "vkCmdPushConstants2KHR");
@@ -1269,7 +1275,6 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
     table->GetPipelineIndirectMemoryRequirementsNV = (PFN_vkGetPipelineIndirectMemoryRequirementsNV)gdpa(device, "vkGetPipelineIndirectMemoryRequirementsNV");
     table->CmdUpdatePipelineIndirectBufferNV = (PFN_vkCmdUpdatePipelineIndirectBufferNV)gdpa(device, "vkCmdUpdatePipelineIndirectBufferNV");
     table->GetPipelineIndirectDeviceAddressNV = (PFN_vkGetPipelineIndirectDeviceAddressNV)gdpa(device, "vkGetPipelineIndirectDeviceAddressNV");
-    table->CmdSetTessellationDomainOriginEXT = (PFN_vkCmdSetTessellationDomainOriginEXT)gdpa(device, "vkCmdSetTessellationDomainOriginEXT");
     table->CmdSetDepthClampEnableEXT = (PFN_vkCmdSetDepthClampEnableEXT)gdpa(device, "vkCmdSetDepthClampEnableEXT");
     table->CmdSetPolygonModeEXT = (PFN_vkCmdSetPolygonModeEXT)gdpa(device, "vkCmdSetPolygonModeEXT");
     table->CmdSetRasterizationSamplesEXT = (PFN_vkCmdSetRasterizationSamplesEXT)gdpa(device, "vkCmdSetRasterizationSamplesEXT");
@@ -1280,6 +1285,7 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
     table->CmdSetColorBlendEnableEXT = (PFN_vkCmdSetColorBlendEnableEXT)gdpa(device, "vkCmdSetColorBlendEnableEXT");
     table->CmdSetColorBlendEquationEXT = (PFN_vkCmdSetColorBlendEquationEXT)gdpa(device, "vkCmdSetColorBlendEquationEXT");
     table->CmdSetColorWriteMaskEXT = (PFN_vkCmdSetColorWriteMaskEXT)gdpa(device, "vkCmdSetColorWriteMaskEXT");
+    table->CmdSetTessellationDomainOriginEXT = (PFN_vkCmdSetTessellationDomainOriginEXT)gdpa(device, "vkCmdSetTessellationDomainOriginEXT");
     table->CmdSetRasterizationStreamEXT = (PFN_vkCmdSetRasterizationStreamEXT)gdpa(device, "vkCmdSetRasterizationStreamEXT");
     table->CmdSetConservativeRasterizationModeEXT = (PFN_vkCmdSetConservativeRasterizationModeEXT)gdpa(device, "vkCmdSetConservativeRasterizationModeEXT");
     table->CmdSetExtraPrimitiveOverestimationSizeEXT = (PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)gdpa(device, "vkCmdSetExtraPrimitiveOverestimationSizeEXT");
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index 67126cb..3f6bfa9 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -378,6 +378,10 @@ template <> inline VkStructureType GetSType<VkPipelineFragmentShadingRateStateCr
 template <> inline VkStructureType GetSType<VkPhysicalDeviceFragmentShadingRateFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceFragmentShadingRatePropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceFragmentShadingRateKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkRenderingAttachmentLocationInfoKHR>() { return VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkRenderingInputAttachmentIndexInfoKHR>() { return VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderQuadControlFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkSurfaceProtectedCapabilitiesKHR>() { return VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDevicePresentWaitFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR; }
@@ -409,6 +413,8 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceFragmentShaderBaryce
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance5FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance5PropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR; }
 template <> inline VkStructureType GetSType<VkRenderingAreaInfoKHR>() { return VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR; }
@@ -426,7 +432,13 @@ template <> inline VkStructureType GetSType<VkVideoInlineQueryInfoKHR>() { retur
 template <> inline VkStructureType GetSType<VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR; }
 template <> inline VkStructureType GetSType<VkPipelineVertexInputDivisorStateCreateInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderFloatControls2FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceIndexTypeUint8FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceLineRasterizationFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceLineRasterizationPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR; }
+template <> inline VkStructureType GetSType<VkPipelineRasterizationLineStateCreateInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkCalibratedTimestampInfoKHR>() { return VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderExpectAssumeFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance6FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance6PropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR; }
 template <> inline VkStructureType GetSType<VkBindMemoryStatusKHR>() { return VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR; }
@@ -623,11 +635,7 @@ template <> inline VkStructureType GetSType<VkSurfaceCapabilitiesFullScreenExclu
 template <> inline VkStructureType GetSType<VkSurfaceFullScreenExclusiveWin32InfoEXT>() { return VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT; }
 #endif  // VK_USE_PLATFORM_WIN32_KHR
 template <> inline VkStructureType GetSType<VkHeadlessSurfaceCreateInfoEXT>() { return VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceLineRasterizationFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceLineRasterizationPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT; }
-template <> inline VkStructureType GetSType<VkPipelineRasterizationLineStateCreateInfoEXT>() { return VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceIndexTypeUint8FeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceHostImageCopyFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceHostImageCopyPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index 9d2af46..dd58c60 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -1134,8 +1134,16 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR";
+        case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR";
+        case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
@@ -1184,16 +1192,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT";
         case VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT:
             return "VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT";
-        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
-            return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
@@ -1606,6 +1606,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR";
         case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM:
             return "VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM:
@@ -1658,6 +1660,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
@@ -1838,6 +1842,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR";
         case VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX:
             return "VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX";
         case VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX:
@@ -1850,8 +1856,18 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR";
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR";
         case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR:
             return "VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR:
@@ -1934,6 +1950,8 @@ static inline const char* string_VkImageLayout(VkImageLayout input_value) {
             return "VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT";
         case VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR:
             return "VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR";
+        case VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR:
+            return "VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR";
         case VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR:
             return "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR";
         case VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR:
@@ -2980,8 +2998,6 @@ static inline const char* string_VkDynamicState(VkDynamicState input_value) {
             return "VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV";
         case VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR:
             return "VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR";
-        case VK_DYNAMIC_STATE_LINE_STIPPLE_EXT:
-            return "VK_DYNAMIC_STATE_LINE_STIPPLE_EXT";
         case VK_DYNAMIC_STATE_VERTEX_INPUT_EXT:
             return "VK_DYNAMIC_STATE_VERTEX_INPUT_EXT";
         case VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT:
@@ -2990,8 +3006,6 @@ static inline const char* string_VkDynamicState(VkDynamicState input_value) {
             return "VK_DYNAMIC_STATE_LOGIC_OP_EXT";
         case VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT:
             return "VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT";
-        case VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT:
-            return "VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT";
         case VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT:
             return "VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT";
         case VK_DYNAMIC_STATE_POLYGON_MODE_EXT:
@@ -3012,6 +3026,8 @@ static inline const char* string_VkDynamicState(VkDynamicState input_value) {
             return "VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT";
         case VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT:
             return "VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT";
+        case VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT:
+            return "VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT";
         case VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT:
             return "VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT";
         case VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT:
@@ -3054,6 +3070,8 @@ static inline const char* string_VkDynamicState(VkDynamicState input_value) {
             return "VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV";
         case VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT:
             return "VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT";
+        case VK_DYNAMIC_STATE_LINE_STIPPLE_KHR:
+            return "VK_DYNAMIC_STATE_LINE_STIPPLE_KHR";
         default:
             return "Unhandled VkDynamicState";
     }
@@ -3288,8 +3306,8 @@ static inline const char* string_VkAttachmentLoadOp(VkAttachmentLoadOp input_val
             return "VK_ATTACHMENT_LOAD_OP_CLEAR";
         case VK_ATTACHMENT_LOAD_OP_DONT_CARE:
             return "VK_ATTACHMENT_LOAD_OP_DONT_CARE";
-        case VK_ATTACHMENT_LOAD_OP_NONE_EXT:
-            return "VK_ATTACHMENT_LOAD_OP_NONE_EXT";
+        case VK_ATTACHMENT_LOAD_OP_NONE_KHR:
+            return "VK_ATTACHMENT_LOAD_OP_NONE_KHR";
         default:
             return "Unhandled VkAttachmentLoadOp";
     }
@@ -3342,8 +3360,8 @@ static inline const char* string_VkIndexType(VkIndexType input_value) {
             return "VK_INDEX_TYPE_UINT32";
         case VK_INDEX_TYPE_NONE_KHR:
             return "VK_INDEX_TYPE_NONE_KHR";
-        case VK_INDEX_TYPE_UINT8_EXT:
-            return "VK_INDEX_TYPE_UINT8_EXT";
+        case VK_INDEX_TYPE_UINT8_KHR:
+            return "VK_INDEX_TYPE_UINT8_KHR";
         default:
             return "Unhandled VkIndexType";
     }
@@ -3750,6 +3768,20 @@ static inline const char* string_VkScopeKHR(VkScopeKHR input_value) {
             return "Unhandled VkScopeKHR";
     }
 }
+static inline const char* string_VkLineRasterizationModeKHR(VkLineRasterizationModeKHR input_value) {
+    switch (input_value) {
+        case VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR:
+            return "VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR";
+        case VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR:
+            return "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR";
+        case VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR:
+            return "VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR";
+        case VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR:
+            return "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR";
+        default:
+            return "Unhandled VkLineRasterizationModeKHR";
+    }
+}
 static inline const char* string_VkTimeDomainKHR(VkTimeDomainKHR input_value) {
     switch (input_value) {
         case VK_TIME_DOMAIN_DEVICE_KHR:
@@ -4262,20 +4294,6 @@ static inline const char* string_VkFullScreenExclusiveEXT(VkFullScreenExclusiveE
     }
 }
 #endif  // VK_USE_PLATFORM_WIN32_KHR
-static inline const char* string_VkLineRasterizationModeEXT(VkLineRasterizationModeEXT input_value) {
-    switch (input_value) {
-        case VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT:
-            return "VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT";
-        case VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT:
-            return "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT";
-        case VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT:
-            return "VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT";
-        case VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT:
-            return "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT";
-        default:
-            return "Unhandled VkLineRasterizationModeEXT";
-    }
-}
 static inline const char* string_VkIndirectCommandsTokenTypeNV(VkIndirectCommandsTokenTypeNV input_value) {
     switch (input_value) {
         case VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV:
diff --git a/scripts/known_good.json b/scripts/known_good.json
index abc2bc9..b0d443d 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.3.275"
+            "commit": "v1.3.276"
         },
         {
             "name": "googletest",

From 86de0a0a9dc09520644bfb6b2f49e919134fe86d Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Thu, 1 Feb 2024 09:53:12 -0800
Subject: [PATCH 003/106] build: Update to header 1.3.277

- Update known-good
- Generate source
---
 include/vulkan/utility/vk_struct_helper.hpp |  5 +++++
 include/vulkan/vk_enum_string_helper.h      | 16 ++++++++++++++++
 scripts/known_good.json                     |  2 +-
 3 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index 3f6bfa9..dd8d1d5 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -427,6 +427,11 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingPositionFe
 template <> inline VkStructureType GetSType<VkCooperativeMatrixPropertiesKHR>() { return VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeMatrixFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeMatrixPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR; }
+template <> inline VkStructureType GetSType<VkVideoDecodeAV1ProfileInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkVideoDecodeAV1CapabilitiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR; }
+template <> inline VkStructureType GetSType<VkVideoDecodeAV1SessionParametersCreateInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkVideoDecodeAV1PictureInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkVideoDecodeAV1DpbSlotInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceVideoMaintenance1FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkVideoInlineQueryInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index dd58c60..a392fe5 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -1810,6 +1810,16 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM";
         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM:
             return "VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR:
+            return "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR";
         case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR:
@@ -6463,6 +6473,10 @@ static inline const char* string_VkSubgroupFeatureFlagBits(VkSubgroupFeatureFlag
             return "VK_SUBGROUP_FEATURE_QUAD_BIT";
         case VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV:
             return "VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV";
+        case VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR:
+            return "VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR";
+        case VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR:
+            return "VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR";
         default:
             return "Unhandled VkSubgroupFeatureFlagBits";
     }
@@ -7374,6 +7388,8 @@ static inline const char* string_VkVideoCodecOperationFlagBitsKHR(VkVideoCodecOp
             return "VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR";
         case VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR:
             return "VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR";
+        case VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR:
+            return "VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR";
         default:
             return "Unhandled VkVideoCodecOperationFlagBitsKHR";
     }
diff --git a/scripts/known_good.json b/scripts/known_good.json
index b0d443d..8187e38 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.3.276"
+            "commit": "v1.3.277"
         },
         {
             "name": "googletest",

From 1b8b60bf7f271a09eeda032d117d51a43ed506cd Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Fri, 16 Feb 2024 11:38:23 -0800
Subject: [PATCH 004/106] build: Update to header 1.3.278

- Update known-good
- Generate source
---
 include/vulkan/utility/vk_struct_helper.hpp |  4 ++
 include/vulkan/vk_enum_string_helper.h      | 62 ++++++++++++++++++++-
 scripts/known_good.json                     |  2 +-
 3 files changed, 65 insertions(+), 3 deletions(-)

diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index dd8d1d5..4bd44f6 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -652,6 +652,9 @@ template <> inline VkStructureType GetSType<VkCopyImageToImageInfoEXT>() { retur
 template <> inline VkStructureType GetSType<VkHostImageLayoutTransitionInfoEXT>() { return VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkSubresourceHostMemcpySizeEXT>() { return VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT; }
 template <> inline VkStructureType GetSType<VkHostImageCopyDevicePerformanceQueryEXT>() { return VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceMapMemoryPlacedFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceMapMemoryPlacedPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT; }
+template <> inline VkStructureType GetSType<VkMemoryMapPlacedInfoEXT>() { return VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkSurfacePresentModeEXT>() { return VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT; }
 template <> inline VkStructureType GetSType<VkSurfacePresentScalingCapabilitiesEXT>() { return VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT; }
@@ -935,6 +938,7 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceExternalMemoryScreen
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
 template <> inline VkStructureType GetSType<VkPhysicalDeviceLayeredDriverPropertiesMSFT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryTrianglesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryAabbsDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryInstancesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index a392fe5..0e191a0 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -108,8 +108,8 @@ static inline const char* string_VkResult(VkResult input_value) {
             return "VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR";
         case VK_ERROR_COMPRESSION_EXHAUSTED_EXT:
             return "VK_ERROR_COMPRESSION_EXHAUSTED_EXT";
-        case VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT:
-            return "VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT";
+        case VK_INCOMPATIBLE_SHADER_BINARY_EXT:
+            return "VK_INCOMPATIBLE_SHADER_BINARY_EXT";
         default:
             return "Unhandled VkResult";
     }
@@ -1232,6 +1232,12 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR";
         case VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR:
             return "VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT";
+        case VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT:
+            return "VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT";
         case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT:
@@ -1898,6 +1904,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV";
         default:
             return "Unhandled VkStructureType";
     }
@@ -5379,6 +5387,31 @@ static inline std::string string_VkPipelineStageFlags(VkPipelineStageFlags input
     return ret;
 }
 #endif // __cplusplus
+static inline const char* string_VkMemoryMapFlagBits(VkMemoryMapFlagBits input_value) {
+    switch (input_value) {
+        case VK_MEMORY_MAP_PLACED_BIT_EXT:
+            return "VK_MEMORY_MAP_PLACED_BIT_EXT";
+        default:
+            return "Unhandled VkMemoryMapFlagBits";
+    }
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkMemoryMapFlags(VkMemoryMapFlags input_value) {
+    std::string ret;
+    int index = 0;
+    while(input_value) {
+        if (input_value & 1) {
+            if( !ret.empty()) ret.append("|");
+            ret.append(string_VkMemoryMapFlagBits(static_cast<VkMemoryMapFlagBits>(1U << index)));
+        }
+        ++index;
+        input_value >>= 1;
+    }
+    if (ret.empty()) ret.append("VkMemoryMapFlags(0)");
+    return ret;
+}
+#endif // __cplusplus
 static inline const char* string_VkSparseMemoryBindFlagBits(VkSparseMemoryBindFlagBits input_value) {
     switch (input_value) {
         case VK_SPARSE_MEMORY_BIND_METADATA_BIT:
@@ -8012,6 +8045,31 @@ static inline std::string string_VkPerformanceCounterDescriptionFlagsKHR(VkPerfo
     return ret;
 }
 #endif // __cplusplus
+static inline const char* string_VkMemoryUnmapFlagBitsKHR(VkMemoryUnmapFlagBitsKHR input_value) {
+    switch (input_value) {
+        case VK_MEMORY_UNMAP_RESERVE_BIT_EXT:
+            return "VK_MEMORY_UNMAP_RESERVE_BIT_EXT";
+        default:
+            return "Unhandled VkMemoryUnmapFlagBitsKHR";
+    }
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkMemoryUnmapFlagsKHR(VkMemoryUnmapFlagsKHR input_value) {
+    std::string ret;
+    int index = 0;
+    while(input_value) {
+        if (input_value & 1) {
+            if( !ret.empty()) ret.append("|");
+            ret.append(string_VkMemoryUnmapFlagBitsKHR(static_cast<VkMemoryUnmapFlagBitsKHR>(1U << index)));
+        }
+        ++index;
+        input_value >>= 1;
+    }
+    if (ret.empty()) ret.append("VkMemoryUnmapFlagsKHR(0)");
+    return ret;
+}
+#endif // __cplusplus
 static inline const char* string_VkVideoEncodeCapabilityFlagBitsKHR(VkVideoEncodeCapabilityFlagBitsKHR input_value) {
     switch (input_value) {
         case VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR:
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 8187e38..322f261 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.3.277"
+            "commit": "v1.3.278"
         },
         {
             "name": "googletest",

From a6697121b52a1a24e27e28ff8f10253ad76c1d74 Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Fri, 1 Mar 2024 08:57:55 -0800
Subject: [PATCH 005/106] build: Update to header 1.3.279

- Update known-good
- Generate source
---
 include/vulkan/utility/vk_struct_helper.hpp | 1 +
 include/vulkan/vk_enum_string_helper.h      | 4 ++--
 scripts/known_good.json                     | 2 +-
 3 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index 4bd44f6..bf834cf 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -938,6 +938,7 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceExternalMemoryScreen
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
 template <> inline VkStructureType GetSType<VkPhysicalDeviceLayeredDriverPropertiesMSFT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceRawAccessChainsFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryTrianglesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryAabbsDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index 0e191a0..445e007 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -1904,6 +1904,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV";
         default:
@@ -8289,10 +8291,8 @@ static inline const char* string_VkBufferUsageFlagBits2KHR(uint64_t input_value)
     if (input_value == VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT";
     if (input_value == VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR) return "VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR";
     if (input_value == VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR) return "VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR";
-#ifdef VK_ENABLE_BETA_EXTENSIONS
     if (input_value == VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR) return "VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR";
     if (input_value == VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR) return "VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR";
-#endif  // VK_ENABLE_BETA_EXTENSIONS
     if (input_value == VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT_KHR) return "VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT_KHR";
     if (input_value == VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR) return "VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR";
     if (input_value == VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR) return "VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR";
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 322f261..83028ab 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.3.278"
+            "commit": "v1.3.279"
         },
         {
             "name": "googletest",

From ddf2f1a3b0631f759b82ec4a1f17a418d73f684d Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 4 Mar 2024 15:33:57 +0000
Subject: [PATCH 006/106] build(deps): Bump fsfe/reuse-action from 2 to 3

Bumps [fsfe/reuse-action](https://github.com/fsfe/reuse-action) from 2 to 3.
- [Release notes](https://github.com/fsfe/reuse-action/releases)
- [Commits](https://github.com/fsfe/reuse-action/compare/v2...v3)

---
updated-dependencies:
- dependency-name: fsfe/reuse-action
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 .github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index c4bd57d..13969d7 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -78,7 +78,7 @@ jobs:
     steps:
     - uses: actions/checkout@v4
     - name: REUSE Compliance Check
-      uses: fsfe/reuse-action@v2
+      uses: fsfe/reuse-action@v3
 
   # Test to ensure we don't accidentally break the Chromium build.
   chromium:

From a4140c5fd47dcf3a030726a60b293db61cfb54a3 Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Fri, 8 Mar 2024 08:56:54 -0800
Subject: [PATCH 007/106] build: Update to header 1.3.280

- Update known-good
- Generate source
---
 include/vulkan/utility/vk_struct_helper.hpp | 1 +
 include/vulkan/vk_enum_string_helper.h      | 2 ++
 scripts/known_good.json                     | 2 +-
 3 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index bf834cf..55dda0e 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -940,6 +940,7 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceLayeredDriverPropert
 template <> inline VkStructureType GetSType<VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceRawAccessChainsFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingValidationFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryTrianglesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryAabbsDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryInstancesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index 445e007..6f4fe4c 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -1908,6 +1908,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV";
         default:
             return "Unhandled VkStructureType";
     }
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 83028ab..e99b26c 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.3.279"
+            "commit": "v1.3.280"
         },
         {
             "name": "googletest",

From 4befdac21af188a21aaf5a82702bb52a6426e47a Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Fri, 22 Mar 2024 14:37:07 -0700
Subject: [PATCH 008/106] build: Update to header 1.3.281

---
 scripts/known_good.json | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/scripts/known_good.json b/scripts/known_good.json
index e99b26c..68dfd38 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.3.280"
+            "commit": "v1.3.281"
         },
         {
             "name": "googletest",
@@ -46,4 +46,4 @@
         "googletest": "GOOGLETEST_INSTALL_DIR",
         "magic_enum": "MAGIC_ENUM_INSTALL_DIR"
     }
-}
+}
\ No newline at end of file

From d90f5c7eb1dcfe6ee21363d3c73200425eb6e8b8 Mon Sep 17 00:00:00 2001
From: Jeremy Gebben <jeremyg@lunarg.com>
Date: Tue, 26 Mar 2024 16:51:16 -0600
Subject: [PATCH 009/106] scripts: Make gn.py use check_call

Just like VVL, it was using subprocess.call(), which ignores
errors.
---
 scripts/gn/gn.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)
 mode change 100644 => 100755 scripts/gn/gn.py

diff --git a/scripts/gn/gn.py b/scripts/gn/gn.py
old mode 100644
new mode 100755
index 52b20c5..f23106d
--- a/scripts/gn/gn.py
+++ b/scripts/gn/gn.py
@@ -23,19 +23,19 @@ def BuildGn():
 
     print("Updating Repo Dependencies and GN Toolchain\n", flush=True)
     update_cmd = './scripts/gn/update_deps.sh'
-    subprocess.call(update_cmd)
+    subprocess.check_call(update_cmd)
 
     print("Checking Header Dependencies\n", flush=True)
     gn_check_cmd = 'gn gen --check out/Debug'.split(" ")
-    subprocess.call(gn_check_cmd)
+    subprocess.check_call(gn_check_cmd)
 
     print("Generating Ninja Files\n", flush=True)
     gn_gen_cmd = 'gn gen out/Debug'.split(" ")
-    subprocess.call(gn_gen_cmd)
+    subprocess.check_call(gn_gen_cmd)
 
     print("Running Ninja Build\n", flush=True)
     ninja_build_cmd = 'ninja -C out/Debug'.split(" ")
-    subprocess.call(ninja_build_cmd)
+    subprocess.check_call(ninja_build_cmd)
 
 #
 # Module Entrypoint

From cdd0e00cff5bb2ac15850995e25c1956c37a58ec Mon Sep 17 00:00:00 2001
From: Jeremy Gebben <jeremyg@lunarg.com>
Date: Tue, 19 Mar 2024 09:51:36 -0600
Subject: [PATCH 010/106] Move vk_safe_struct to VUL

This code was being generated in both Vulkan-ValidationLayers
and Vulkan-ExtensionLayer. Further uses are on the horizon so
lets stop the copypasta.

Also, add functions to manipulate extension lists and pNext chains,
since many client layers have been doing that themselves.
---
 BUILD.gn                                      |    10 +
 CMakeLists.txt                                |     3 +-
 include/CMakeLists.txt                        |    26 +-
 .../utility/vk_concurrent_unordered_map.hpp   |   201 +
 include/vulkan/utility/vk_safe_struct.hpp     | 18472 +++++++++++++++
 .../vulkan/utility/vk_safe_struct_utils.hpp   |   128 +
 scripts/common_ci.py                          |    54 +
 scripts/generate_source.py                    |    41 +
 scripts/generators/base_generator.py          |    60 +-
 .../generators/dispatch_table_generator.py    |    16 +-
 .../enum_string_helper_generator.py           |    20 +-
 scripts/generators/generator_utils.py         |   149 +-
 scripts/generators/safe_struct_generator.py   |   797 +
 scripts/generators/struct_helper_generator.py |     8 +-
 scripts/generators/vulkan_object.py           |    38 +-
 scripts/gn/stub.cpp                           |     9 +-
 src/CMakeLists.txt                            |     4 +
 src/vulkan/CMakeLists.txt                     |    30 +
 src/vulkan/vk_safe_struct_core.cpp            | 18773 ++++++++++++++++
 src/vulkan/vk_safe_struct_ext.cpp             | 15447 +++++++++++++
 src/vulkan/vk_safe_struct_khr.cpp             | 15627 +++++++++++++
 src/vulkan/vk_safe_struct_manual.cpp          |  2209 ++
 src/vulkan/vk_safe_struct_utils.cpp           |  3633 +++
 src/vulkan/vk_safe_struct_vendor.cpp          | 15191 +++++++++++++
 tests/CMakeLists.txt                          |     2 +
 tests/safe_struct.cpp                         |   239 +
 26 files changed, 91119 insertions(+), 68 deletions(-)
 create mode 100644 include/vulkan/utility/vk_concurrent_unordered_map.hpp
 create mode 100644 include/vulkan/utility/vk_safe_struct.hpp
 create mode 100644 include/vulkan/utility/vk_safe_struct_utils.hpp
 create mode 100644 scripts/common_ci.py
 create mode 100644 scripts/generators/safe_struct_generator.py
 create mode 100644 src/vulkan/CMakeLists.txt
 create mode 100644 src/vulkan/vk_safe_struct_core.cpp
 create mode 100644 src/vulkan/vk_safe_struct_ext.cpp
 create mode 100644 src/vulkan/vk_safe_struct_khr.cpp
 create mode 100644 src/vulkan/vk_safe_struct_manual.cpp
 create mode 100644 src/vulkan/vk_safe_struct_utils.cpp
 create mode 100644 src/vulkan/vk_safe_struct_vendor.cpp
 create mode 100644 tests/safe_struct.cpp

diff --git a/BUILD.gn b/BUILD.gn
index ea46210..5096a09 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -6,6 +6,7 @@ import("//build_overrides/vulkan_utility_libraries.gni")
 
 config("vulkan_utility_libraries_config") {
   include_dirs = [ "include" ]
+  defines = [ "VK_ENABLE_BETA_EXTENSIONS" ]
 }
 
 static_library("vulkan_layer_settings") {
@@ -14,8 +15,11 @@ static_library("vulkan_layer_settings") {
   sources = [
     "include/vulkan/layer/vk_layer_settings.h",
     "include/vulkan/layer/vk_layer_settings.hpp",
+    "include/vulkan/utility/vk_concurrent_unordered_map.hpp",
     "include/vulkan/utility/vk_dispatch_table.h",
     "include/vulkan/utility/vk_format_utils.h",
+    "include/vulkan/utility/vk_safe_struct.hpp",
+    "include/vulkan/utility/vk_safe_struct_utils.hpp",
     "include/vulkan/utility/vk_struct_helper.hpp",
     "include/vulkan/vk_enum_string_helper.h",
     "scripts/gn/stub.cpp",
@@ -25,5 +29,11 @@ static_library("vulkan_layer_settings") {
     "src/layer/layer_settings_util.hpp",
     "src/layer/vk_layer_settings.cpp",
     "src/layer/vk_layer_settings_helper.cpp",
+    "src/vulkan/vk_safe_struct_core.cpp",
+    "src/vulkan/vk_safe_struct_ext.cpp",
+    "src/vulkan/vk_safe_struct_khr.cpp",
+    "src/vulkan/vk_safe_struct_utils.cpp",
+    "src/vulkan/vk_safe_struct_vendor.cpp",
+    "src/vulkan/vk_safe_struct_manual.cpp",
   ]
 }
diff --git a/CMakeLists.txt b/CMakeLists.txt
index ae4bd3f..042550b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -48,9 +48,10 @@ if (VUL_IS_TOP_LEVEL)
     # Create VulkanUtilityLibraries-targets.cmake
     set_target_properties(VulkanLayerSettings PROPERTIES EXPORT_NAME "LayerSettings")
     set_target_properties(VulkanUtilityHeaders PROPERTIES EXPORT_NAME "UtilityHeaders")
+    set_target_properties(VulkanSafeStruct PROPERTIES EXPORT_NAME "SafeStruct")
     set_target_properties(VulkanCompilerConfiguration PROPERTIES EXPORT_NAME "CompilerConfiguration")
     install(
-        TARGETS VulkanLayerSettings VulkanUtilityHeaders VulkanCompilerConfiguration
+        TARGETS VulkanLayerSettings VulkanUtilityHeaders VulkanSafeStruct VulkanCompilerConfiguration
         EXPORT VulkanUtilityLibraries-targets
         INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
     )
diff --git a/include/CMakeLists.txt b/include/CMakeLists.txt
index 9d045a7..58c48e9 100644
--- a/include/CMakeLists.txt
+++ b/include/CMakeLists.txt
@@ -6,8 +6,15 @@
 target_include_directories(VulkanLayerSettings PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
 
 target_sources(VulkanLayerSettings PRIVATE
-	vulkan/layer/vk_layer_settings.h
-	vulkan/layer/vk_layer_settings.hpp
+    vulkan/layer/vk_layer_settings.h
+    vulkan/layer/vk_layer_settings.hpp
+)
+
+target_include_directories(VulkanSafeStruct PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
+
+target_sources(VulkanSafeStruct PRIVATE
+        vulkan/utility/vk_safe_struct.hpp
+        vulkan/utility/vk_safe_struct_utils.hpp
 )
 
 set(CMAKE_FOLDER "${CMAKE_FOLDER}/VulkanUtilityHeaders")
@@ -17,15 +24,16 @@ add_library(Vulkan::UtilityHeaders ALIAS VulkanUtilityHeaders)
 
 # https://cmake.org/cmake/help/latest/release/3.19.html#other
 if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.19")
-	target_sources(VulkanUtilityHeaders PRIVATE
-		vulkan/utility/vk_dispatch_table.h
-		vulkan/vk_enum_string_helper.h
-		vulkan/utility/vk_format_utils.h
-		vulkan/utility/vk_struct_helper.hpp
-	)
+    target_sources(VulkanUtilityHeaders PRIVATE
+        vulkan/vk_enum_string_helper.h
+        vulkan/utility/vk_concurrent_unordered_map.hpp
+        vulkan/utility/vk_dispatch_table.h
+        vulkan/utility/vk_format_utils.h
+        vulkan/utility/vk_struct_helper.hpp
+    )
 endif()
 
-target_link_Libraries(VulkanUtilityHeaders INTERFACE Vulkan::Headers)
+target_link_libraries(VulkanUtilityHeaders INTERFACE Vulkan::Headers)
 
 target_include_directories(VulkanUtilityHeaders INTERFACE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
 
diff --git a/include/vulkan/utility/vk_concurrent_unordered_map.hpp b/include/vulkan/utility/vk_concurrent_unordered_map.hpp
new file mode 100644
index 0000000..631346d
--- /dev/null
+++ b/include/vulkan/utility/vk_concurrent_unordered_map.hpp
@@ -0,0 +1,201 @@
+/* Copyright (c) 2015-2017, 2019-2024 The Khronos Group Inc.
+ * Copyright (c) 2015-2017, 2019-2024 Valve Corporation
+ * Copyright (c) 2015-2017, 2019-2024 LunarG, Inc.
+ * Modifications Copyright (C) 2022 RasterGrid Kft.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ */
+
+#pragma once
+
+#include <array>
+#include <functional>
+#include <mutex>
+#include <shared_mutex>
+#include <unordered_map>
+#include <vector>
+
+namespace vku {
+namespace concurrent {
+// https://en.cppreference.com/w/cpp/thread/hardware_destructive_interference_size
+// https://en.wikipedia.org/wiki/False_sharing
+// TODO use C++20 to check for std::hardware_destructive_interference_size feature support.
+constexpr std::size_t get_hardware_destructive_interference_size() { return 64; }
+
+// Limited concurrent unordered_map that supports internally-synchronized
+// insert/erase/access. Splits locking across N buckets and uses shared_mutex
+// for read/write locking. Iterators are not supported. The following
+// operations are supported:
+//
+// insert_or_assign: Insert a new element or update an existing element.
+// insert: Insert a new element and return whether it was inserted.
+// erase: Remove an element.
+// contains: Returns true if the key is in the map.
+// find: Returns != end() if found, value is in ret->second.
+// pop: Erases and returns the erased value if found.
+//
+// find/end: find returns a vaguely iterator-like type that can be compared to
+// end and can use iter->second to retrieve the reference. This is to ease porting
+// for existing code that combines the existence check and lookup in a single
+// operation (and thus a single lock). i.e.:
+//
+//      auto iter = map.find(key);
+//      if (iter != map.end()) {
+//          T t = iter->second;
+//          ...
+//
+// snapshot: Return an array of elements (key, value pairs) that satisfy an optional
+// predicate. This can be used as a substitute for iterators in exceptional cases.
+template <typename Key, typename T, int BUCKETSLOG2 = 2, typename Map = std::unordered_map<Key, T>>
+class unordered_map {
+    // Aliases to avoid excessive typing. We can't easily auto these away because
+    // there are virtual methods in ValidationObject which return lock guards
+    // and those cannot use return type deduction.
+    using ReadLockGuard = std::shared_lock<std::shared_mutex>;
+    using WriteLockGuard = std::unique_lock<std::shared_mutex>;
+
+  public:
+    template <typename... Args>
+    void insert_or_assign(const Key &key, Args &&...args) {
+        uint32_t h = ConcurrentMapHashObject(key);
+        WriteLockGuard lock(locks[h].lock);
+        maps[h][key] = {std::forward<Args>(args)...};
+    }
+
+    template <typename... Args>
+    bool insert(const Key &key, Args &&...args) {
+        uint32_t h = ConcurrentMapHashObject(key);
+        WriteLockGuard lock(locks[h].lock);
+        auto ret = maps[h].emplace(key, std::forward<Args>(args)...);
+        return ret.second;
+    }
+
+    // returns size_type
+    size_t erase(const Key &key) {
+        uint32_t h = ConcurrentMapHashObject(key);
+        WriteLockGuard lock(locks[h].lock);
+        return maps[h].erase(key);
+    }
+
+    bool contains(const Key &key) const {
+        uint32_t h = ConcurrentMapHashObject(key);
+        ReadLockGuard lock(locks[h].lock);
+        return maps[h].count(key) != 0;
+    }
+
+    // type returned by find() and end().
+    class FindResult {
+      public:
+        FindResult(bool a, T b) : result(a, std::move(b)) {}
+
+        // == and != only support comparing against end()
+        bool operator==(const FindResult &other) const {
+            if (result.first == false && other.result.first == false) {
+                return true;
+            }
+            return false;
+        }
+        bool operator!=(const FindResult &other) const { return !(*this == other); }
+
+        // Make -> act kind of like an iterator.
+        std::pair<bool, T> *operator->() { return &result; }
+        const std::pair<bool, T> *operator->() const { return &result; }
+
+      private:
+        // (found, reference to element)
+        std::pair<bool, T> result;
+    };
+
+    // find()/end() return a FindResult containing a copy of the value. For end(),
+    // return a default value.
+    FindResult end() const { return FindResult(false, T()); }
+    FindResult cend() const { return end(); }
+
+    FindResult find(const Key &key) const {
+        uint32_t h = ConcurrentMapHashObject(key);
+        ReadLockGuard lock(locks[h].lock);
+
+        auto itr = maps[h].find(key);
+        const bool found = itr != maps[h].end();
+
+        if (found) {
+            return FindResult(true, itr->second);
+        } else {
+            return end();
+        }
+    }
+
+    FindResult pop(const Key &key) {
+        uint32_t h = ConcurrentMapHashObject(key);
+        WriteLockGuard lock(locks[h].lock);
+
+        auto itr = maps[h].find(key);
+        const bool found = itr != maps[h].end();
+
+        if (found) {
+            auto ret = FindResult(true, itr->second);
+            maps[h].erase(itr);
+            return ret;
+        } else {
+            return end();
+        }
+    }
+
+    std::vector<std::pair<const Key, T>> snapshot(std::function<bool(T)> f = nullptr) const {
+        std::vector<std::pair<const Key, T>> ret;
+        for (int h = 0; h < BUCKETS; ++h) {
+            ReadLockGuard lock(locks[h].lock);
+            for (const auto &j : maps[h]) {
+                if (!f || f(j.second)) {
+                    ret.emplace_back(j.first, j.second);
+                }
+            }
+        }
+        return ret;
+    }
+
+    void clear() {
+        for (int h = 0; h < BUCKETS; ++h) {
+            WriteLockGuard lock(locks[h].lock);
+            maps[h].clear();
+        }
+    }
+
+    size_t size() const {
+        size_t result = 0;
+        for (int h = 0; h < BUCKETS; ++h) {
+            ReadLockGuard lock(locks[h].lock);
+            result += maps[h].size();
+        }
+        return result;
+    }
+
+    bool empty() const {
+        bool result = 0;
+        for (int h = 0; h < BUCKETS; ++h) {
+            ReadLockGuard lock(locks[h].lock);
+            result |= maps[h].empty();
+        }
+        return result;
+    }
+
+  private:
+    static const int BUCKETS = (1 << BUCKETSLOG2);
+
+    Map maps[BUCKETS];
+    struct alignas(get_hardware_destructive_interference_size()) AlignedSharedMutex {
+        std::shared_mutex lock;
+    };
+    mutable std::array<AlignedSharedMutex, BUCKETS> locks;
+
+    uint32_t ConcurrentMapHashObject(const Key &object) const {
+        uint64_t u64 = (uint64_t)(uintptr_t)object;
+        uint32_t hash = (uint32_t)(u64 >> 32) + (uint32_t)u64;
+        hash ^= (hash >> BUCKETSLOG2) ^ (hash >> (2 * BUCKETSLOG2));
+        hash &= (BUCKETS - 1);
+        return hash;
+    }
+};
+}  // namespace concurrent
+}  // namespace vku
diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
new file mode 100644
index 0000000..4efcdcf
--- /dev/null
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -0,0 +1,18472 @@
+// *** THIS FILE IS GENERATED - DO NOT EDIT ***
+// See safe_struct_generator.py for modifications
+
+/***************************************************************************
+ *
+ * Copyright (c) 2015-2024 The Khronos Group Inc.
+ * Copyright (c) 2015-2024 Valve Corporation
+ * Copyright (c) 2015-2024 LunarG, Inc.
+ * Copyright (c) 2015-2024 Google Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ ****************************************************************************/
+
+// NOLINTBEGIN
+
+#pragma once
+#include <vulkan/vulkan.h>
+#include <algorithm>
+
+#include <vulkan/utility/vk_safe_struct_utils.hpp>
+
+namespace vku {
+
+struct safe_VkBufferMemoryBarrier {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAccessFlags srcAccessMask;
+    VkAccessFlags dstAccessMask;
+    uint32_t srcQueueFamilyIndex;
+    uint32_t dstQueueFamilyIndex;
+    VkBuffer buffer;
+    VkDeviceSize offset;
+    VkDeviceSize size;
+
+    safe_VkBufferMemoryBarrier(const VkBufferMemoryBarrier* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkBufferMemoryBarrier(const safe_VkBufferMemoryBarrier& copy_src);
+    safe_VkBufferMemoryBarrier& operator=(const safe_VkBufferMemoryBarrier& copy_src);
+    safe_VkBufferMemoryBarrier();
+    ~safe_VkBufferMemoryBarrier();
+    void initialize(const VkBufferMemoryBarrier* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBufferMemoryBarrier* copy_src, PNextCopyState* copy_state = {});
+    VkBufferMemoryBarrier* ptr() { return reinterpret_cast<VkBufferMemoryBarrier*>(this); }
+    VkBufferMemoryBarrier const* ptr() const { return reinterpret_cast<VkBufferMemoryBarrier const*>(this); }
+};
+struct safe_VkImageMemoryBarrier {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAccessFlags srcAccessMask;
+    VkAccessFlags dstAccessMask;
+    VkImageLayout oldLayout;
+    VkImageLayout newLayout;
+    uint32_t srcQueueFamilyIndex;
+    uint32_t dstQueueFamilyIndex;
+    VkImage image;
+    VkImageSubresourceRange subresourceRange;
+
+    safe_VkImageMemoryBarrier(const VkImageMemoryBarrier* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkImageMemoryBarrier(const safe_VkImageMemoryBarrier& copy_src);
+    safe_VkImageMemoryBarrier& operator=(const safe_VkImageMemoryBarrier& copy_src);
+    safe_VkImageMemoryBarrier();
+    ~safe_VkImageMemoryBarrier();
+    void initialize(const VkImageMemoryBarrier* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageMemoryBarrier* copy_src, PNextCopyState* copy_state = {});
+    VkImageMemoryBarrier* ptr() { return reinterpret_cast<VkImageMemoryBarrier*>(this); }
+    VkImageMemoryBarrier const* ptr() const { return reinterpret_cast<VkImageMemoryBarrier const*>(this); }
+};
+struct safe_VkMemoryBarrier {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAccessFlags srcAccessMask;
+    VkAccessFlags dstAccessMask;
+
+    safe_VkMemoryBarrier(const VkMemoryBarrier* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkMemoryBarrier(const safe_VkMemoryBarrier& copy_src);
+    safe_VkMemoryBarrier& operator=(const safe_VkMemoryBarrier& copy_src);
+    safe_VkMemoryBarrier();
+    ~safe_VkMemoryBarrier();
+    void initialize(const VkMemoryBarrier* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMemoryBarrier* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryBarrier* ptr() { return reinterpret_cast<VkMemoryBarrier*>(this); }
+    VkMemoryBarrier const* ptr() const { return reinterpret_cast<VkMemoryBarrier const*>(this); }
+};
+struct safe_VkAllocationCallbacks {
+    void* pUserData{};
+    PFN_vkAllocationFunction pfnAllocation;
+    PFN_vkReallocationFunction pfnReallocation;
+    PFN_vkFreeFunction pfnFree;
+    PFN_vkInternalAllocationNotification pfnInternalAllocation;
+    PFN_vkInternalFreeNotification pfnInternalFree;
+
+    safe_VkAllocationCallbacks(const VkAllocationCallbacks* in_struct, PNextCopyState* copy_state = {});
+    safe_VkAllocationCallbacks(const safe_VkAllocationCallbacks& copy_src);
+    safe_VkAllocationCallbacks& operator=(const safe_VkAllocationCallbacks& copy_src);
+    safe_VkAllocationCallbacks();
+    ~safe_VkAllocationCallbacks();
+    void initialize(const VkAllocationCallbacks* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAllocationCallbacks* copy_src, PNextCopyState* copy_state = {});
+    VkAllocationCallbacks* ptr() { return reinterpret_cast<VkAllocationCallbacks*>(this); }
+    VkAllocationCallbacks const* ptr() const { return reinterpret_cast<VkAllocationCallbacks const*>(this); }
+};
+struct safe_VkApplicationInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    const char* pApplicationName{};
+    uint32_t applicationVersion;
+    const char* pEngineName{};
+    uint32_t engineVersion;
+    uint32_t apiVersion;
+
+    safe_VkApplicationInfo(const VkApplicationInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkApplicationInfo(const safe_VkApplicationInfo& copy_src);
+    safe_VkApplicationInfo& operator=(const safe_VkApplicationInfo& copy_src);
+    safe_VkApplicationInfo();
+    ~safe_VkApplicationInfo();
+    void initialize(const VkApplicationInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkApplicationInfo* copy_src, PNextCopyState* copy_state = {});
+    VkApplicationInfo* ptr() { return reinterpret_cast<VkApplicationInfo*>(this); }
+    VkApplicationInfo const* ptr() const { return reinterpret_cast<VkApplicationInfo const*>(this); }
+};
+struct safe_VkInstanceCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkInstanceCreateFlags flags;
+    safe_VkApplicationInfo* pApplicationInfo{};
+    uint32_t enabledLayerCount;
+    const char* const* ppEnabledLayerNames{};
+    uint32_t enabledExtensionCount;
+    const char* const* ppEnabledExtensionNames{};
+
+    safe_VkInstanceCreateInfo(const VkInstanceCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkInstanceCreateInfo(const safe_VkInstanceCreateInfo& copy_src);
+    safe_VkInstanceCreateInfo& operator=(const safe_VkInstanceCreateInfo& copy_src);
+    safe_VkInstanceCreateInfo();
+    ~safe_VkInstanceCreateInfo();
+    void initialize(const VkInstanceCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkInstanceCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkInstanceCreateInfo* ptr() { return reinterpret_cast<VkInstanceCreateInfo*>(this); }
+    VkInstanceCreateInfo const* ptr() const { return reinterpret_cast<VkInstanceCreateInfo const*>(this); }
+};
+struct safe_VkDeviceQueueCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceQueueCreateFlags flags;
+    uint32_t queueFamilyIndex;
+    uint32_t queueCount;
+    const float* pQueuePriorities{};
+
+    safe_VkDeviceQueueCreateInfo(const VkDeviceQueueCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDeviceQueueCreateInfo(const safe_VkDeviceQueueCreateInfo& copy_src);
+    safe_VkDeviceQueueCreateInfo& operator=(const safe_VkDeviceQueueCreateInfo& copy_src);
+    safe_VkDeviceQueueCreateInfo();
+    ~safe_VkDeviceQueueCreateInfo();
+    void initialize(const VkDeviceQueueCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDeviceQueueCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceQueueCreateInfo* ptr() { return reinterpret_cast<VkDeviceQueueCreateInfo*>(this); }
+    VkDeviceQueueCreateInfo const* ptr() const { return reinterpret_cast<VkDeviceQueueCreateInfo const*>(this); }
+};
+struct safe_VkDeviceCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceCreateFlags flags;
+    uint32_t queueCreateInfoCount;
+    safe_VkDeviceQueueCreateInfo* pQueueCreateInfos{};
+    uint32_t enabledLayerCount;
+    const char* const* ppEnabledLayerNames{};
+    uint32_t enabledExtensionCount;
+    const char* const* ppEnabledExtensionNames{};
+    const VkPhysicalDeviceFeatures* pEnabledFeatures{};
+
+    safe_VkDeviceCreateInfo(const VkDeviceCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDeviceCreateInfo(const safe_VkDeviceCreateInfo& copy_src);
+    safe_VkDeviceCreateInfo& operator=(const safe_VkDeviceCreateInfo& copy_src);
+    safe_VkDeviceCreateInfo();
+    ~safe_VkDeviceCreateInfo();
+    void initialize(const VkDeviceCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDeviceCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceCreateInfo* ptr() { return reinterpret_cast<VkDeviceCreateInfo*>(this); }
+    VkDeviceCreateInfo const* ptr() const { return reinterpret_cast<VkDeviceCreateInfo const*>(this); }
+};
+struct safe_VkSubmitInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t waitSemaphoreCount;
+    VkSemaphore* pWaitSemaphores{};
+    const VkPipelineStageFlags* pWaitDstStageMask{};
+    uint32_t commandBufferCount;
+    VkCommandBuffer* pCommandBuffers{};
+    uint32_t signalSemaphoreCount;
+    VkSemaphore* pSignalSemaphores{};
+
+    safe_VkSubmitInfo(const VkSubmitInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSubmitInfo(const safe_VkSubmitInfo& copy_src);
+    safe_VkSubmitInfo& operator=(const safe_VkSubmitInfo& copy_src);
+    safe_VkSubmitInfo();
+    ~safe_VkSubmitInfo();
+    void initialize(const VkSubmitInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSubmitInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSubmitInfo* ptr() { return reinterpret_cast<VkSubmitInfo*>(this); }
+    VkSubmitInfo const* ptr() const { return reinterpret_cast<VkSubmitInfo const*>(this); }
+};
+struct safe_VkMappedMemoryRange {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceMemory memory;
+    VkDeviceSize offset;
+    VkDeviceSize size;
+
+    safe_VkMappedMemoryRange(const VkMappedMemoryRange* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkMappedMemoryRange(const safe_VkMappedMemoryRange& copy_src);
+    safe_VkMappedMemoryRange& operator=(const safe_VkMappedMemoryRange& copy_src);
+    safe_VkMappedMemoryRange();
+    ~safe_VkMappedMemoryRange();
+    void initialize(const VkMappedMemoryRange* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMappedMemoryRange* copy_src, PNextCopyState* copy_state = {});
+    VkMappedMemoryRange* ptr() { return reinterpret_cast<VkMappedMemoryRange*>(this); }
+    VkMappedMemoryRange const* ptr() const { return reinterpret_cast<VkMappedMemoryRange const*>(this); }
+};
+struct safe_VkMemoryAllocateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceSize allocationSize;
+    uint32_t memoryTypeIndex;
+
+    safe_VkMemoryAllocateInfo(const VkMemoryAllocateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkMemoryAllocateInfo(const safe_VkMemoryAllocateInfo& copy_src);
+    safe_VkMemoryAllocateInfo& operator=(const safe_VkMemoryAllocateInfo& copy_src);
+    safe_VkMemoryAllocateInfo();
+    ~safe_VkMemoryAllocateInfo();
+    void initialize(const VkMemoryAllocateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMemoryAllocateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryAllocateInfo* ptr() { return reinterpret_cast<VkMemoryAllocateInfo*>(this); }
+    VkMemoryAllocateInfo const* ptr() const { return reinterpret_cast<VkMemoryAllocateInfo const*>(this); }
+};
+struct safe_VkSparseBufferMemoryBindInfo {
+    VkBuffer buffer;
+    uint32_t bindCount;
+    VkSparseMemoryBind* pBinds{};
+
+    safe_VkSparseBufferMemoryBindInfo(const VkSparseBufferMemoryBindInfo* in_struct, PNextCopyState* copy_state = {});
+    safe_VkSparseBufferMemoryBindInfo(const safe_VkSparseBufferMemoryBindInfo& copy_src);
+    safe_VkSparseBufferMemoryBindInfo& operator=(const safe_VkSparseBufferMemoryBindInfo& copy_src);
+    safe_VkSparseBufferMemoryBindInfo();
+    ~safe_VkSparseBufferMemoryBindInfo();
+    void initialize(const VkSparseBufferMemoryBindInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSparseBufferMemoryBindInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSparseBufferMemoryBindInfo* ptr() { return reinterpret_cast<VkSparseBufferMemoryBindInfo*>(this); }
+    VkSparseBufferMemoryBindInfo const* ptr() const { return reinterpret_cast<VkSparseBufferMemoryBindInfo const*>(this); }
+};
+struct safe_VkSparseImageOpaqueMemoryBindInfo {
+    VkImage image;
+    uint32_t bindCount;
+    VkSparseMemoryBind* pBinds{};
+
+    safe_VkSparseImageOpaqueMemoryBindInfo(const VkSparseImageOpaqueMemoryBindInfo* in_struct, PNextCopyState* copy_state = {});
+    safe_VkSparseImageOpaqueMemoryBindInfo(const safe_VkSparseImageOpaqueMemoryBindInfo& copy_src);
+    safe_VkSparseImageOpaqueMemoryBindInfo& operator=(const safe_VkSparseImageOpaqueMemoryBindInfo& copy_src);
+    safe_VkSparseImageOpaqueMemoryBindInfo();
+    ~safe_VkSparseImageOpaqueMemoryBindInfo();
+    void initialize(const VkSparseImageOpaqueMemoryBindInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSparseImageOpaqueMemoryBindInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSparseImageOpaqueMemoryBindInfo* ptr() { return reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo*>(this); }
+    VkSparseImageOpaqueMemoryBindInfo const* ptr() const {
+        return reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo const*>(this);
+    }
+};
+struct safe_VkSparseImageMemoryBindInfo {
+    VkImage image;
+    uint32_t bindCount;
+    VkSparseImageMemoryBind* pBinds{};
+
+    safe_VkSparseImageMemoryBindInfo(const VkSparseImageMemoryBindInfo* in_struct, PNextCopyState* copy_state = {});
+    safe_VkSparseImageMemoryBindInfo(const safe_VkSparseImageMemoryBindInfo& copy_src);
+    safe_VkSparseImageMemoryBindInfo& operator=(const safe_VkSparseImageMemoryBindInfo& copy_src);
+    safe_VkSparseImageMemoryBindInfo();
+    ~safe_VkSparseImageMemoryBindInfo();
+    void initialize(const VkSparseImageMemoryBindInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSparseImageMemoryBindInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSparseImageMemoryBindInfo* ptr() { return reinterpret_cast<VkSparseImageMemoryBindInfo*>(this); }
+    VkSparseImageMemoryBindInfo const* ptr() const { return reinterpret_cast<VkSparseImageMemoryBindInfo const*>(this); }
+};
+struct safe_VkBindSparseInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t waitSemaphoreCount;
+    VkSemaphore* pWaitSemaphores{};
+    uint32_t bufferBindCount;
+    safe_VkSparseBufferMemoryBindInfo* pBufferBinds{};
+    uint32_t imageOpaqueBindCount;
+    safe_VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds{};
+    uint32_t imageBindCount;
+    safe_VkSparseImageMemoryBindInfo* pImageBinds{};
+    uint32_t signalSemaphoreCount;
+    VkSemaphore* pSignalSemaphores{};
+
+    safe_VkBindSparseInfo(const VkBindSparseInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkBindSparseInfo(const safe_VkBindSparseInfo& copy_src);
+    safe_VkBindSparseInfo& operator=(const safe_VkBindSparseInfo& copy_src);
+    safe_VkBindSparseInfo();
+    ~safe_VkBindSparseInfo();
+    void initialize(const VkBindSparseInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBindSparseInfo* copy_src, PNextCopyState* copy_state = {});
+    VkBindSparseInfo* ptr() { return reinterpret_cast<VkBindSparseInfo*>(this); }
+    VkBindSparseInfo const* ptr() const { return reinterpret_cast<VkBindSparseInfo const*>(this); }
+};
+struct safe_VkFenceCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkFenceCreateFlags flags;
+
+    safe_VkFenceCreateInfo(const VkFenceCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkFenceCreateInfo(const safe_VkFenceCreateInfo& copy_src);
+    safe_VkFenceCreateInfo& operator=(const safe_VkFenceCreateInfo& copy_src);
+    safe_VkFenceCreateInfo();
+    ~safe_VkFenceCreateInfo();
+    void initialize(const VkFenceCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkFenceCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkFenceCreateInfo* ptr() { return reinterpret_cast<VkFenceCreateInfo*>(this); }
+    VkFenceCreateInfo const* ptr() const { return reinterpret_cast<VkFenceCreateInfo const*>(this); }
+};
+struct safe_VkSemaphoreCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSemaphoreCreateFlags flags;
+
+    safe_VkSemaphoreCreateInfo(const VkSemaphoreCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSemaphoreCreateInfo(const safe_VkSemaphoreCreateInfo& copy_src);
+    safe_VkSemaphoreCreateInfo& operator=(const safe_VkSemaphoreCreateInfo& copy_src);
+    safe_VkSemaphoreCreateInfo();
+    ~safe_VkSemaphoreCreateInfo();
+    void initialize(const VkSemaphoreCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSemaphoreCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSemaphoreCreateInfo* ptr() { return reinterpret_cast<VkSemaphoreCreateInfo*>(this); }
+    VkSemaphoreCreateInfo const* ptr() const { return reinterpret_cast<VkSemaphoreCreateInfo const*>(this); }
+};
+struct safe_VkEventCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkEventCreateFlags flags;
+
+    safe_VkEventCreateInfo(const VkEventCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkEventCreateInfo(const safe_VkEventCreateInfo& copy_src);
+    safe_VkEventCreateInfo& operator=(const safe_VkEventCreateInfo& copy_src);
+    safe_VkEventCreateInfo();
+    ~safe_VkEventCreateInfo();
+    void initialize(const VkEventCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkEventCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkEventCreateInfo* ptr() { return reinterpret_cast<VkEventCreateInfo*>(this); }
+    VkEventCreateInfo const* ptr() const { return reinterpret_cast<VkEventCreateInfo const*>(this); }
+};
+struct safe_VkQueryPoolCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkQueryPoolCreateFlags flags;
+    VkQueryType queryType;
+    uint32_t queryCount;
+    VkQueryPipelineStatisticFlags pipelineStatistics;
+
+    safe_VkQueryPoolCreateInfo(const VkQueryPoolCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkQueryPoolCreateInfo(const safe_VkQueryPoolCreateInfo& copy_src);
+    safe_VkQueryPoolCreateInfo& operator=(const safe_VkQueryPoolCreateInfo& copy_src);
+    safe_VkQueryPoolCreateInfo();
+    ~safe_VkQueryPoolCreateInfo();
+    void initialize(const VkQueryPoolCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkQueryPoolCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkQueryPoolCreateInfo* ptr() { return reinterpret_cast<VkQueryPoolCreateInfo*>(this); }
+    VkQueryPoolCreateInfo const* ptr() const { return reinterpret_cast<VkQueryPoolCreateInfo const*>(this); }
+};
+struct safe_VkBufferCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBufferCreateFlags flags;
+    VkDeviceSize size;
+    VkBufferUsageFlags usage;
+    VkSharingMode sharingMode;
+    uint32_t queueFamilyIndexCount;
+    const uint32_t* pQueueFamilyIndices{};
+
+    safe_VkBufferCreateInfo(const VkBufferCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkBufferCreateInfo(const safe_VkBufferCreateInfo& copy_src);
+    safe_VkBufferCreateInfo& operator=(const safe_VkBufferCreateInfo& copy_src);
+    safe_VkBufferCreateInfo();
+    ~safe_VkBufferCreateInfo();
+    void initialize(const VkBufferCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBufferCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkBufferCreateInfo* ptr() { return reinterpret_cast<VkBufferCreateInfo*>(this); }
+    VkBufferCreateInfo const* ptr() const { return reinterpret_cast<VkBufferCreateInfo const*>(this); }
+};
+struct safe_VkBufferViewCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBufferViewCreateFlags flags;
+    VkBuffer buffer;
+    VkFormat format;
+    VkDeviceSize offset;
+    VkDeviceSize range;
+
+    safe_VkBufferViewCreateInfo(const VkBufferViewCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkBufferViewCreateInfo(const safe_VkBufferViewCreateInfo& copy_src);
+    safe_VkBufferViewCreateInfo& operator=(const safe_VkBufferViewCreateInfo& copy_src);
+    safe_VkBufferViewCreateInfo();
+    ~safe_VkBufferViewCreateInfo();
+    void initialize(const VkBufferViewCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBufferViewCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkBufferViewCreateInfo* ptr() { return reinterpret_cast<VkBufferViewCreateInfo*>(this); }
+    VkBufferViewCreateInfo const* ptr() const { return reinterpret_cast<VkBufferViewCreateInfo const*>(this); }
+};
+struct safe_VkImageCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageCreateFlags flags;
+    VkImageType imageType;
+    VkFormat format;
+    VkExtent3D extent;
+    uint32_t mipLevels;
+    uint32_t arrayLayers;
+    VkSampleCountFlagBits samples;
+    VkImageTiling tiling;
+    VkImageUsageFlags usage;
+    VkSharingMode sharingMode;
+    uint32_t queueFamilyIndexCount;
+    const uint32_t* pQueueFamilyIndices{};
+    VkImageLayout initialLayout;
+
+    safe_VkImageCreateInfo(const VkImageCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkImageCreateInfo(const safe_VkImageCreateInfo& copy_src);
+    safe_VkImageCreateInfo& operator=(const safe_VkImageCreateInfo& copy_src);
+    safe_VkImageCreateInfo();
+    ~safe_VkImageCreateInfo();
+    void initialize(const VkImageCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkImageCreateInfo* ptr() { return reinterpret_cast<VkImageCreateInfo*>(this); }
+    VkImageCreateInfo const* ptr() const { return reinterpret_cast<VkImageCreateInfo const*>(this); }
+};
+struct safe_VkImageViewCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageViewCreateFlags flags;
+    VkImage image;
+    VkImageViewType viewType;
+    VkFormat format;
+    VkComponentMapping components;
+    VkImageSubresourceRange subresourceRange;
+
+    safe_VkImageViewCreateInfo(const VkImageViewCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkImageViewCreateInfo(const safe_VkImageViewCreateInfo& copy_src);
+    safe_VkImageViewCreateInfo& operator=(const safe_VkImageViewCreateInfo& copy_src);
+    safe_VkImageViewCreateInfo();
+    ~safe_VkImageViewCreateInfo();
+    void initialize(const VkImageViewCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageViewCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkImageViewCreateInfo* ptr() { return reinterpret_cast<VkImageViewCreateInfo*>(this); }
+    VkImageViewCreateInfo const* ptr() const { return reinterpret_cast<VkImageViewCreateInfo const*>(this); }
+};
+struct safe_VkShaderModuleCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkShaderModuleCreateFlags flags;
+    size_t codeSize;
+    const uint32_t* pCode{};
+
+    safe_VkShaderModuleCreateInfo(const VkShaderModuleCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    safe_VkShaderModuleCreateInfo(const safe_VkShaderModuleCreateInfo& copy_src);
+    safe_VkShaderModuleCreateInfo& operator=(const safe_VkShaderModuleCreateInfo& copy_src);
+    safe_VkShaderModuleCreateInfo();
+    ~safe_VkShaderModuleCreateInfo();
+    void initialize(const VkShaderModuleCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkShaderModuleCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkShaderModuleCreateInfo* ptr() { return reinterpret_cast<VkShaderModuleCreateInfo*>(this); }
+    VkShaderModuleCreateInfo const* ptr() const { return reinterpret_cast<VkShaderModuleCreateInfo const*>(this); }
+
+    // Primarily intended for use by GPUAV when replacing shader module code with instrumented code
+    template <typename Container>
+    void SetCode(const Container& code) {
+        delete[] pCode;
+        codeSize = static_cast<uint32_t>(code.size() * sizeof(uint32_t));
+        pCode = new uint32_t[code.size()];
+        std::copy(&code.front(), &code.back() + 1, const_cast<uint32_t*>(pCode));
+    }
+};
+struct safe_VkPipelineCacheCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineCacheCreateFlags flags;
+    size_t initialDataSize;
+    const void* pInitialData{};
+
+    safe_VkPipelineCacheCreateInfo(const VkPipelineCacheCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    safe_VkPipelineCacheCreateInfo(const safe_VkPipelineCacheCreateInfo& copy_src);
+    safe_VkPipelineCacheCreateInfo& operator=(const safe_VkPipelineCacheCreateInfo& copy_src);
+    safe_VkPipelineCacheCreateInfo();
+    ~safe_VkPipelineCacheCreateInfo();
+    void initialize(const VkPipelineCacheCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineCacheCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineCacheCreateInfo* ptr() { return reinterpret_cast<VkPipelineCacheCreateInfo*>(this); }
+    VkPipelineCacheCreateInfo const* ptr() const { return reinterpret_cast<VkPipelineCacheCreateInfo const*>(this); }
+};
+struct safe_VkSpecializationInfo {
+    uint32_t mapEntryCount;
+    const VkSpecializationMapEntry* pMapEntries{};
+    size_t dataSize;
+    const void* pData{};
+
+    safe_VkSpecializationInfo(const VkSpecializationInfo* in_struct, PNextCopyState* copy_state = {});
+    safe_VkSpecializationInfo(const safe_VkSpecializationInfo& copy_src);
+    safe_VkSpecializationInfo& operator=(const safe_VkSpecializationInfo& copy_src);
+    safe_VkSpecializationInfo();
+    ~safe_VkSpecializationInfo();
+    void initialize(const VkSpecializationInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSpecializationInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSpecializationInfo* ptr() { return reinterpret_cast<VkSpecializationInfo*>(this); }
+    VkSpecializationInfo const* ptr() const { return reinterpret_cast<VkSpecializationInfo const*>(this); }
+};
+struct safe_VkPipelineShaderStageCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineShaderStageCreateFlags flags;
+    VkShaderStageFlagBits stage;
+    VkShaderModule module;
+    const char* pName{};
+    safe_VkSpecializationInfo* pSpecializationInfo{};
+
+    safe_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkPipelineShaderStageCreateInfo(const safe_VkPipelineShaderStageCreateInfo& copy_src);
+    safe_VkPipelineShaderStageCreateInfo& operator=(const safe_VkPipelineShaderStageCreateInfo& copy_src);
+    safe_VkPipelineShaderStageCreateInfo();
+    ~safe_VkPipelineShaderStageCreateInfo();
+    void initialize(const VkPipelineShaderStageCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineShaderStageCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineShaderStageCreateInfo* ptr() { return reinterpret_cast<VkPipelineShaderStageCreateInfo*>(this); }
+    VkPipelineShaderStageCreateInfo const* ptr() const { return reinterpret_cast<VkPipelineShaderStageCreateInfo const*>(this); }
+};
+struct safe_VkComputePipelineCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineCreateFlags flags;
+    safe_VkPipelineShaderStageCreateInfo stage;
+    VkPipelineLayout layout;
+    VkPipeline basePipelineHandle;
+    int32_t basePipelineIndex;
+
+    safe_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    safe_VkComputePipelineCreateInfo(const safe_VkComputePipelineCreateInfo& copy_src);
+    safe_VkComputePipelineCreateInfo& operator=(const safe_VkComputePipelineCreateInfo& copy_src);
+    safe_VkComputePipelineCreateInfo();
+    ~safe_VkComputePipelineCreateInfo();
+    void initialize(const VkComputePipelineCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkComputePipelineCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkComputePipelineCreateInfo* ptr() { return reinterpret_cast<VkComputePipelineCreateInfo*>(this); }
+    VkComputePipelineCreateInfo const* ptr() const { return reinterpret_cast<VkComputePipelineCreateInfo const*>(this); }
+};
+struct safe_VkPipelineVertexInputStateCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineVertexInputStateCreateFlags flags;
+    uint32_t vertexBindingDescriptionCount;
+    const VkVertexInputBindingDescription* pVertexBindingDescriptions{};
+    uint32_t vertexAttributeDescriptionCount;
+    const VkVertexInputAttributeDescription* pVertexAttributeDescriptions{};
+
+    safe_VkPipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineVertexInputStateCreateInfo(const safe_VkPipelineVertexInputStateCreateInfo& copy_src);
+    safe_VkPipelineVertexInputStateCreateInfo& operator=(const safe_VkPipelineVertexInputStateCreateInfo& copy_src);
+    safe_VkPipelineVertexInputStateCreateInfo();
+    ~safe_VkPipelineVertexInputStateCreateInfo();
+    void initialize(const VkPipelineVertexInputStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineVertexInputStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineVertexInputStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineVertexInputStateCreateInfo*>(this); }
+    VkPipelineVertexInputStateCreateInfo const* ptr() const {
+        return reinterpret_cast<VkPipelineVertexInputStateCreateInfo const*>(this);
+    }
+};
+struct safe_VkPipelineInputAssemblyStateCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineInputAssemblyStateCreateFlags flags;
+    VkPrimitiveTopology topology;
+    VkBool32 primitiveRestartEnable;
+
+    safe_VkPipelineInputAssemblyStateCreateInfo(const VkPipelineInputAssemblyStateCreateInfo* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineInputAssemblyStateCreateInfo(const safe_VkPipelineInputAssemblyStateCreateInfo& copy_src);
+    safe_VkPipelineInputAssemblyStateCreateInfo& operator=(const safe_VkPipelineInputAssemblyStateCreateInfo& copy_src);
+    safe_VkPipelineInputAssemblyStateCreateInfo();
+    ~safe_VkPipelineInputAssemblyStateCreateInfo();
+    void initialize(const VkPipelineInputAssemblyStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineInputAssemblyStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineInputAssemblyStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo*>(this); }
+    VkPipelineInputAssemblyStateCreateInfo const* ptr() const {
+        return reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo const*>(this);
+    }
+};
+struct safe_VkPipelineTessellationStateCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineTessellationStateCreateFlags flags;
+    uint32_t patchControlPoints;
+
+    safe_VkPipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineTessellationStateCreateInfo(const safe_VkPipelineTessellationStateCreateInfo& copy_src);
+    safe_VkPipelineTessellationStateCreateInfo& operator=(const safe_VkPipelineTessellationStateCreateInfo& copy_src);
+    safe_VkPipelineTessellationStateCreateInfo();
+    ~safe_VkPipelineTessellationStateCreateInfo();
+    void initialize(const VkPipelineTessellationStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineTessellationStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineTessellationStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineTessellationStateCreateInfo*>(this); }
+    VkPipelineTessellationStateCreateInfo const* ptr() const {
+        return reinterpret_cast<VkPipelineTessellationStateCreateInfo const*>(this);
+    }
+};
+struct safe_VkPipelineViewportStateCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineViewportStateCreateFlags flags;
+    uint32_t viewportCount;
+    const VkViewport* pViewports{};
+    uint32_t scissorCount;
+    const VkRect2D* pScissors{};
+
+    safe_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo* in_struct, const bool is_dynamic_viewports,
+                                           const bool is_dynamic_scissors, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineViewportStateCreateInfo(const safe_VkPipelineViewportStateCreateInfo& copy_src);
+    safe_VkPipelineViewportStateCreateInfo& operator=(const safe_VkPipelineViewportStateCreateInfo& copy_src);
+    safe_VkPipelineViewportStateCreateInfo();
+    ~safe_VkPipelineViewportStateCreateInfo();
+    void initialize(const VkPipelineViewportStateCreateInfo* in_struct, const bool is_dynamic_viewports,
+                    const bool is_dynamic_scissors, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineViewportStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineViewportStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineViewportStateCreateInfo*>(this); }
+    VkPipelineViewportStateCreateInfo const* ptr() const {
+        return reinterpret_cast<VkPipelineViewportStateCreateInfo const*>(this);
+    }
+};
+struct safe_VkPipelineRasterizationStateCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineRasterizationStateCreateFlags flags;
+    VkBool32 depthClampEnable;
+    VkBool32 rasterizerDiscardEnable;
+    VkPolygonMode polygonMode;
+    VkCullModeFlags cullMode;
+    VkFrontFace frontFace;
+    VkBool32 depthBiasEnable;
+    float depthBiasConstantFactor;
+    float depthBiasClamp;
+    float depthBiasSlopeFactor;
+    float lineWidth;
+
+    safe_VkPipelineRasterizationStateCreateInfo(const VkPipelineRasterizationStateCreateInfo* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineRasterizationStateCreateInfo(const safe_VkPipelineRasterizationStateCreateInfo& copy_src);
+    safe_VkPipelineRasterizationStateCreateInfo& operator=(const safe_VkPipelineRasterizationStateCreateInfo& copy_src);
+    safe_VkPipelineRasterizationStateCreateInfo();
+    ~safe_VkPipelineRasterizationStateCreateInfo();
+    void initialize(const VkPipelineRasterizationStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineRasterizationStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineRasterizationStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineRasterizationStateCreateInfo*>(this); }
+    VkPipelineRasterizationStateCreateInfo const* ptr() const {
+        return reinterpret_cast<VkPipelineRasterizationStateCreateInfo const*>(this);
+    }
+};
+struct safe_VkPipelineMultisampleStateCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineMultisampleStateCreateFlags flags;
+    VkSampleCountFlagBits rasterizationSamples;
+    VkBool32 sampleShadingEnable;
+    float minSampleShading;
+    const VkSampleMask* pSampleMask{};
+    VkBool32 alphaToCoverageEnable;
+    VkBool32 alphaToOneEnable;
+
+    safe_VkPipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineMultisampleStateCreateInfo(const safe_VkPipelineMultisampleStateCreateInfo& copy_src);
+    safe_VkPipelineMultisampleStateCreateInfo& operator=(const safe_VkPipelineMultisampleStateCreateInfo& copy_src);
+    safe_VkPipelineMultisampleStateCreateInfo();
+    ~safe_VkPipelineMultisampleStateCreateInfo();
+    void initialize(const VkPipelineMultisampleStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineMultisampleStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineMultisampleStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineMultisampleStateCreateInfo*>(this); }
+    VkPipelineMultisampleStateCreateInfo const* ptr() const {
+        return reinterpret_cast<VkPipelineMultisampleStateCreateInfo const*>(this);
+    }
+};
+struct safe_VkPipelineDepthStencilStateCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineDepthStencilStateCreateFlags flags;
+    VkBool32 depthTestEnable;
+    VkBool32 depthWriteEnable;
+    VkCompareOp depthCompareOp;
+    VkBool32 depthBoundsTestEnable;
+    VkBool32 stencilTestEnable;
+    VkStencilOpState front;
+    VkStencilOpState back;
+    float minDepthBounds;
+    float maxDepthBounds;
+
+    safe_VkPipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineDepthStencilStateCreateInfo(const safe_VkPipelineDepthStencilStateCreateInfo& copy_src);
+    safe_VkPipelineDepthStencilStateCreateInfo& operator=(const safe_VkPipelineDepthStencilStateCreateInfo& copy_src);
+    safe_VkPipelineDepthStencilStateCreateInfo();
+    ~safe_VkPipelineDepthStencilStateCreateInfo();
+    void initialize(const VkPipelineDepthStencilStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineDepthStencilStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineDepthStencilStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineDepthStencilStateCreateInfo*>(this); }
+    VkPipelineDepthStencilStateCreateInfo const* ptr() const {
+        return reinterpret_cast<VkPipelineDepthStencilStateCreateInfo const*>(this);
+    }
+};
+struct safe_VkPipelineColorBlendStateCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineColorBlendStateCreateFlags flags;
+    VkBool32 logicOpEnable;
+    VkLogicOp logicOp;
+    uint32_t attachmentCount;
+    const VkPipelineColorBlendAttachmentState* pAttachments{};
+    float blendConstants[4];
+
+    safe_VkPipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkPipelineColorBlendStateCreateInfo(const safe_VkPipelineColorBlendStateCreateInfo& copy_src);
+    safe_VkPipelineColorBlendStateCreateInfo& operator=(const safe_VkPipelineColorBlendStateCreateInfo& copy_src);
+    safe_VkPipelineColorBlendStateCreateInfo();
+    ~safe_VkPipelineColorBlendStateCreateInfo();
+    void initialize(const VkPipelineColorBlendStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineColorBlendStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineColorBlendStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineColorBlendStateCreateInfo*>(this); }
+    VkPipelineColorBlendStateCreateInfo const* ptr() const {
+        return reinterpret_cast<VkPipelineColorBlendStateCreateInfo const*>(this);
+    }
+};
+struct safe_VkPipelineDynamicStateCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineDynamicStateCreateFlags flags;
+    uint32_t dynamicStateCount;
+    const VkDynamicState* pDynamicStates{};
+
+    safe_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkPipelineDynamicStateCreateInfo(const safe_VkPipelineDynamicStateCreateInfo& copy_src);
+    safe_VkPipelineDynamicStateCreateInfo& operator=(const safe_VkPipelineDynamicStateCreateInfo& copy_src);
+    safe_VkPipelineDynamicStateCreateInfo();
+    ~safe_VkPipelineDynamicStateCreateInfo();
+    void initialize(const VkPipelineDynamicStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineDynamicStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineDynamicStateCreateInfo* ptr() { return reinterpret_cast<VkPipelineDynamicStateCreateInfo*>(this); }
+    VkPipelineDynamicStateCreateInfo const* ptr() const { return reinterpret_cast<VkPipelineDynamicStateCreateInfo const*>(this); }
+};
+struct safe_VkGraphicsPipelineCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineCreateFlags flags;
+    uint32_t stageCount;
+    safe_VkPipelineShaderStageCreateInfo* pStages{};
+    safe_VkPipelineVertexInputStateCreateInfo* pVertexInputState{};
+    safe_VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState{};
+    safe_VkPipelineTessellationStateCreateInfo* pTessellationState{};
+    safe_VkPipelineViewportStateCreateInfo* pViewportState{};
+    safe_VkPipelineRasterizationStateCreateInfo* pRasterizationState{};
+    safe_VkPipelineMultisampleStateCreateInfo* pMultisampleState{};
+    safe_VkPipelineDepthStencilStateCreateInfo* pDepthStencilState{};
+    safe_VkPipelineColorBlendStateCreateInfo* pColorBlendState{};
+    safe_VkPipelineDynamicStateCreateInfo* pDynamicState{};
+    VkPipelineLayout layout;
+    VkRenderPass renderPass;
+    uint32_t subpass;
+    VkPipeline basePipelineHandle;
+    int32_t basePipelineIndex;
+
+    safe_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo* in_struct, const bool uses_color_attachment,
+                                      const bool uses_depthstencil_attachment, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    safe_VkGraphicsPipelineCreateInfo(const safe_VkGraphicsPipelineCreateInfo& copy_src);
+    safe_VkGraphicsPipelineCreateInfo& operator=(const safe_VkGraphicsPipelineCreateInfo& copy_src);
+    safe_VkGraphicsPipelineCreateInfo();
+    ~safe_VkGraphicsPipelineCreateInfo();
+    void initialize(const VkGraphicsPipelineCreateInfo* in_struct, const bool uses_color_attachment,
+                    const bool uses_depthstencil_attachment, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkGraphicsPipelineCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkGraphicsPipelineCreateInfo* ptr() { return reinterpret_cast<VkGraphicsPipelineCreateInfo*>(this); }
+    VkGraphicsPipelineCreateInfo const* ptr() const { return reinterpret_cast<VkGraphicsPipelineCreateInfo const*>(this); }
+};
+struct safe_VkPipelineLayoutCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineLayoutCreateFlags flags;
+    uint32_t setLayoutCount;
+    VkDescriptorSetLayout* pSetLayouts{};
+    uint32_t pushConstantRangeCount;
+    const VkPushConstantRange* pPushConstantRanges{};
+
+    safe_VkPipelineLayoutCreateInfo(const VkPipelineLayoutCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    safe_VkPipelineLayoutCreateInfo(const safe_VkPipelineLayoutCreateInfo& copy_src);
+    safe_VkPipelineLayoutCreateInfo& operator=(const safe_VkPipelineLayoutCreateInfo& copy_src);
+    safe_VkPipelineLayoutCreateInfo();
+    ~safe_VkPipelineLayoutCreateInfo();
+    void initialize(const VkPipelineLayoutCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineLayoutCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineLayoutCreateInfo* ptr() { return reinterpret_cast<VkPipelineLayoutCreateInfo*>(this); }
+    VkPipelineLayoutCreateInfo const* ptr() const { return reinterpret_cast<VkPipelineLayoutCreateInfo const*>(this); }
+};
+struct safe_VkSamplerCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSamplerCreateFlags flags;
+    VkFilter magFilter;
+    VkFilter minFilter;
+    VkSamplerMipmapMode mipmapMode;
+    VkSamplerAddressMode addressModeU;
+    VkSamplerAddressMode addressModeV;
+    VkSamplerAddressMode addressModeW;
+    float mipLodBias;
+    VkBool32 anisotropyEnable;
+    float maxAnisotropy;
+    VkBool32 compareEnable;
+    VkCompareOp compareOp;
+    float minLod;
+    float maxLod;
+    VkBorderColor borderColor;
+    VkBool32 unnormalizedCoordinates;
+
+    safe_VkSamplerCreateInfo(const VkSamplerCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSamplerCreateInfo(const safe_VkSamplerCreateInfo& copy_src);
+    safe_VkSamplerCreateInfo& operator=(const safe_VkSamplerCreateInfo& copy_src);
+    safe_VkSamplerCreateInfo();
+    ~safe_VkSamplerCreateInfo();
+    void initialize(const VkSamplerCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSamplerCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSamplerCreateInfo* ptr() { return reinterpret_cast<VkSamplerCreateInfo*>(this); }
+    VkSamplerCreateInfo const* ptr() const { return reinterpret_cast<VkSamplerCreateInfo const*>(this); }
+};
+struct safe_VkCopyDescriptorSet {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDescriptorSet srcSet;
+    uint32_t srcBinding;
+    uint32_t srcArrayElement;
+    VkDescriptorSet dstSet;
+    uint32_t dstBinding;
+    uint32_t dstArrayElement;
+    uint32_t descriptorCount;
+
+    safe_VkCopyDescriptorSet(const VkCopyDescriptorSet* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkCopyDescriptorSet(const safe_VkCopyDescriptorSet& copy_src);
+    safe_VkCopyDescriptorSet& operator=(const safe_VkCopyDescriptorSet& copy_src);
+    safe_VkCopyDescriptorSet();
+    ~safe_VkCopyDescriptorSet();
+    void initialize(const VkCopyDescriptorSet* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCopyDescriptorSet* copy_src, PNextCopyState* copy_state = {});
+    VkCopyDescriptorSet* ptr() { return reinterpret_cast<VkCopyDescriptorSet*>(this); }
+    VkCopyDescriptorSet const* ptr() const { return reinterpret_cast<VkCopyDescriptorSet const*>(this); }
+};
+struct safe_VkDescriptorPoolCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDescriptorPoolCreateFlags flags;
+    uint32_t maxSets;
+    uint32_t poolSizeCount;
+    const VkDescriptorPoolSize* pPoolSizes{};
+
+    safe_VkDescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    safe_VkDescriptorPoolCreateInfo(const safe_VkDescriptorPoolCreateInfo& copy_src);
+    safe_VkDescriptorPoolCreateInfo& operator=(const safe_VkDescriptorPoolCreateInfo& copy_src);
+    safe_VkDescriptorPoolCreateInfo();
+    ~safe_VkDescriptorPoolCreateInfo();
+    void initialize(const VkDescriptorPoolCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDescriptorPoolCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorPoolCreateInfo* ptr() { return reinterpret_cast<VkDescriptorPoolCreateInfo*>(this); }
+    VkDescriptorPoolCreateInfo const* ptr() const { return reinterpret_cast<VkDescriptorPoolCreateInfo const*>(this); }
+};
+struct safe_VkDescriptorSetAllocateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDescriptorPool descriptorPool;
+    uint32_t descriptorSetCount;
+    VkDescriptorSetLayout* pSetLayouts{};
+
+    safe_VkDescriptorSetAllocateInfo(const VkDescriptorSetAllocateInfo* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    safe_VkDescriptorSetAllocateInfo(const safe_VkDescriptorSetAllocateInfo& copy_src);
+    safe_VkDescriptorSetAllocateInfo& operator=(const safe_VkDescriptorSetAllocateInfo& copy_src);
+    safe_VkDescriptorSetAllocateInfo();
+    ~safe_VkDescriptorSetAllocateInfo();
+    void initialize(const VkDescriptorSetAllocateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDescriptorSetAllocateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorSetAllocateInfo* ptr() { return reinterpret_cast<VkDescriptorSetAllocateInfo*>(this); }
+    VkDescriptorSetAllocateInfo const* ptr() const { return reinterpret_cast<VkDescriptorSetAllocateInfo const*>(this); }
+};
+struct safe_VkDescriptorSetLayoutBinding {
+    uint32_t binding;
+    VkDescriptorType descriptorType;
+    uint32_t descriptorCount;
+    VkShaderStageFlags stageFlags;
+    VkSampler* pImmutableSamplers{};
+
+    safe_VkDescriptorSetLayoutBinding(const VkDescriptorSetLayoutBinding* in_struct, PNextCopyState* copy_state = {});
+    safe_VkDescriptorSetLayoutBinding(const safe_VkDescriptorSetLayoutBinding& copy_src);
+    safe_VkDescriptorSetLayoutBinding& operator=(const safe_VkDescriptorSetLayoutBinding& copy_src);
+    safe_VkDescriptorSetLayoutBinding();
+    ~safe_VkDescriptorSetLayoutBinding();
+    void initialize(const VkDescriptorSetLayoutBinding* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDescriptorSetLayoutBinding* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorSetLayoutBinding* ptr() { return reinterpret_cast<VkDescriptorSetLayoutBinding*>(this); }
+    VkDescriptorSetLayoutBinding const* ptr() const { return reinterpret_cast<VkDescriptorSetLayoutBinding const*>(this); }
+};
+struct safe_VkDescriptorSetLayoutCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDescriptorSetLayoutCreateFlags flags;
+    uint32_t bindingCount;
+    safe_VkDescriptorSetLayoutBinding* pBindings{};
+
+    safe_VkDescriptorSetLayoutCreateInfo(const VkDescriptorSetLayoutCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkDescriptorSetLayoutCreateInfo(const safe_VkDescriptorSetLayoutCreateInfo& copy_src);
+    safe_VkDescriptorSetLayoutCreateInfo& operator=(const safe_VkDescriptorSetLayoutCreateInfo& copy_src);
+    safe_VkDescriptorSetLayoutCreateInfo();
+    ~safe_VkDescriptorSetLayoutCreateInfo();
+    void initialize(const VkDescriptorSetLayoutCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDescriptorSetLayoutCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorSetLayoutCreateInfo* ptr() { return reinterpret_cast<VkDescriptorSetLayoutCreateInfo*>(this); }
+    VkDescriptorSetLayoutCreateInfo const* ptr() const { return reinterpret_cast<VkDescriptorSetLayoutCreateInfo const*>(this); }
+};
+struct safe_VkWriteDescriptorSet {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDescriptorSet dstSet;
+    uint32_t dstBinding;
+    uint32_t dstArrayElement;
+    uint32_t descriptorCount;
+    VkDescriptorType descriptorType;
+    VkDescriptorImageInfo* pImageInfo{};
+    VkDescriptorBufferInfo* pBufferInfo{};
+    VkBufferView* pTexelBufferView{};
+
+    safe_VkWriteDescriptorSet(const VkWriteDescriptorSet* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkWriteDescriptorSet(const safe_VkWriteDescriptorSet& copy_src);
+    safe_VkWriteDescriptorSet& operator=(const safe_VkWriteDescriptorSet& copy_src);
+    safe_VkWriteDescriptorSet();
+    ~safe_VkWriteDescriptorSet();
+    void initialize(const VkWriteDescriptorSet* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkWriteDescriptorSet* copy_src, PNextCopyState* copy_state = {});
+    VkWriteDescriptorSet* ptr() { return reinterpret_cast<VkWriteDescriptorSet*>(this); }
+    VkWriteDescriptorSet const* ptr() const { return reinterpret_cast<VkWriteDescriptorSet const*>(this); }
+};
+struct safe_VkFramebufferCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkFramebufferCreateFlags flags;
+    VkRenderPass renderPass;
+    uint32_t attachmentCount;
+    VkImageView* pAttachments{};
+    uint32_t width;
+    uint32_t height;
+    uint32_t layers;
+
+    safe_VkFramebufferCreateInfo(const VkFramebufferCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkFramebufferCreateInfo(const safe_VkFramebufferCreateInfo& copy_src);
+    safe_VkFramebufferCreateInfo& operator=(const safe_VkFramebufferCreateInfo& copy_src);
+    safe_VkFramebufferCreateInfo();
+    ~safe_VkFramebufferCreateInfo();
+    void initialize(const VkFramebufferCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkFramebufferCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkFramebufferCreateInfo* ptr() { return reinterpret_cast<VkFramebufferCreateInfo*>(this); }
+    VkFramebufferCreateInfo const* ptr() const { return reinterpret_cast<VkFramebufferCreateInfo const*>(this); }
+};
+struct safe_VkSubpassDescription {
+    VkSubpassDescriptionFlags flags;
+    VkPipelineBindPoint pipelineBindPoint;
+    uint32_t inputAttachmentCount;
+    const VkAttachmentReference* pInputAttachments{};
+    uint32_t colorAttachmentCount;
+    const VkAttachmentReference* pColorAttachments{};
+    const VkAttachmentReference* pResolveAttachments{};
+    const VkAttachmentReference* pDepthStencilAttachment{};
+    uint32_t preserveAttachmentCount;
+    const uint32_t* pPreserveAttachments{};
+
+    safe_VkSubpassDescription(const VkSubpassDescription* in_struct, PNextCopyState* copy_state = {});
+    safe_VkSubpassDescription(const safe_VkSubpassDescription& copy_src);
+    safe_VkSubpassDescription& operator=(const safe_VkSubpassDescription& copy_src);
+    safe_VkSubpassDescription();
+    ~safe_VkSubpassDescription();
+    void initialize(const VkSubpassDescription* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSubpassDescription* copy_src, PNextCopyState* copy_state = {});
+    VkSubpassDescription* ptr() { return reinterpret_cast<VkSubpassDescription*>(this); }
+    VkSubpassDescription const* ptr() const { return reinterpret_cast<VkSubpassDescription const*>(this); }
+};
+struct safe_VkRenderPassCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkRenderPassCreateFlags flags;
+    uint32_t attachmentCount;
+    const VkAttachmentDescription* pAttachments{};
+    uint32_t subpassCount;
+    safe_VkSubpassDescription* pSubpasses{};
+    uint32_t dependencyCount;
+    const VkSubpassDependency* pDependencies{};
+
+    safe_VkRenderPassCreateInfo(const VkRenderPassCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkRenderPassCreateInfo(const safe_VkRenderPassCreateInfo& copy_src);
+    safe_VkRenderPassCreateInfo& operator=(const safe_VkRenderPassCreateInfo& copy_src);
+    safe_VkRenderPassCreateInfo();
+    ~safe_VkRenderPassCreateInfo();
+    void initialize(const VkRenderPassCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderPassCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassCreateInfo* ptr() { return reinterpret_cast<VkRenderPassCreateInfo*>(this); }
+    VkRenderPassCreateInfo const* ptr() const { return reinterpret_cast<VkRenderPassCreateInfo const*>(this); }
+};
+struct safe_VkCommandPoolCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkCommandPoolCreateFlags flags;
+    uint32_t queueFamilyIndex;
+
+    safe_VkCommandPoolCreateInfo(const VkCommandPoolCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkCommandPoolCreateInfo(const safe_VkCommandPoolCreateInfo& copy_src);
+    safe_VkCommandPoolCreateInfo& operator=(const safe_VkCommandPoolCreateInfo& copy_src);
+    safe_VkCommandPoolCreateInfo();
+    ~safe_VkCommandPoolCreateInfo();
+    void initialize(const VkCommandPoolCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCommandPoolCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkCommandPoolCreateInfo* ptr() { return reinterpret_cast<VkCommandPoolCreateInfo*>(this); }
+    VkCommandPoolCreateInfo const* ptr() const { return reinterpret_cast<VkCommandPoolCreateInfo const*>(this); }
+};
+struct safe_VkCommandBufferAllocateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkCommandPool commandPool;
+    VkCommandBufferLevel level;
+    uint32_t commandBufferCount;
+
+    safe_VkCommandBufferAllocateInfo(const VkCommandBufferAllocateInfo* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    safe_VkCommandBufferAllocateInfo(const safe_VkCommandBufferAllocateInfo& copy_src);
+    safe_VkCommandBufferAllocateInfo& operator=(const safe_VkCommandBufferAllocateInfo& copy_src);
+    safe_VkCommandBufferAllocateInfo();
+    ~safe_VkCommandBufferAllocateInfo();
+    void initialize(const VkCommandBufferAllocateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCommandBufferAllocateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkCommandBufferAllocateInfo* ptr() { return reinterpret_cast<VkCommandBufferAllocateInfo*>(this); }
+    VkCommandBufferAllocateInfo const* ptr() const { return reinterpret_cast<VkCommandBufferAllocateInfo const*>(this); }
+};
+struct safe_VkCommandBufferInheritanceInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkRenderPass renderPass;
+    uint32_t subpass;
+    VkFramebuffer framebuffer;
+    VkBool32 occlusionQueryEnable;
+    VkQueryControlFlags queryFlags;
+    VkQueryPipelineStatisticFlags pipelineStatistics;
+
+    safe_VkCommandBufferInheritanceInfo(const VkCommandBufferInheritanceInfo* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkCommandBufferInheritanceInfo(const safe_VkCommandBufferInheritanceInfo& copy_src);
+    safe_VkCommandBufferInheritanceInfo& operator=(const safe_VkCommandBufferInheritanceInfo& copy_src);
+    safe_VkCommandBufferInheritanceInfo();
+    ~safe_VkCommandBufferInheritanceInfo();
+    void initialize(const VkCommandBufferInheritanceInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCommandBufferInheritanceInfo* copy_src, PNextCopyState* copy_state = {});
+    VkCommandBufferInheritanceInfo* ptr() { return reinterpret_cast<VkCommandBufferInheritanceInfo*>(this); }
+    VkCommandBufferInheritanceInfo const* ptr() const { return reinterpret_cast<VkCommandBufferInheritanceInfo const*>(this); }
+};
+struct safe_VkCommandBufferBeginInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkCommandBufferUsageFlags flags;
+    safe_VkCommandBufferInheritanceInfo* pInheritanceInfo{};
+
+    safe_VkCommandBufferBeginInfo(const VkCommandBufferBeginInfo* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    safe_VkCommandBufferBeginInfo(const safe_VkCommandBufferBeginInfo& copy_src);
+    safe_VkCommandBufferBeginInfo& operator=(const safe_VkCommandBufferBeginInfo& copy_src);
+    safe_VkCommandBufferBeginInfo();
+    ~safe_VkCommandBufferBeginInfo();
+    void initialize(const VkCommandBufferBeginInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCommandBufferBeginInfo* copy_src, PNextCopyState* copy_state = {});
+    VkCommandBufferBeginInfo* ptr() { return reinterpret_cast<VkCommandBufferBeginInfo*>(this); }
+    VkCommandBufferBeginInfo const* ptr() const { return reinterpret_cast<VkCommandBufferBeginInfo const*>(this); }
+};
+struct safe_VkRenderPassBeginInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkRenderPass renderPass;
+    VkFramebuffer framebuffer;
+    VkRect2D renderArea;
+    uint32_t clearValueCount;
+    const VkClearValue* pClearValues{};
+
+    safe_VkRenderPassBeginInfo(const VkRenderPassBeginInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkRenderPassBeginInfo(const safe_VkRenderPassBeginInfo& copy_src);
+    safe_VkRenderPassBeginInfo& operator=(const safe_VkRenderPassBeginInfo& copy_src);
+    safe_VkRenderPassBeginInfo();
+    ~safe_VkRenderPassBeginInfo();
+    void initialize(const VkRenderPassBeginInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderPassBeginInfo* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassBeginInfo* ptr() { return reinterpret_cast<VkRenderPassBeginInfo*>(this); }
+    VkRenderPassBeginInfo const* ptr() const { return reinterpret_cast<VkRenderPassBeginInfo const*>(this); }
+};
+struct safe_VkPhysicalDeviceSubgroupProperties {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t subgroupSize;
+    VkShaderStageFlags supportedStages;
+    VkSubgroupFeatureFlags supportedOperations;
+    VkBool32 quadOperationsInAllStages;
+
+    safe_VkPhysicalDeviceSubgroupProperties(const VkPhysicalDeviceSubgroupProperties* in_struct, PNextCopyState* copy_state = {},
+                                            bool copy_pnext = true);
+    safe_VkPhysicalDeviceSubgroupProperties(const safe_VkPhysicalDeviceSubgroupProperties& copy_src);
+    safe_VkPhysicalDeviceSubgroupProperties& operator=(const safe_VkPhysicalDeviceSubgroupProperties& copy_src);
+    safe_VkPhysicalDeviceSubgroupProperties();
+    ~safe_VkPhysicalDeviceSubgroupProperties();
+    void initialize(const VkPhysicalDeviceSubgroupProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceSubgroupProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSubgroupProperties* ptr() { return reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(this); }
+    VkPhysicalDeviceSubgroupProperties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceSubgroupProperties const*>(this);
+    }
+};
+struct safe_VkBindBufferMemoryInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBuffer buffer;
+    VkDeviceMemory memory;
+    VkDeviceSize memoryOffset;
+
+    safe_VkBindBufferMemoryInfo(const VkBindBufferMemoryInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkBindBufferMemoryInfo(const safe_VkBindBufferMemoryInfo& copy_src);
+    safe_VkBindBufferMemoryInfo& operator=(const safe_VkBindBufferMemoryInfo& copy_src);
+    safe_VkBindBufferMemoryInfo();
+    ~safe_VkBindBufferMemoryInfo();
+    void initialize(const VkBindBufferMemoryInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBindBufferMemoryInfo* copy_src, PNextCopyState* copy_state = {});
+    VkBindBufferMemoryInfo* ptr() { return reinterpret_cast<VkBindBufferMemoryInfo*>(this); }
+    VkBindBufferMemoryInfo const* ptr() const { return reinterpret_cast<VkBindBufferMemoryInfo const*>(this); }
+};
+struct safe_VkBindImageMemoryInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImage image;
+    VkDeviceMemory memory;
+    VkDeviceSize memoryOffset;
+
+    safe_VkBindImageMemoryInfo(const VkBindImageMemoryInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkBindImageMemoryInfo(const safe_VkBindImageMemoryInfo& copy_src);
+    safe_VkBindImageMemoryInfo& operator=(const safe_VkBindImageMemoryInfo& copy_src);
+    safe_VkBindImageMemoryInfo();
+    ~safe_VkBindImageMemoryInfo();
+    void initialize(const VkBindImageMemoryInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBindImageMemoryInfo* copy_src, PNextCopyState* copy_state = {});
+    VkBindImageMemoryInfo* ptr() { return reinterpret_cast<VkBindImageMemoryInfo*>(this); }
+    VkBindImageMemoryInfo const* ptr() const { return reinterpret_cast<VkBindImageMemoryInfo const*>(this); }
+};
+struct safe_VkPhysicalDevice16BitStorageFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 storageBuffer16BitAccess;
+    VkBool32 uniformAndStorageBuffer16BitAccess;
+    VkBool32 storagePushConstant16;
+    VkBool32 storageInputOutput16;
+
+    safe_VkPhysicalDevice16BitStorageFeatures(const VkPhysicalDevice16BitStorageFeatures* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDevice16BitStorageFeatures(const safe_VkPhysicalDevice16BitStorageFeatures& copy_src);
+    safe_VkPhysicalDevice16BitStorageFeatures& operator=(const safe_VkPhysicalDevice16BitStorageFeatures& copy_src);
+    safe_VkPhysicalDevice16BitStorageFeatures();
+    ~safe_VkPhysicalDevice16BitStorageFeatures();
+    void initialize(const VkPhysicalDevice16BitStorageFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevice16BitStorageFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevice16BitStorageFeatures* ptr() { return reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(this); }
+    VkPhysicalDevice16BitStorageFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevice16BitStorageFeatures const*>(this);
+    }
+};
+struct safe_VkMemoryDedicatedRequirements {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 prefersDedicatedAllocation;
+    VkBool32 requiresDedicatedAllocation;
+
+    safe_VkMemoryDedicatedRequirements(const VkMemoryDedicatedRequirements* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    safe_VkMemoryDedicatedRequirements(const safe_VkMemoryDedicatedRequirements& copy_src);
+    safe_VkMemoryDedicatedRequirements& operator=(const safe_VkMemoryDedicatedRequirements& copy_src);
+    safe_VkMemoryDedicatedRequirements();
+    ~safe_VkMemoryDedicatedRequirements();
+    void initialize(const VkMemoryDedicatedRequirements* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMemoryDedicatedRequirements* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryDedicatedRequirements* ptr() { return reinterpret_cast<VkMemoryDedicatedRequirements*>(this); }
+    VkMemoryDedicatedRequirements const* ptr() const { return reinterpret_cast<VkMemoryDedicatedRequirements const*>(this); }
+};
+struct safe_VkMemoryDedicatedAllocateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImage image;
+    VkBuffer buffer;
+
+    safe_VkMemoryDedicatedAllocateInfo(const VkMemoryDedicatedAllocateInfo* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    safe_VkMemoryDedicatedAllocateInfo(const safe_VkMemoryDedicatedAllocateInfo& copy_src);
+    safe_VkMemoryDedicatedAllocateInfo& operator=(const safe_VkMemoryDedicatedAllocateInfo& copy_src);
+    safe_VkMemoryDedicatedAllocateInfo();
+    ~safe_VkMemoryDedicatedAllocateInfo();
+    void initialize(const VkMemoryDedicatedAllocateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMemoryDedicatedAllocateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryDedicatedAllocateInfo* ptr() { return reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(this); }
+    VkMemoryDedicatedAllocateInfo const* ptr() const { return reinterpret_cast<VkMemoryDedicatedAllocateInfo const*>(this); }
+};
+struct safe_VkMemoryAllocateFlagsInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkMemoryAllocateFlags flags;
+    uint32_t deviceMask;
+
+    safe_VkMemoryAllocateFlagsInfo(const VkMemoryAllocateFlagsInfo* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    safe_VkMemoryAllocateFlagsInfo(const safe_VkMemoryAllocateFlagsInfo& copy_src);
+    safe_VkMemoryAllocateFlagsInfo& operator=(const safe_VkMemoryAllocateFlagsInfo& copy_src);
+    safe_VkMemoryAllocateFlagsInfo();
+    ~safe_VkMemoryAllocateFlagsInfo();
+    void initialize(const VkMemoryAllocateFlagsInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMemoryAllocateFlagsInfo* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryAllocateFlagsInfo* ptr() { return reinterpret_cast<VkMemoryAllocateFlagsInfo*>(this); }
+    VkMemoryAllocateFlagsInfo const* ptr() const { return reinterpret_cast<VkMemoryAllocateFlagsInfo const*>(this); }
+};
+struct safe_VkDeviceGroupRenderPassBeginInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t deviceMask;
+    uint32_t deviceRenderAreaCount;
+    const VkRect2D* pDeviceRenderAreas{};
+
+    safe_VkDeviceGroupRenderPassBeginInfo(const VkDeviceGroupRenderPassBeginInfo* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkDeviceGroupRenderPassBeginInfo(const safe_VkDeviceGroupRenderPassBeginInfo& copy_src);
+    safe_VkDeviceGroupRenderPassBeginInfo& operator=(const safe_VkDeviceGroupRenderPassBeginInfo& copy_src);
+    safe_VkDeviceGroupRenderPassBeginInfo();
+    ~safe_VkDeviceGroupRenderPassBeginInfo();
+    void initialize(const VkDeviceGroupRenderPassBeginInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDeviceGroupRenderPassBeginInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceGroupRenderPassBeginInfo* ptr() { return reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(this); }
+    VkDeviceGroupRenderPassBeginInfo const* ptr() const { return reinterpret_cast<VkDeviceGroupRenderPassBeginInfo const*>(this); }
+};
+struct safe_VkDeviceGroupCommandBufferBeginInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t deviceMask;
+
+    safe_VkDeviceGroupCommandBufferBeginInfo(const VkDeviceGroupCommandBufferBeginInfo* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkDeviceGroupCommandBufferBeginInfo(const safe_VkDeviceGroupCommandBufferBeginInfo& copy_src);
+    safe_VkDeviceGroupCommandBufferBeginInfo& operator=(const safe_VkDeviceGroupCommandBufferBeginInfo& copy_src);
+    safe_VkDeviceGroupCommandBufferBeginInfo();
+    ~safe_VkDeviceGroupCommandBufferBeginInfo();
+    void initialize(const VkDeviceGroupCommandBufferBeginInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDeviceGroupCommandBufferBeginInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceGroupCommandBufferBeginInfo* ptr() { return reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(this); }
+    VkDeviceGroupCommandBufferBeginInfo const* ptr() const {
+        return reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo const*>(this);
+    }
+};
+struct safe_VkDeviceGroupSubmitInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t waitSemaphoreCount;
+    const uint32_t* pWaitSemaphoreDeviceIndices{};
+    uint32_t commandBufferCount;
+    const uint32_t* pCommandBufferDeviceMasks{};
+    uint32_t signalSemaphoreCount;
+    const uint32_t* pSignalSemaphoreDeviceIndices{};
+
+    safe_VkDeviceGroupSubmitInfo(const VkDeviceGroupSubmitInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDeviceGroupSubmitInfo(const safe_VkDeviceGroupSubmitInfo& copy_src);
+    safe_VkDeviceGroupSubmitInfo& operator=(const safe_VkDeviceGroupSubmitInfo& copy_src);
+    safe_VkDeviceGroupSubmitInfo();
+    ~safe_VkDeviceGroupSubmitInfo();
+    void initialize(const VkDeviceGroupSubmitInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDeviceGroupSubmitInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceGroupSubmitInfo* ptr() { return reinterpret_cast<VkDeviceGroupSubmitInfo*>(this); }
+    VkDeviceGroupSubmitInfo const* ptr() const { return reinterpret_cast<VkDeviceGroupSubmitInfo const*>(this); }
+};
+struct safe_VkDeviceGroupBindSparseInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t resourceDeviceIndex;
+    uint32_t memoryDeviceIndex;
+
+    safe_VkDeviceGroupBindSparseInfo(const VkDeviceGroupBindSparseInfo* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    safe_VkDeviceGroupBindSparseInfo(const safe_VkDeviceGroupBindSparseInfo& copy_src);
+    safe_VkDeviceGroupBindSparseInfo& operator=(const safe_VkDeviceGroupBindSparseInfo& copy_src);
+    safe_VkDeviceGroupBindSparseInfo();
+    ~safe_VkDeviceGroupBindSparseInfo();
+    void initialize(const VkDeviceGroupBindSparseInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDeviceGroupBindSparseInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceGroupBindSparseInfo* ptr() { return reinterpret_cast<VkDeviceGroupBindSparseInfo*>(this); }
+    VkDeviceGroupBindSparseInfo const* ptr() const { return reinterpret_cast<VkDeviceGroupBindSparseInfo const*>(this); }
+};
+struct safe_VkBindBufferMemoryDeviceGroupInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t deviceIndexCount;
+    const uint32_t* pDeviceIndices{};
+
+    safe_VkBindBufferMemoryDeviceGroupInfo(const VkBindBufferMemoryDeviceGroupInfo* in_struct, PNextCopyState* copy_state = {},
+                                           bool copy_pnext = true);
+    safe_VkBindBufferMemoryDeviceGroupInfo(const safe_VkBindBufferMemoryDeviceGroupInfo& copy_src);
+    safe_VkBindBufferMemoryDeviceGroupInfo& operator=(const safe_VkBindBufferMemoryDeviceGroupInfo& copy_src);
+    safe_VkBindBufferMemoryDeviceGroupInfo();
+    ~safe_VkBindBufferMemoryDeviceGroupInfo();
+    void initialize(const VkBindBufferMemoryDeviceGroupInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBindBufferMemoryDeviceGroupInfo* copy_src, PNextCopyState* copy_state = {});
+    VkBindBufferMemoryDeviceGroupInfo* ptr() { return reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(this); }
+    VkBindBufferMemoryDeviceGroupInfo const* ptr() const {
+        return reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo const*>(this);
+    }
+};
+struct safe_VkBindImageMemoryDeviceGroupInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t deviceIndexCount;
+    const uint32_t* pDeviceIndices{};
+    uint32_t splitInstanceBindRegionCount;
+    const VkRect2D* pSplitInstanceBindRegions{};
+
+    safe_VkBindImageMemoryDeviceGroupInfo(const VkBindImageMemoryDeviceGroupInfo* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkBindImageMemoryDeviceGroupInfo(const safe_VkBindImageMemoryDeviceGroupInfo& copy_src);
+    safe_VkBindImageMemoryDeviceGroupInfo& operator=(const safe_VkBindImageMemoryDeviceGroupInfo& copy_src);
+    safe_VkBindImageMemoryDeviceGroupInfo();
+    ~safe_VkBindImageMemoryDeviceGroupInfo();
+    void initialize(const VkBindImageMemoryDeviceGroupInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBindImageMemoryDeviceGroupInfo* copy_src, PNextCopyState* copy_state = {});
+    VkBindImageMemoryDeviceGroupInfo* ptr() { return reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(this); }
+    VkBindImageMemoryDeviceGroupInfo const* ptr() const { return reinterpret_cast<VkBindImageMemoryDeviceGroupInfo const*>(this); }
+};
+struct safe_VkPhysicalDeviceGroupProperties {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t physicalDeviceCount;
+    VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];
+    VkBool32 subsetAllocation;
+
+    safe_VkPhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkPhysicalDeviceGroupProperties(const safe_VkPhysicalDeviceGroupProperties& copy_src);
+    safe_VkPhysicalDeviceGroupProperties& operator=(const safe_VkPhysicalDeviceGroupProperties& copy_src);
+    safe_VkPhysicalDeviceGroupProperties();
+    ~safe_VkPhysicalDeviceGroupProperties();
+    void initialize(const VkPhysicalDeviceGroupProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceGroupProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceGroupProperties* ptr() { return reinterpret_cast<VkPhysicalDeviceGroupProperties*>(this); }
+    VkPhysicalDeviceGroupProperties const* ptr() const { return reinterpret_cast<VkPhysicalDeviceGroupProperties const*>(this); }
+};
+struct safe_VkDeviceGroupDeviceCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t physicalDeviceCount;
+    VkPhysicalDevice* pPhysicalDevices{};
+
+    safe_VkDeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    safe_VkDeviceGroupDeviceCreateInfo(const safe_VkDeviceGroupDeviceCreateInfo& copy_src);
+    safe_VkDeviceGroupDeviceCreateInfo& operator=(const safe_VkDeviceGroupDeviceCreateInfo& copy_src);
+    safe_VkDeviceGroupDeviceCreateInfo();
+    ~safe_VkDeviceGroupDeviceCreateInfo();
+    void initialize(const VkDeviceGroupDeviceCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDeviceGroupDeviceCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceGroupDeviceCreateInfo* ptr() { return reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(this); }
+    VkDeviceGroupDeviceCreateInfo const* ptr() const { return reinterpret_cast<VkDeviceGroupDeviceCreateInfo const*>(this); }
+};
+struct safe_VkBufferMemoryRequirementsInfo2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBuffer buffer;
+
+    safe_VkBufferMemoryRequirementsInfo2(const VkBufferMemoryRequirementsInfo2* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkBufferMemoryRequirementsInfo2(const safe_VkBufferMemoryRequirementsInfo2& copy_src);
+    safe_VkBufferMemoryRequirementsInfo2& operator=(const safe_VkBufferMemoryRequirementsInfo2& copy_src);
+    safe_VkBufferMemoryRequirementsInfo2();
+    ~safe_VkBufferMemoryRequirementsInfo2();
+    void initialize(const VkBufferMemoryRequirementsInfo2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBufferMemoryRequirementsInfo2* copy_src, PNextCopyState* copy_state = {});
+    VkBufferMemoryRequirementsInfo2* ptr() { return reinterpret_cast<VkBufferMemoryRequirementsInfo2*>(this); }
+    VkBufferMemoryRequirementsInfo2 const* ptr() const { return reinterpret_cast<VkBufferMemoryRequirementsInfo2 const*>(this); }
+};
+struct safe_VkImageMemoryRequirementsInfo2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImage image;
+
+    safe_VkImageMemoryRequirementsInfo2(const VkImageMemoryRequirementsInfo2* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkImageMemoryRequirementsInfo2(const safe_VkImageMemoryRequirementsInfo2& copy_src);
+    safe_VkImageMemoryRequirementsInfo2& operator=(const safe_VkImageMemoryRequirementsInfo2& copy_src);
+    safe_VkImageMemoryRequirementsInfo2();
+    ~safe_VkImageMemoryRequirementsInfo2();
+    void initialize(const VkImageMemoryRequirementsInfo2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageMemoryRequirementsInfo2* copy_src, PNextCopyState* copy_state = {});
+    VkImageMemoryRequirementsInfo2* ptr() { return reinterpret_cast<VkImageMemoryRequirementsInfo2*>(this); }
+    VkImageMemoryRequirementsInfo2 const* ptr() const { return reinterpret_cast<VkImageMemoryRequirementsInfo2 const*>(this); }
+};
+struct safe_VkImageSparseMemoryRequirementsInfo2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImage image;
+
+    safe_VkImageSparseMemoryRequirementsInfo2(const VkImageSparseMemoryRequirementsInfo2* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkImageSparseMemoryRequirementsInfo2(const safe_VkImageSparseMemoryRequirementsInfo2& copy_src);
+    safe_VkImageSparseMemoryRequirementsInfo2& operator=(const safe_VkImageSparseMemoryRequirementsInfo2& copy_src);
+    safe_VkImageSparseMemoryRequirementsInfo2();
+    ~safe_VkImageSparseMemoryRequirementsInfo2();
+    void initialize(const VkImageSparseMemoryRequirementsInfo2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageSparseMemoryRequirementsInfo2* copy_src, PNextCopyState* copy_state = {});
+    VkImageSparseMemoryRequirementsInfo2* ptr() { return reinterpret_cast<VkImageSparseMemoryRequirementsInfo2*>(this); }
+    VkImageSparseMemoryRequirementsInfo2 const* ptr() const {
+        return reinterpret_cast<VkImageSparseMemoryRequirementsInfo2 const*>(this);
+    }
+};
+struct safe_VkMemoryRequirements2 {
+    VkStructureType sType;
+    void* pNext{};
+    VkMemoryRequirements memoryRequirements;
+
+    safe_VkMemoryRequirements2(const VkMemoryRequirements2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkMemoryRequirements2(const safe_VkMemoryRequirements2& copy_src);
+    safe_VkMemoryRequirements2& operator=(const safe_VkMemoryRequirements2& copy_src);
+    safe_VkMemoryRequirements2();
+    ~safe_VkMemoryRequirements2();
+    void initialize(const VkMemoryRequirements2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMemoryRequirements2* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryRequirements2* ptr() { return reinterpret_cast<VkMemoryRequirements2*>(this); }
+    VkMemoryRequirements2 const* ptr() const { return reinterpret_cast<VkMemoryRequirements2 const*>(this); }
+};
+struct safe_VkSparseImageMemoryRequirements2 {
+    VkStructureType sType;
+    void* pNext{};
+    VkSparseImageMemoryRequirements memoryRequirements;
+
+    safe_VkSparseImageMemoryRequirements2(const VkSparseImageMemoryRequirements2* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkSparseImageMemoryRequirements2(const safe_VkSparseImageMemoryRequirements2& copy_src);
+    safe_VkSparseImageMemoryRequirements2& operator=(const safe_VkSparseImageMemoryRequirements2& copy_src);
+    safe_VkSparseImageMemoryRequirements2();
+    ~safe_VkSparseImageMemoryRequirements2();
+    void initialize(const VkSparseImageMemoryRequirements2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSparseImageMemoryRequirements2* copy_src, PNextCopyState* copy_state = {});
+    VkSparseImageMemoryRequirements2* ptr() { return reinterpret_cast<VkSparseImageMemoryRequirements2*>(this); }
+    VkSparseImageMemoryRequirements2 const* ptr() const { return reinterpret_cast<VkSparseImageMemoryRequirements2 const*>(this); }
+};
+struct safe_VkPhysicalDeviceFeatures2 {
+    VkStructureType sType;
+    void* pNext{};
+    VkPhysicalDeviceFeatures features;
+
+    safe_VkPhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    safe_VkPhysicalDeviceFeatures2(const safe_VkPhysicalDeviceFeatures2& copy_src);
+    safe_VkPhysicalDeviceFeatures2& operator=(const safe_VkPhysicalDeviceFeatures2& copy_src);
+    safe_VkPhysicalDeviceFeatures2();
+    ~safe_VkPhysicalDeviceFeatures2();
+    void initialize(const VkPhysicalDeviceFeatures2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceFeatures2* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFeatures2* ptr() { return reinterpret_cast<VkPhysicalDeviceFeatures2*>(this); }
+    VkPhysicalDeviceFeatures2 const* ptr() const { return reinterpret_cast<VkPhysicalDeviceFeatures2 const*>(this); }
+};
+struct safe_VkPhysicalDeviceProperties2 {
+    VkStructureType sType;
+    void* pNext{};
+    VkPhysicalDeviceProperties properties;
+
+    safe_VkPhysicalDeviceProperties2(const VkPhysicalDeviceProperties2* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    safe_VkPhysicalDeviceProperties2(const safe_VkPhysicalDeviceProperties2& copy_src);
+    safe_VkPhysicalDeviceProperties2& operator=(const safe_VkPhysicalDeviceProperties2& copy_src);
+    safe_VkPhysicalDeviceProperties2();
+    ~safe_VkPhysicalDeviceProperties2();
+    void initialize(const VkPhysicalDeviceProperties2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceProperties2* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceProperties2* ptr() { return reinterpret_cast<VkPhysicalDeviceProperties2*>(this); }
+    VkPhysicalDeviceProperties2 const* ptr() const { return reinterpret_cast<VkPhysicalDeviceProperties2 const*>(this); }
+};
+struct safe_VkFormatProperties2 {
+    VkStructureType sType;
+    void* pNext{};
+    VkFormatProperties formatProperties;
+
+    safe_VkFormatProperties2(const VkFormatProperties2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkFormatProperties2(const safe_VkFormatProperties2& copy_src);
+    safe_VkFormatProperties2& operator=(const safe_VkFormatProperties2& copy_src);
+    safe_VkFormatProperties2();
+    ~safe_VkFormatProperties2();
+    void initialize(const VkFormatProperties2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkFormatProperties2* copy_src, PNextCopyState* copy_state = {});
+    VkFormatProperties2* ptr() { return reinterpret_cast<VkFormatProperties2*>(this); }
+    VkFormatProperties2 const* ptr() const { return reinterpret_cast<VkFormatProperties2 const*>(this); }
+};
+struct safe_VkImageFormatProperties2 {
+    VkStructureType sType;
+    void* pNext{};
+    VkImageFormatProperties imageFormatProperties;
+
+    safe_VkImageFormatProperties2(const VkImageFormatProperties2* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    safe_VkImageFormatProperties2(const safe_VkImageFormatProperties2& copy_src);
+    safe_VkImageFormatProperties2& operator=(const safe_VkImageFormatProperties2& copy_src);
+    safe_VkImageFormatProperties2();
+    ~safe_VkImageFormatProperties2();
+    void initialize(const VkImageFormatProperties2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageFormatProperties2* copy_src, PNextCopyState* copy_state = {});
+    VkImageFormatProperties2* ptr() { return reinterpret_cast<VkImageFormatProperties2*>(this); }
+    VkImageFormatProperties2 const* ptr() const { return reinterpret_cast<VkImageFormatProperties2 const*>(this); }
+};
+struct safe_VkPhysicalDeviceImageFormatInfo2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkFormat format;
+    VkImageType type;
+    VkImageTiling tiling;
+    VkImageUsageFlags usage;
+    VkImageCreateFlags flags;
+
+    safe_VkPhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkPhysicalDeviceImageFormatInfo2(const safe_VkPhysicalDeviceImageFormatInfo2& copy_src);
+    safe_VkPhysicalDeviceImageFormatInfo2& operator=(const safe_VkPhysicalDeviceImageFormatInfo2& copy_src);
+    safe_VkPhysicalDeviceImageFormatInfo2();
+    ~safe_VkPhysicalDeviceImageFormatInfo2();
+    void initialize(const VkPhysicalDeviceImageFormatInfo2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceImageFormatInfo2* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceImageFormatInfo2* ptr() { return reinterpret_cast<VkPhysicalDeviceImageFormatInfo2*>(this); }
+    VkPhysicalDeviceImageFormatInfo2 const* ptr() const { return reinterpret_cast<VkPhysicalDeviceImageFormatInfo2 const*>(this); }
+};
+struct safe_VkQueueFamilyProperties2 {
+    VkStructureType sType;
+    void* pNext{};
+    VkQueueFamilyProperties queueFamilyProperties;
+
+    safe_VkQueueFamilyProperties2(const VkQueueFamilyProperties2* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    safe_VkQueueFamilyProperties2(const safe_VkQueueFamilyProperties2& copy_src);
+    safe_VkQueueFamilyProperties2& operator=(const safe_VkQueueFamilyProperties2& copy_src);
+    safe_VkQueueFamilyProperties2();
+    ~safe_VkQueueFamilyProperties2();
+    void initialize(const VkQueueFamilyProperties2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkQueueFamilyProperties2* copy_src, PNextCopyState* copy_state = {});
+    VkQueueFamilyProperties2* ptr() { return reinterpret_cast<VkQueueFamilyProperties2*>(this); }
+    VkQueueFamilyProperties2 const* ptr() const { return reinterpret_cast<VkQueueFamilyProperties2 const*>(this); }
+};
+struct safe_VkPhysicalDeviceMemoryProperties2 {
+    VkStructureType sType;
+    void* pNext{};
+    VkPhysicalDeviceMemoryProperties memoryProperties;
+
+    safe_VkPhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2* in_struct, PNextCopyState* copy_state = {},
+                                           bool copy_pnext = true);
+    safe_VkPhysicalDeviceMemoryProperties2(const safe_VkPhysicalDeviceMemoryProperties2& copy_src);
+    safe_VkPhysicalDeviceMemoryProperties2& operator=(const safe_VkPhysicalDeviceMemoryProperties2& copy_src);
+    safe_VkPhysicalDeviceMemoryProperties2();
+    ~safe_VkPhysicalDeviceMemoryProperties2();
+    void initialize(const VkPhysicalDeviceMemoryProperties2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMemoryProperties2* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMemoryProperties2* ptr() { return reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>(this); }
+    VkPhysicalDeviceMemoryProperties2 const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMemoryProperties2 const*>(this);
+    }
+};
+struct safe_VkSparseImageFormatProperties2 {
+    VkStructureType sType;
+    void* pNext{};
+    VkSparseImageFormatProperties properties;
+
+    safe_VkSparseImageFormatProperties2(const VkSparseImageFormatProperties2* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkSparseImageFormatProperties2(const safe_VkSparseImageFormatProperties2& copy_src);
+    safe_VkSparseImageFormatProperties2& operator=(const safe_VkSparseImageFormatProperties2& copy_src);
+    safe_VkSparseImageFormatProperties2();
+    ~safe_VkSparseImageFormatProperties2();
+    void initialize(const VkSparseImageFormatProperties2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSparseImageFormatProperties2* copy_src, PNextCopyState* copy_state = {});
+    VkSparseImageFormatProperties2* ptr() { return reinterpret_cast<VkSparseImageFormatProperties2*>(this); }
+    VkSparseImageFormatProperties2 const* ptr() const { return reinterpret_cast<VkSparseImageFormatProperties2 const*>(this); }
+};
+struct safe_VkPhysicalDeviceSparseImageFormatInfo2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkFormat format;
+    VkImageType type;
+    VkSampleCountFlagBits samples;
+    VkImageUsageFlags usage;
+    VkImageTiling tiling;
+
+    safe_VkPhysicalDeviceSparseImageFormatInfo2(const VkPhysicalDeviceSparseImageFormatInfo2* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceSparseImageFormatInfo2(const safe_VkPhysicalDeviceSparseImageFormatInfo2& copy_src);
+    safe_VkPhysicalDeviceSparseImageFormatInfo2& operator=(const safe_VkPhysicalDeviceSparseImageFormatInfo2& copy_src);
+    safe_VkPhysicalDeviceSparseImageFormatInfo2();
+    ~safe_VkPhysicalDeviceSparseImageFormatInfo2();
+    void initialize(const VkPhysicalDeviceSparseImageFormatInfo2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceSparseImageFormatInfo2* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSparseImageFormatInfo2* ptr() { return reinterpret_cast<VkPhysicalDeviceSparseImageFormatInfo2*>(this); }
+    VkPhysicalDeviceSparseImageFormatInfo2 const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceSparseImageFormatInfo2 const*>(this);
+    }
+};
+struct safe_VkPhysicalDevicePointClippingProperties {
+    VkStructureType sType;
+    void* pNext{};
+    VkPointClippingBehavior pointClippingBehavior;
+
+    safe_VkPhysicalDevicePointClippingProperties(const VkPhysicalDevicePointClippingProperties* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDevicePointClippingProperties(const safe_VkPhysicalDevicePointClippingProperties& copy_src);
+    safe_VkPhysicalDevicePointClippingProperties& operator=(const safe_VkPhysicalDevicePointClippingProperties& copy_src);
+    safe_VkPhysicalDevicePointClippingProperties();
+    ~safe_VkPhysicalDevicePointClippingProperties();
+    void initialize(const VkPhysicalDevicePointClippingProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePointClippingProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePointClippingProperties* ptr() { return reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(this); }
+    VkPhysicalDevicePointClippingProperties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePointClippingProperties const*>(this);
+    }
+};
+struct safe_VkRenderPassInputAttachmentAspectCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t aspectReferenceCount;
+    const VkInputAttachmentAspectReference* pAspectReferences{};
+
+    safe_VkRenderPassInputAttachmentAspectCreateInfo(const VkRenderPassInputAttachmentAspectCreateInfo* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkRenderPassInputAttachmentAspectCreateInfo(const safe_VkRenderPassInputAttachmentAspectCreateInfo& copy_src);
+    safe_VkRenderPassInputAttachmentAspectCreateInfo& operator=(const safe_VkRenderPassInputAttachmentAspectCreateInfo& copy_src);
+    safe_VkRenderPassInputAttachmentAspectCreateInfo();
+    ~safe_VkRenderPassInputAttachmentAspectCreateInfo();
+    void initialize(const VkRenderPassInputAttachmentAspectCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderPassInputAttachmentAspectCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassInputAttachmentAspectCreateInfo* ptr() {
+        return reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(this);
+    }
+    VkRenderPassInputAttachmentAspectCreateInfo const* ptr() const {
+        return reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo const*>(this);
+    }
+};
+struct safe_VkImageViewUsageCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageUsageFlags usage;
+
+    safe_VkImageViewUsageCreateInfo(const VkImageViewUsageCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    safe_VkImageViewUsageCreateInfo(const safe_VkImageViewUsageCreateInfo& copy_src);
+    safe_VkImageViewUsageCreateInfo& operator=(const safe_VkImageViewUsageCreateInfo& copy_src);
+    safe_VkImageViewUsageCreateInfo();
+    ~safe_VkImageViewUsageCreateInfo();
+    void initialize(const VkImageViewUsageCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageViewUsageCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkImageViewUsageCreateInfo* ptr() { return reinterpret_cast<VkImageViewUsageCreateInfo*>(this); }
+    VkImageViewUsageCreateInfo const* ptr() const { return reinterpret_cast<VkImageViewUsageCreateInfo const*>(this); }
+};
+struct safe_VkPipelineTessellationDomainOriginStateCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkTessellationDomainOrigin domainOrigin;
+
+    safe_VkPipelineTessellationDomainOriginStateCreateInfo(const VkPipelineTessellationDomainOriginStateCreateInfo* in_struct,
+                                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineTessellationDomainOriginStateCreateInfo(const safe_VkPipelineTessellationDomainOriginStateCreateInfo& copy_src);
+    safe_VkPipelineTessellationDomainOriginStateCreateInfo& operator=(
+        const safe_VkPipelineTessellationDomainOriginStateCreateInfo& copy_src);
+    safe_VkPipelineTessellationDomainOriginStateCreateInfo();
+    ~safe_VkPipelineTessellationDomainOriginStateCreateInfo();
+    void initialize(const VkPipelineTessellationDomainOriginStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineTessellationDomainOriginStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineTessellationDomainOriginStateCreateInfo* ptr() {
+        return reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(this);
+    }
+    VkPipelineTessellationDomainOriginStateCreateInfo const* ptr() const {
+        return reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo const*>(this);
+    }
+};
+struct safe_VkRenderPassMultiviewCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t subpassCount;
+    const uint32_t* pViewMasks{};
+    uint32_t dependencyCount;
+    const int32_t* pViewOffsets{};
+    uint32_t correlationMaskCount;
+    const uint32_t* pCorrelationMasks{};
+
+    safe_VkRenderPassMultiviewCreateInfo(const VkRenderPassMultiviewCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkRenderPassMultiviewCreateInfo(const safe_VkRenderPassMultiviewCreateInfo& copy_src);
+    safe_VkRenderPassMultiviewCreateInfo& operator=(const safe_VkRenderPassMultiviewCreateInfo& copy_src);
+    safe_VkRenderPassMultiviewCreateInfo();
+    ~safe_VkRenderPassMultiviewCreateInfo();
+    void initialize(const VkRenderPassMultiviewCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderPassMultiviewCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassMultiviewCreateInfo* ptr() { return reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(this); }
+    VkRenderPassMultiviewCreateInfo const* ptr() const { return reinterpret_cast<VkRenderPassMultiviewCreateInfo const*>(this); }
+};
+struct safe_VkPhysicalDeviceMultiviewFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 multiview;
+    VkBool32 multiviewGeometryShader;
+    VkBool32 multiviewTessellationShader;
+
+    safe_VkPhysicalDeviceMultiviewFeatures(const VkPhysicalDeviceMultiviewFeatures* in_struct, PNextCopyState* copy_state = {},
+                                           bool copy_pnext = true);
+    safe_VkPhysicalDeviceMultiviewFeatures(const safe_VkPhysicalDeviceMultiviewFeatures& copy_src);
+    safe_VkPhysicalDeviceMultiviewFeatures& operator=(const safe_VkPhysicalDeviceMultiviewFeatures& copy_src);
+    safe_VkPhysicalDeviceMultiviewFeatures();
+    ~safe_VkPhysicalDeviceMultiviewFeatures();
+    void initialize(const VkPhysicalDeviceMultiviewFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMultiviewFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMultiviewFeatures* ptr() { return reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(this); }
+    VkPhysicalDeviceMultiviewFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMultiviewFeatures const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceMultiviewProperties {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxMultiviewViewCount;
+    uint32_t maxMultiviewInstanceIndex;
+
+    safe_VkPhysicalDeviceMultiviewProperties(const VkPhysicalDeviceMultiviewProperties* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkPhysicalDeviceMultiviewProperties(const safe_VkPhysicalDeviceMultiviewProperties& copy_src);
+    safe_VkPhysicalDeviceMultiviewProperties& operator=(const safe_VkPhysicalDeviceMultiviewProperties& copy_src);
+    safe_VkPhysicalDeviceMultiviewProperties();
+    ~safe_VkPhysicalDeviceMultiviewProperties();
+    void initialize(const VkPhysicalDeviceMultiviewProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMultiviewProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMultiviewProperties* ptr() { return reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(this); }
+    VkPhysicalDeviceMultiviewProperties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMultiviewProperties const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceVariablePointersFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 variablePointersStorageBuffer;
+    VkBool32 variablePointers;
+
+    safe_VkPhysicalDeviceVariablePointersFeatures(const VkPhysicalDeviceVariablePointersFeatures* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceVariablePointersFeatures(const safe_VkPhysicalDeviceVariablePointersFeatures& copy_src);
+    safe_VkPhysicalDeviceVariablePointersFeatures& operator=(const safe_VkPhysicalDeviceVariablePointersFeatures& copy_src);
+    safe_VkPhysicalDeviceVariablePointersFeatures();
+    ~safe_VkPhysicalDeviceVariablePointersFeatures();
+    void initialize(const VkPhysicalDeviceVariablePointersFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceVariablePointersFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVariablePointersFeatures* ptr() { return reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures*>(this); }
+    VkPhysicalDeviceVariablePointersFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceProtectedMemoryFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 protectedMemory;
+
+    safe_VkPhysicalDeviceProtectedMemoryFeatures(const VkPhysicalDeviceProtectedMemoryFeatures* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceProtectedMemoryFeatures(const safe_VkPhysicalDeviceProtectedMemoryFeatures& copy_src);
+    safe_VkPhysicalDeviceProtectedMemoryFeatures& operator=(const safe_VkPhysicalDeviceProtectedMemoryFeatures& copy_src);
+    safe_VkPhysicalDeviceProtectedMemoryFeatures();
+    ~safe_VkPhysicalDeviceProtectedMemoryFeatures();
+    void initialize(const VkPhysicalDeviceProtectedMemoryFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceProtectedMemoryFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceProtectedMemoryFeatures* ptr() { return reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(this); }
+    VkPhysicalDeviceProtectedMemoryFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceProtectedMemoryProperties {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 protectedNoFault;
+
+    safe_VkPhysicalDeviceProtectedMemoryProperties(const VkPhysicalDeviceProtectedMemoryProperties* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceProtectedMemoryProperties(const safe_VkPhysicalDeviceProtectedMemoryProperties& copy_src);
+    safe_VkPhysicalDeviceProtectedMemoryProperties& operator=(const safe_VkPhysicalDeviceProtectedMemoryProperties& copy_src);
+    safe_VkPhysicalDeviceProtectedMemoryProperties();
+    ~safe_VkPhysicalDeviceProtectedMemoryProperties();
+    void initialize(const VkPhysicalDeviceProtectedMemoryProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceProtectedMemoryProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceProtectedMemoryProperties* ptr() { return reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(this); }
+    VkPhysicalDeviceProtectedMemoryProperties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties const*>(this);
+    }
+};
+struct safe_VkDeviceQueueInfo2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceQueueCreateFlags flags;
+    uint32_t queueFamilyIndex;
+    uint32_t queueIndex;
+
+    safe_VkDeviceQueueInfo2(const VkDeviceQueueInfo2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDeviceQueueInfo2(const safe_VkDeviceQueueInfo2& copy_src);
+    safe_VkDeviceQueueInfo2& operator=(const safe_VkDeviceQueueInfo2& copy_src);
+    safe_VkDeviceQueueInfo2();
+    ~safe_VkDeviceQueueInfo2();
+    void initialize(const VkDeviceQueueInfo2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDeviceQueueInfo2* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceQueueInfo2* ptr() { return reinterpret_cast<VkDeviceQueueInfo2*>(this); }
+    VkDeviceQueueInfo2 const* ptr() const { return reinterpret_cast<VkDeviceQueueInfo2 const*>(this); }
+};
+struct safe_VkProtectedSubmitInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 protectedSubmit;
+
+    safe_VkProtectedSubmitInfo(const VkProtectedSubmitInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkProtectedSubmitInfo(const safe_VkProtectedSubmitInfo& copy_src);
+    safe_VkProtectedSubmitInfo& operator=(const safe_VkProtectedSubmitInfo& copy_src);
+    safe_VkProtectedSubmitInfo();
+    ~safe_VkProtectedSubmitInfo();
+    void initialize(const VkProtectedSubmitInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkProtectedSubmitInfo* copy_src, PNextCopyState* copy_state = {});
+    VkProtectedSubmitInfo* ptr() { return reinterpret_cast<VkProtectedSubmitInfo*>(this); }
+    VkProtectedSubmitInfo const* ptr() const { return reinterpret_cast<VkProtectedSubmitInfo const*>(this); }
+};
+struct safe_VkSamplerYcbcrConversionCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkFormat format;
+    VkSamplerYcbcrModelConversion ycbcrModel;
+    VkSamplerYcbcrRange ycbcrRange;
+    VkComponentMapping components;
+    VkChromaLocation xChromaOffset;
+    VkChromaLocation yChromaOffset;
+    VkFilter chromaFilter;
+    VkBool32 forceExplicitReconstruction;
+
+    safe_VkSamplerYcbcrConversionCreateInfo(const VkSamplerYcbcrConversionCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                            bool copy_pnext = true);
+    safe_VkSamplerYcbcrConversionCreateInfo(const safe_VkSamplerYcbcrConversionCreateInfo& copy_src);
+    safe_VkSamplerYcbcrConversionCreateInfo& operator=(const safe_VkSamplerYcbcrConversionCreateInfo& copy_src);
+    safe_VkSamplerYcbcrConversionCreateInfo();
+    ~safe_VkSamplerYcbcrConversionCreateInfo();
+    void initialize(const VkSamplerYcbcrConversionCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSamplerYcbcrConversionCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSamplerYcbcrConversionCreateInfo* ptr() { return reinterpret_cast<VkSamplerYcbcrConversionCreateInfo*>(this); }
+    VkSamplerYcbcrConversionCreateInfo const* ptr() const {
+        return reinterpret_cast<VkSamplerYcbcrConversionCreateInfo const*>(this);
+    }
+};
+struct safe_VkSamplerYcbcrConversionInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSamplerYcbcrConversion conversion;
+
+    safe_VkSamplerYcbcrConversionInfo(const VkSamplerYcbcrConversionInfo* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    safe_VkSamplerYcbcrConversionInfo(const safe_VkSamplerYcbcrConversionInfo& copy_src);
+    safe_VkSamplerYcbcrConversionInfo& operator=(const safe_VkSamplerYcbcrConversionInfo& copy_src);
+    safe_VkSamplerYcbcrConversionInfo();
+    ~safe_VkSamplerYcbcrConversionInfo();
+    void initialize(const VkSamplerYcbcrConversionInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSamplerYcbcrConversionInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSamplerYcbcrConversionInfo* ptr() { return reinterpret_cast<VkSamplerYcbcrConversionInfo*>(this); }
+    VkSamplerYcbcrConversionInfo const* ptr() const { return reinterpret_cast<VkSamplerYcbcrConversionInfo const*>(this); }
+};
+struct safe_VkBindImagePlaneMemoryInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageAspectFlagBits planeAspect;
+
+    safe_VkBindImagePlaneMemoryInfo(const VkBindImagePlaneMemoryInfo* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    safe_VkBindImagePlaneMemoryInfo(const safe_VkBindImagePlaneMemoryInfo& copy_src);
+    safe_VkBindImagePlaneMemoryInfo& operator=(const safe_VkBindImagePlaneMemoryInfo& copy_src);
+    safe_VkBindImagePlaneMemoryInfo();
+    ~safe_VkBindImagePlaneMemoryInfo();
+    void initialize(const VkBindImagePlaneMemoryInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBindImagePlaneMemoryInfo* copy_src, PNextCopyState* copy_state = {});
+    VkBindImagePlaneMemoryInfo* ptr() { return reinterpret_cast<VkBindImagePlaneMemoryInfo*>(this); }
+    VkBindImagePlaneMemoryInfo const* ptr() const { return reinterpret_cast<VkBindImagePlaneMemoryInfo const*>(this); }
+};
+struct safe_VkImagePlaneMemoryRequirementsInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageAspectFlagBits planeAspect;
+
+    safe_VkImagePlaneMemoryRequirementsInfo(const VkImagePlaneMemoryRequirementsInfo* in_struct, PNextCopyState* copy_state = {},
+                                            bool copy_pnext = true);
+    safe_VkImagePlaneMemoryRequirementsInfo(const safe_VkImagePlaneMemoryRequirementsInfo& copy_src);
+    safe_VkImagePlaneMemoryRequirementsInfo& operator=(const safe_VkImagePlaneMemoryRequirementsInfo& copy_src);
+    safe_VkImagePlaneMemoryRequirementsInfo();
+    ~safe_VkImagePlaneMemoryRequirementsInfo();
+    void initialize(const VkImagePlaneMemoryRequirementsInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImagePlaneMemoryRequirementsInfo* copy_src, PNextCopyState* copy_state = {});
+    VkImagePlaneMemoryRequirementsInfo* ptr() { return reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(this); }
+    VkImagePlaneMemoryRequirementsInfo const* ptr() const {
+        return reinterpret_cast<VkImagePlaneMemoryRequirementsInfo const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 samplerYcbcrConversion;
+
+    safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const VkPhysicalDeviceSamplerYcbcrConversionFeatures* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures& copy_src);
+    safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures& operator=(
+        const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures& copy_src);
+    safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures();
+    ~safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures();
+    void initialize(const VkPhysicalDeviceSamplerYcbcrConversionFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSamplerYcbcrConversionFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(this);
+    }
+    VkPhysicalDeviceSamplerYcbcrConversionFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures const*>(this);
+    }
+};
+struct safe_VkSamplerYcbcrConversionImageFormatProperties {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t combinedImageSamplerDescriptorCount;
+
+    safe_VkSamplerYcbcrConversionImageFormatProperties(const VkSamplerYcbcrConversionImageFormatProperties* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSamplerYcbcrConversionImageFormatProperties(const safe_VkSamplerYcbcrConversionImageFormatProperties& copy_src);
+    safe_VkSamplerYcbcrConversionImageFormatProperties& operator=(
+        const safe_VkSamplerYcbcrConversionImageFormatProperties& copy_src);
+    safe_VkSamplerYcbcrConversionImageFormatProperties();
+    ~safe_VkSamplerYcbcrConversionImageFormatProperties();
+    void initialize(const VkSamplerYcbcrConversionImageFormatProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSamplerYcbcrConversionImageFormatProperties* copy_src, PNextCopyState* copy_state = {});
+    VkSamplerYcbcrConversionImageFormatProperties* ptr() {
+        return reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(this);
+    }
+    VkSamplerYcbcrConversionImageFormatProperties const* ptr() const {
+        return reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties const*>(this);
+    }
+};
+struct safe_VkDescriptorUpdateTemplateCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDescriptorUpdateTemplateCreateFlags flags;
+    uint32_t descriptorUpdateEntryCount;
+    const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntries{};
+    VkDescriptorUpdateTemplateType templateType;
+    VkDescriptorSetLayout descriptorSetLayout;
+    VkPipelineBindPoint pipelineBindPoint;
+    VkPipelineLayout pipelineLayout;
+    uint32_t set;
+
+    safe_VkDescriptorUpdateTemplateCreateInfo(const VkDescriptorUpdateTemplateCreateInfo* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDescriptorUpdateTemplateCreateInfo(const safe_VkDescriptorUpdateTemplateCreateInfo& copy_src);
+    safe_VkDescriptorUpdateTemplateCreateInfo& operator=(const safe_VkDescriptorUpdateTemplateCreateInfo& copy_src);
+    safe_VkDescriptorUpdateTemplateCreateInfo();
+    ~safe_VkDescriptorUpdateTemplateCreateInfo();
+    void initialize(const VkDescriptorUpdateTemplateCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDescriptorUpdateTemplateCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorUpdateTemplateCreateInfo* ptr() { return reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo*>(this); }
+    VkDescriptorUpdateTemplateCreateInfo const* ptr() const {
+        return reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceExternalImageFormatInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalMemoryHandleTypeFlagBits handleType;
+
+    safe_VkPhysicalDeviceExternalImageFormatInfo(const VkPhysicalDeviceExternalImageFormatInfo* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceExternalImageFormatInfo(const safe_VkPhysicalDeviceExternalImageFormatInfo& copy_src);
+    safe_VkPhysicalDeviceExternalImageFormatInfo& operator=(const safe_VkPhysicalDeviceExternalImageFormatInfo& copy_src);
+    safe_VkPhysicalDeviceExternalImageFormatInfo();
+    ~safe_VkPhysicalDeviceExternalImageFormatInfo();
+    void initialize(const VkPhysicalDeviceExternalImageFormatInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceExternalImageFormatInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExternalImageFormatInfo* ptr() { return reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(this); }
+    VkPhysicalDeviceExternalImageFormatInfo const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo const*>(this);
+    }
+};
+struct safe_VkExternalImageFormatProperties {
+    VkStructureType sType;
+    void* pNext{};
+    VkExternalMemoryProperties externalMemoryProperties;
+
+    safe_VkExternalImageFormatProperties(const VkExternalImageFormatProperties* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkExternalImageFormatProperties(const safe_VkExternalImageFormatProperties& copy_src);
+    safe_VkExternalImageFormatProperties& operator=(const safe_VkExternalImageFormatProperties& copy_src);
+    safe_VkExternalImageFormatProperties();
+    ~safe_VkExternalImageFormatProperties();
+    void initialize(const VkExternalImageFormatProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExternalImageFormatProperties* copy_src, PNextCopyState* copy_state = {});
+    VkExternalImageFormatProperties* ptr() { return reinterpret_cast<VkExternalImageFormatProperties*>(this); }
+    VkExternalImageFormatProperties const* ptr() const { return reinterpret_cast<VkExternalImageFormatProperties const*>(this); }
+};
+struct safe_VkPhysicalDeviceExternalBufferInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBufferCreateFlags flags;
+    VkBufferUsageFlags usage;
+    VkExternalMemoryHandleTypeFlagBits handleType;
+
+    safe_VkPhysicalDeviceExternalBufferInfo(const VkPhysicalDeviceExternalBufferInfo* in_struct, PNextCopyState* copy_state = {},
+                                            bool copy_pnext = true);
+    safe_VkPhysicalDeviceExternalBufferInfo(const safe_VkPhysicalDeviceExternalBufferInfo& copy_src);
+    safe_VkPhysicalDeviceExternalBufferInfo& operator=(const safe_VkPhysicalDeviceExternalBufferInfo& copy_src);
+    safe_VkPhysicalDeviceExternalBufferInfo();
+    ~safe_VkPhysicalDeviceExternalBufferInfo();
+    void initialize(const VkPhysicalDeviceExternalBufferInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceExternalBufferInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExternalBufferInfo* ptr() { return reinterpret_cast<VkPhysicalDeviceExternalBufferInfo*>(this); }
+    VkPhysicalDeviceExternalBufferInfo const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExternalBufferInfo const*>(this);
+    }
+};
+struct safe_VkExternalBufferProperties {
+    VkStructureType sType;
+    void* pNext{};
+    VkExternalMemoryProperties externalMemoryProperties;
+
+    safe_VkExternalBufferProperties(const VkExternalBufferProperties* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    safe_VkExternalBufferProperties(const safe_VkExternalBufferProperties& copy_src);
+    safe_VkExternalBufferProperties& operator=(const safe_VkExternalBufferProperties& copy_src);
+    safe_VkExternalBufferProperties();
+    ~safe_VkExternalBufferProperties();
+    void initialize(const VkExternalBufferProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExternalBufferProperties* copy_src, PNextCopyState* copy_state = {});
+    VkExternalBufferProperties* ptr() { return reinterpret_cast<VkExternalBufferProperties*>(this); }
+    VkExternalBufferProperties const* ptr() const { return reinterpret_cast<VkExternalBufferProperties const*>(this); }
+};
+struct safe_VkPhysicalDeviceIDProperties {
+    VkStructureType sType;
+    void* pNext{};
+    uint8_t deviceUUID[VK_UUID_SIZE];
+    uint8_t driverUUID[VK_UUID_SIZE];
+    uint8_t deviceLUID[VK_LUID_SIZE];
+    uint32_t deviceNodeMask;
+    VkBool32 deviceLUIDValid;
+
+    safe_VkPhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    safe_VkPhysicalDeviceIDProperties(const safe_VkPhysicalDeviceIDProperties& copy_src);
+    safe_VkPhysicalDeviceIDProperties& operator=(const safe_VkPhysicalDeviceIDProperties& copy_src);
+    safe_VkPhysicalDeviceIDProperties();
+    ~safe_VkPhysicalDeviceIDProperties();
+    void initialize(const VkPhysicalDeviceIDProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceIDProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceIDProperties* ptr() { return reinterpret_cast<VkPhysicalDeviceIDProperties*>(this); }
+    VkPhysicalDeviceIDProperties const* ptr() const { return reinterpret_cast<VkPhysicalDeviceIDProperties const*>(this); }
+};
+struct safe_VkExternalMemoryImageCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalMemoryHandleTypeFlags handleTypes;
+
+    safe_VkExternalMemoryImageCreateInfo(const VkExternalMemoryImageCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkExternalMemoryImageCreateInfo(const safe_VkExternalMemoryImageCreateInfo& copy_src);
+    safe_VkExternalMemoryImageCreateInfo& operator=(const safe_VkExternalMemoryImageCreateInfo& copy_src);
+    safe_VkExternalMemoryImageCreateInfo();
+    ~safe_VkExternalMemoryImageCreateInfo();
+    void initialize(const VkExternalMemoryImageCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExternalMemoryImageCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkExternalMemoryImageCreateInfo* ptr() { return reinterpret_cast<VkExternalMemoryImageCreateInfo*>(this); }
+    VkExternalMemoryImageCreateInfo const* ptr() const { return reinterpret_cast<VkExternalMemoryImageCreateInfo const*>(this); }
+};
+struct safe_VkExternalMemoryBufferCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalMemoryHandleTypeFlags handleTypes;
+
+    safe_VkExternalMemoryBufferCreateInfo(const VkExternalMemoryBufferCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkExternalMemoryBufferCreateInfo(const safe_VkExternalMemoryBufferCreateInfo& copy_src);
+    safe_VkExternalMemoryBufferCreateInfo& operator=(const safe_VkExternalMemoryBufferCreateInfo& copy_src);
+    safe_VkExternalMemoryBufferCreateInfo();
+    ~safe_VkExternalMemoryBufferCreateInfo();
+    void initialize(const VkExternalMemoryBufferCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExternalMemoryBufferCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkExternalMemoryBufferCreateInfo* ptr() { return reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(this); }
+    VkExternalMemoryBufferCreateInfo const* ptr() const { return reinterpret_cast<VkExternalMemoryBufferCreateInfo const*>(this); }
+};
+struct safe_VkExportMemoryAllocateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalMemoryHandleTypeFlags handleTypes;
+
+    safe_VkExportMemoryAllocateInfo(const VkExportMemoryAllocateInfo* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    safe_VkExportMemoryAllocateInfo(const safe_VkExportMemoryAllocateInfo& copy_src);
+    safe_VkExportMemoryAllocateInfo& operator=(const safe_VkExportMemoryAllocateInfo& copy_src);
+    safe_VkExportMemoryAllocateInfo();
+    ~safe_VkExportMemoryAllocateInfo();
+    void initialize(const VkExportMemoryAllocateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExportMemoryAllocateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkExportMemoryAllocateInfo* ptr() { return reinterpret_cast<VkExportMemoryAllocateInfo*>(this); }
+    VkExportMemoryAllocateInfo const* ptr() const { return reinterpret_cast<VkExportMemoryAllocateInfo const*>(this); }
+};
+struct safe_VkPhysicalDeviceExternalFenceInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalFenceHandleTypeFlagBits handleType;
+
+    safe_VkPhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo* in_struct, PNextCopyState* copy_state = {},
+                                           bool copy_pnext = true);
+    safe_VkPhysicalDeviceExternalFenceInfo(const safe_VkPhysicalDeviceExternalFenceInfo& copy_src);
+    safe_VkPhysicalDeviceExternalFenceInfo& operator=(const safe_VkPhysicalDeviceExternalFenceInfo& copy_src);
+    safe_VkPhysicalDeviceExternalFenceInfo();
+    ~safe_VkPhysicalDeviceExternalFenceInfo();
+    void initialize(const VkPhysicalDeviceExternalFenceInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceExternalFenceInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExternalFenceInfo* ptr() { return reinterpret_cast<VkPhysicalDeviceExternalFenceInfo*>(this); }
+    VkPhysicalDeviceExternalFenceInfo const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExternalFenceInfo const*>(this);
+    }
+};
+struct safe_VkExternalFenceProperties {
+    VkStructureType sType;
+    void* pNext{};
+    VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes;
+    VkExternalFenceHandleTypeFlags compatibleHandleTypes;
+    VkExternalFenceFeatureFlags externalFenceFeatures;
+
+    safe_VkExternalFenceProperties(const VkExternalFenceProperties* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    safe_VkExternalFenceProperties(const safe_VkExternalFenceProperties& copy_src);
+    safe_VkExternalFenceProperties& operator=(const safe_VkExternalFenceProperties& copy_src);
+    safe_VkExternalFenceProperties();
+    ~safe_VkExternalFenceProperties();
+    void initialize(const VkExternalFenceProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExternalFenceProperties* copy_src, PNextCopyState* copy_state = {});
+    VkExternalFenceProperties* ptr() { return reinterpret_cast<VkExternalFenceProperties*>(this); }
+    VkExternalFenceProperties const* ptr() const { return reinterpret_cast<VkExternalFenceProperties const*>(this); }
+};
+struct safe_VkExportFenceCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalFenceHandleTypeFlags handleTypes;
+
+    safe_VkExportFenceCreateInfo(const VkExportFenceCreateInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkExportFenceCreateInfo(const safe_VkExportFenceCreateInfo& copy_src);
+    safe_VkExportFenceCreateInfo& operator=(const safe_VkExportFenceCreateInfo& copy_src);
+    safe_VkExportFenceCreateInfo();
+    ~safe_VkExportFenceCreateInfo();
+    void initialize(const VkExportFenceCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExportFenceCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkExportFenceCreateInfo* ptr() { return reinterpret_cast<VkExportFenceCreateInfo*>(this); }
+    VkExportFenceCreateInfo const* ptr() const { return reinterpret_cast<VkExportFenceCreateInfo const*>(this); }
+};
+struct safe_VkExportSemaphoreCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalSemaphoreHandleTypeFlags handleTypes;
+
+    safe_VkExportSemaphoreCreateInfo(const VkExportSemaphoreCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    safe_VkExportSemaphoreCreateInfo(const safe_VkExportSemaphoreCreateInfo& copy_src);
+    safe_VkExportSemaphoreCreateInfo& operator=(const safe_VkExportSemaphoreCreateInfo& copy_src);
+    safe_VkExportSemaphoreCreateInfo();
+    ~safe_VkExportSemaphoreCreateInfo();
+    void initialize(const VkExportSemaphoreCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExportSemaphoreCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkExportSemaphoreCreateInfo* ptr() { return reinterpret_cast<VkExportSemaphoreCreateInfo*>(this); }
+    VkExportSemaphoreCreateInfo const* ptr() const { return reinterpret_cast<VkExportSemaphoreCreateInfo const*>(this); }
+};
+struct safe_VkPhysicalDeviceExternalSemaphoreInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalSemaphoreHandleTypeFlagBits handleType;
+
+    safe_VkPhysicalDeviceExternalSemaphoreInfo(const VkPhysicalDeviceExternalSemaphoreInfo* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceExternalSemaphoreInfo(const safe_VkPhysicalDeviceExternalSemaphoreInfo& copy_src);
+    safe_VkPhysicalDeviceExternalSemaphoreInfo& operator=(const safe_VkPhysicalDeviceExternalSemaphoreInfo& copy_src);
+    safe_VkPhysicalDeviceExternalSemaphoreInfo();
+    ~safe_VkPhysicalDeviceExternalSemaphoreInfo();
+    void initialize(const VkPhysicalDeviceExternalSemaphoreInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceExternalSemaphoreInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExternalSemaphoreInfo* ptr() { return reinterpret_cast<VkPhysicalDeviceExternalSemaphoreInfo*>(this); }
+    VkPhysicalDeviceExternalSemaphoreInfo const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExternalSemaphoreInfo const*>(this);
+    }
+};
+struct safe_VkExternalSemaphoreProperties {
+    VkStructureType sType;
+    void* pNext{};
+    VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes;
+    VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes;
+    VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures;
+
+    safe_VkExternalSemaphoreProperties(const VkExternalSemaphoreProperties* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    safe_VkExternalSemaphoreProperties(const safe_VkExternalSemaphoreProperties& copy_src);
+    safe_VkExternalSemaphoreProperties& operator=(const safe_VkExternalSemaphoreProperties& copy_src);
+    safe_VkExternalSemaphoreProperties();
+    ~safe_VkExternalSemaphoreProperties();
+    void initialize(const VkExternalSemaphoreProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExternalSemaphoreProperties* copy_src, PNextCopyState* copy_state = {});
+    VkExternalSemaphoreProperties* ptr() { return reinterpret_cast<VkExternalSemaphoreProperties*>(this); }
+    VkExternalSemaphoreProperties const* ptr() const { return reinterpret_cast<VkExternalSemaphoreProperties const*>(this); }
+};
+struct safe_VkPhysicalDeviceMaintenance3Properties {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxPerSetDescriptors;
+    VkDeviceSize maxMemoryAllocationSize;
+
+    safe_VkPhysicalDeviceMaintenance3Properties(const VkPhysicalDeviceMaintenance3Properties* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceMaintenance3Properties(const safe_VkPhysicalDeviceMaintenance3Properties& copy_src);
+    safe_VkPhysicalDeviceMaintenance3Properties& operator=(const safe_VkPhysicalDeviceMaintenance3Properties& copy_src);
+    safe_VkPhysicalDeviceMaintenance3Properties();
+    ~safe_VkPhysicalDeviceMaintenance3Properties();
+    void initialize(const VkPhysicalDeviceMaintenance3Properties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMaintenance3Properties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMaintenance3Properties* ptr() { return reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(this); }
+    VkPhysicalDeviceMaintenance3Properties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMaintenance3Properties const*>(this);
+    }
+};
+struct safe_VkDescriptorSetLayoutSupport {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 supported;
+
+    safe_VkDescriptorSetLayoutSupport(const VkDescriptorSetLayoutSupport* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    safe_VkDescriptorSetLayoutSupport(const safe_VkDescriptorSetLayoutSupport& copy_src);
+    safe_VkDescriptorSetLayoutSupport& operator=(const safe_VkDescriptorSetLayoutSupport& copy_src);
+    safe_VkDescriptorSetLayoutSupport();
+    ~safe_VkDescriptorSetLayoutSupport();
+    void initialize(const VkDescriptorSetLayoutSupport* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDescriptorSetLayoutSupport* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorSetLayoutSupport* ptr() { return reinterpret_cast<VkDescriptorSetLayoutSupport*>(this); }
+    VkDescriptorSetLayoutSupport const* ptr() const { return reinterpret_cast<VkDescriptorSetLayoutSupport const*>(this); }
+};
+struct safe_VkPhysicalDeviceShaderDrawParametersFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderDrawParameters;
+
+    safe_VkPhysicalDeviceShaderDrawParametersFeatures(const VkPhysicalDeviceShaderDrawParametersFeatures* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderDrawParametersFeatures(const safe_VkPhysicalDeviceShaderDrawParametersFeatures& copy_src);
+    safe_VkPhysicalDeviceShaderDrawParametersFeatures& operator=(const safe_VkPhysicalDeviceShaderDrawParametersFeatures& copy_src);
+    safe_VkPhysicalDeviceShaderDrawParametersFeatures();
+    ~safe_VkPhysicalDeviceShaderDrawParametersFeatures();
+    void initialize(const VkPhysicalDeviceShaderDrawParametersFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderDrawParametersFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderDrawParametersFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures*>(this);
+    }
+    VkPhysicalDeviceShaderDrawParametersFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceVulkan11Features {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 storageBuffer16BitAccess;
+    VkBool32 uniformAndStorageBuffer16BitAccess;
+    VkBool32 storagePushConstant16;
+    VkBool32 storageInputOutput16;
+    VkBool32 multiview;
+    VkBool32 multiviewGeometryShader;
+    VkBool32 multiviewTessellationShader;
+    VkBool32 variablePointersStorageBuffer;
+    VkBool32 variablePointers;
+    VkBool32 protectedMemory;
+    VkBool32 samplerYcbcrConversion;
+    VkBool32 shaderDrawParameters;
+
+    safe_VkPhysicalDeviceVulkan11Features(const VkPhysicalDeviceVulkan11Features* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkPhysicalDeviceVulkan11Features(const safe_VkPhysicalDeviceVulkan11Features& copy_src);
+    safe_VkPhysicalDeviceVulkan11Features& operator=(const safe_VkPhysicalDeviceVulkan11Features& copy_src);
+    safe_VkPhysicalDeviceVulkan11Features();
+    ~safe_VkPhysicalDeviceVulkan11Features();
+    void initialize(const VkPhysicalDeviceVulkan11Features* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceVulkan11Features* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVulkan11Features* ptr() { return reinterpret_cast<VkPhysicalDeviceVulkan11Features*>(this); }
+    VkPhysicalDeviceVulkan11Features const* ptr() const { return reinterpret_cast<VkPhysicalDeviceVulkan11Features const*>(this); }
+};
+struct safe_VkPhysicalDeviceVulkan11Properties {
+    VkStructureType sType;
+    void* pNext{};
+    uint8_t deviceUUID[VK_UUID_SIZE];
+    uint8_t driverUUID[VK_UUID_SIZE];
+    uint8_t deviceLUID[VK_LUID_SIZE];
+    uint32_t deviceNodeMask;
+    VkBool32 deviceLUIDValid;
+    uint32_t subgroupSize;
+    VkShaderStageFlags subgroupSupportedStages;
+    VkSubgroupFeatureFlags subgroupSupportedOperations;
+    VkBool32 subgroupQuadOperationsInAllStages;
+    VkPointClippingBehavior pointClippingBehavior;
+    uint32_t maxMultiviewViewCount;
+    uint32_t maxMultiviewInstanceIndex;
+    VkBool32 protectedNoFault;
+    uint32_t maxPerSetDescriptors;
+    VkDeviceSize maxMemoryAllocationSize;
+
+    safe_VkPhysicalDeviceVulkan11Properties(const VkPhysicalDeviceVulkan11Properties* in_struct, PNextCopyState* copy_state = {},
+                                            bool copy_pnext = true);
+    safe_VkPhysicalDeviceVulkan11Properties(const safe_VkPhysicalDeviceVulkan11Properties& copy_src);
+    safe_VkPhysicalDeviceVulkan11Properties& operator=(const safe_VkPhysicalDeviceVulkan11Properties& copy_src);
+    safe_VkPhysicalDeviceVulkan11Properties();
+    ~safe_VkPhysicalDeviceVulkan11Properties();
+    void initialize(const VkPhysicalDeviceVulkan11Properties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceVulkan11Properties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVulkan11Properties* ptr() { return reinterpret_cast<VkPhysicalDeviceVulkan11Properties*>(this); }
+    VkPhysicalDeviceVulkan11Properties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceVulkan11Properties const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceVulkan12Features {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 samplerMirrorClampToEdge;
+    VkBool32 drawIndirectCount;
+    VkBool32 storageBuffer8BitAccess;
+    VkBool32 uniformAndStorageBuffer8BitAccess;
+    VkBool32 storagePushConstant8;
+    VkBool32 shaderBufferInt64Atomics;
+    VkBool32 shaderSharedInt64Atomics;
+    VkBool32 shaderFloat16;
+    VkBool32 shaderInt8;
+    VkBool32 descriptorIndexing;
+    VkBool32 shaderInputAttachmentArrayDynamicIndexing;
+    VkBool32 shaderUniformTexelBufferArrayDynamicIndexing;
+    VkBool32 shaderStorageTexelBufferArrayDynamicIndexing;
+    VkBool32 shaderUniformBufferArrayNonUniformIndexing;
+    VkBool32 shaderSampledImageArrayNonUniformIndexing;
+    VkBool32 shaderStorageBufferArrayNonUniformIndexing;
+    VkBool32 shaderStorageImageArrayNonUniformIndexing;
+    VkBool32 shaderInputAttachmentArrayNonUniformIndexing;
+    VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing;
+    VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing;
+    VkBool32 descriptorBindingUniformBufferUpdateAfterBind;
+    VkBool32 descriptorBindingSampledImageUpdateAfterBind;
+    VkBool32 descriptorBindingStorageImageUpdateAfterBind;
+    VkBool32 descriptorBindingStorageBufferUpdateAfterBind;
+    VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind;
+    VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind;
+    VkBool32 descriptorBindingUpdateUnusedWhilePending;
+    VkBool32 descriptorBindingPartiallyBound;
+    VkBool32 descriptorBindingVariableDescriptorCount;
+    VkBool32 runtimeDescriptorArray;
+    VkBool32 samplerFilterMinmax;
+    VkBool32 scalarBlockLayout;
+    VkBool32 imagelessFramebuffer;
+    VkBool32 uniformBufferStandardLayout;
+    VkBool32 shaderSubgroupExtendedTypes;
+    VkBool32 separateDepthStencilLayouts;
+    VkBool32 hostQueryReset;
+    VkBool32 timelineSemaphore;
+    VkBool32 bufferDeviceAddress;
+    VkBool32 bufferDeviceAddressCaptureReplay;
+    VkBool32 bufferDeviceAddressMultiDevice;
+    VkBool32 vulkanMemoryModel;
+    VkBool32 vulkanMemoryModelDeviceScope;
+    VkBool32 vulkanMemoryModelAvailabilityVisibilityChains;
+    VkBool32 shaderOutputViewportIndex;
+    VkBool32 shaderOutputLayer;
+    VkBool32 subgroupBroadcastDynamicId;
+
+    safe_VkPhysicalDeviceVulkan12Features(const VkPhysicalDeviceVulkan12Features* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkPhysicalDeviceVulkan12Features(const safe_VkPhysicalDeviceVulkan12Features& copy_src);
+    safe_VkPhysicalDeviceVulkan12Features& operator=(const safe_VkPhysicalDeviceVulkan12Features& copy_src);
+    safe_VkPhysicalDeviceVulkan12Features();
+    ~safe_VkPhysicalDeviceVulkan12Features();
+    void initialize(const VkPhysicalDeviceVulkan12Features* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceVulkan12Features* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVulkan12Features* ptr() { return reinterpret_cast<VkPhysicalDeviceVulkan12Features*>(this); }
+    VkPhysicalDeviceVulkan12Features const* ptr() const { return reinterpret_cast<VkPhysicalDeviceVulkan12Features const*>(this); }
+};
+struct safe_VkPhysicalDeviceVulkan12Properties {
+    VkStructureType sType;
+    void* pNext{};
+    VkDriverId driverID;
+    char driverName[VK_MAX_DRIVER_NAME_SIZE];
+    char driverInfo[VK_MAX_DRIVER_INFO_SIZE];
+    VkConformanceVersion conformanceVersion;
+    VkShaderFloatControlsIndependence denormBehaviorIndependence;
+    VkShaderFloatControlsIndependence roundingModeIndependence;
+    VkBool32 shaderSignedZeroInfNanPreserveFloat16;
+    VkBool32 shaderSignedZeroInfNanPreserveFloat32;
+    VkBool32 shaderSignedZeroInfNanPreserveFloat64;
+    VkBool32 shaderDenormPreserveFloat16;
+    VkBool32 shaderDenormPreserveFloat32;
+    VkBool32 shaderDenormPreserveFloat64;
+    VkBool32 shaderDenormFlushToZeroFloat16;
+    VkBool32 shaderDenormFlushToZeroFloat32;
+    VkBool32 shaderDenormFlushToZeroFloat64;
+    VkBool32 shaderRoundingModeRTEFloat16;
+    VkBool32 shaderRoundingModeRTEFloat32;
+    VkBool32 shaderRoundingModeRTEFloat64;
+    VkBool32 shaderRoundingModeRTZFloat16;
+    VkBool32 shaderRoundingModeRTZFloat32;
+    VkBool32 shaderRoundingModeRTZFloat64;
+    uint32_t maxUpdateAfterBindDescriptorsInAllPools;
+    VkBool32 shaderUniformBufferArrayNonUniformIndexingNative;
+    VkBool32 shaderSampledImageArrayNonUniformIndexingNative;
+    VkBool32 shaderStorageBufferArrayNonUniformIndexingNative;
+    VkBool32 shaderStorageImageArrayNonUniformIndexingNative;
+    VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative;
+    VkBool32 robustBufferAccessUpdateAfterBind;
+    VkBool32 quadDivergentImplicitLod;
+    uint32_t maxPerStageDescriptorUpdateAfterBindSamplers;
+    uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers;
+    uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers;
+    uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages;
+    uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages;
+    uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments;
+    uint32_t maxPerStageUpdateAfterBindResources;
+    uint32_t maxDescriptorSetUpdateAfterBindSamplers;
+    uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers;
+    uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
+    uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers;
+    uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
+    uint32_t maxDescriptorSetUpdateAfterBindSampledImages;
+    uint32_t maxDescriptorSetUpdateAfterBindStorageImages;
+    uint32_t maxDescriptorSetUpdateAfterBindInputAttachments;
+    VkResolveModeFlags supportedDepthResolveModes;
+    VkResolveModeFlags supportedStencilResolveModes;
+    VkBool32 independentResolveNone;
+    VkBool32 independentResolve;
+    VkBool32 filterMinmaxSingleComponentFormats;
+    VkBool32 filterMinmaxImageComponentMapping;
+    uint64_t maxTimelineSemaphoreValueDifference;
+    VkSampleCountFlags framebufferIntegerColorSampleCounts;
+
+    safe_VkPhysicalDeviceVulkan12Properties(const VkPhysicalDeviceVulkan12Properties* in_struct, PNextCopyState* copy_state = {},
+                                            bool copy_pnext = true);
+    safe_VkPhysicalDeviceVulkan12Properties(const safe_VkPhysicalDeviceVulkan12Properties& copy_src);
+    safe_VkPhysicalDeviceVulkan12Properties& operator=(const safe_VkPhysicalDeviceVulkan12Properties& copy_src);
+    safe_VkPhysicalDeviceVulkan12Properties();
+    ~safe_VkPhysicalDeviceVulkan12Properties();
+    void initialize(const VkPhysicalDeviceVulkan12Properties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceVulkan12Properties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVulkan12Properties* ptr() { return reinterpret_cast<VkPhysicalDeviceVulkan12Properties*>(this); }
+    VkPhysicalDeviceVulkan12Properties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceVulkan12Properties const*>(this);
+    }
+};
+struct safe_VkImageFormatListCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t viewFormatCount;
+    const VkFormat* pViewFormats{};
+
+    safe_VkImageFormatListCreateInfo(const VkImageFormatListCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    safe_VkImageFormatListCreateInfo(const safe_VkImageFormatListCreateInfo& copy_src);
+    safe_VkImageFormatListCreateInfo& operator=(const safe_VkImageFormatListCreateInfo& copy_src);
+    safe_VkImageFormatListCreateInfo();
+    ~safe_VkImageFormatListCreateInfo();
+    void initialize(const VkImageFormatListCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageFormatListCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkImageFormatListCreateInfo* ptr() { return reinterpret_cast<VkImageFormatListCreateInfo*>(this); }
+    VkImageFormatListCreateInfo const* ptr() const { return reinterpret_cast<VkImageFormatListCreateInfo const*>(this); }
+};
+struct safe_VkAttachmentDescription2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAttachmentDescriptionFlags flags;
+    VkFormat format;
+    VkSampleCountFlagBits samples;
+    VkAttachmentLoadOp loadOp;
+    VkAttachmentStoreOp storeOp;
+    VkAttachmentLoadOp stencilLoadOp;
+    VkAttachmentStoreOp stencilStoreOp;
+    VkImageLayout initialLayout;
+    VkImageLayout finalLayout;
+
+    safe_VkAttachmentDescription2(const VkAttachmentDescription2* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    safe_VkAttachmentDescription2(const safe_VkAttachmentDescription2& copy_src);
+    safe_VkAttachmentDescription2& operator=(const safe_VkAttachmentDescription2& copy_src);
+    safe_VkAttachmentDescription2();
+    ~safe_VkAttachmentDescription2();
+    void initialize(const VkAttachmentDescription2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAttachmentDescription2* copy_src, PNextCopyState* copy_state = {});
+    VkAttachmentDescription2* ptr() { return reinterpret_cast<VkAttachmentDescription2*>(this); }
+    VkAttachmentDescription2 const* ptr() const { return reinterpret_cast<VkAttachmentDescription2 const*>(this); }
+};
+struct safe_VkAttachmentReference2 {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t attachment;
+    VkImageLayout layout;
+    VkImageAspectFlags aspectMask;
+
+    safe_VkAttachmentReference2(const VkAttachmentReference2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkAttachmentReference2(const safe_VkAttachmentReference2& copy_src);
+    safe_VkAttachmentReference2& operator=(const safe_VkAttachmentReference2& copy_src);
+    safe_VkAttachmentReference2();
+    ~safe_VkAttachmentReference2();
+    void initialize(const VkAttachmentReference2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAttachmentReference2* copy_src, PNextCopyState* copy_state = {});
+    VkAttachmentReference2* ptr() { return reinterpret_cast<VkAttachmentReference2*>(this); }
+    VkAttachmentReference2 const* ptr() const { return reinterpret_cast<VkAttachmentReference2 const*>(this); }
+};
+struct safe_VkSubpassDescription2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSubpassDescriptionFlags flags;
+    VkPipelineBindPoint pipelineBindPoint;
+    uint32_t viewMask;
+    uint32_t inputAttachmentCount;
+    safe_VkAttachmentReference2* pInputAttachments{};
+    uint32_t colorAttachmentCount;
+    safe_VkAttachmentReference2* pColorAttachments{};
+    safe_VkAttachmentReference2* pResolveAttachments{};
+    safe_VkAttachmentReference2* pDepthStencilAttachment{};
+    uint32_t preserveAttachmentCount;
+    const uint32_t* pPreserveAttachments{};
+
+    safe_VkSubpassDescription2(const VkSubpassDescription2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSubpassDescription2(const safe_VkSubpassDescription2& copy_src);
+    safe_VkSubpassDescription2& operator=(const safe_VkSubpassDescription2& copy_src);
+    safe_VkSubpassDescription2();
+    ~safe_VkSubpassDescription2();
+    void initialize(const VkSubpassDescription2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSubpassDescription2* copy_src, PNextCopyState* copy_state = {});
+    VkSubpassDescription2* ptr() { return reinterpret_cast<VkSubpassDescription2*>(this); }
+    VkSubpassDescription2 const* ptr() const { return reinterpret_cast<VkSubpassDescription2 const*>(this); }
+};
+struct safe_VkSubpassDependency2 {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t srcSubpass;
+    uint32_t dstSubpass;
+    VkPipelineStageFlags srcStageMask;
+    VkPipelineStageFlags dstStageMask;
+    VkAccessFlags srcAccessMask;
+    VkAccessFlags dstAccessMask;
+    VkDependencyFlags dependencyFlags;
+    int32_t viewOffset;
+
+    safe_VkSubpassDependency2(const VkSubpassDependency2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSubpassDependency2(const safe_VkSubpassDependency2& copy_src);
+    safe_VkSubpassDependency2& operator=(const safe_VkSubpassDependency2& copy_src);
+    safe_VkSubpassDependency2();
+    ~safe_VkSubpassDependency2();
+    void initialize(const VkSubpassDependency2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSubpassDependency2* copy_src, PNextCopyState* copy_state = {});
+    VkSubpassDependency2* ptr() { return reinterpret_cast<VkSubpassDependency2*>(this); }
+    VkSubpassDependency2 const* ptr() const { return reinterpret_cast<VkSubpassDependency2 const*>(this); }
+};
+struct safe_VkRenderPassCreateInfo2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkRenderPassCreateFlags flags;
+    uint32_t attachmentCount;
+    safe_VkAttachmentDescription2* pAttachments{};
+    uint32_t subpassCount;
+    safe_VkSubpassDescription2* pSubpasses{};
+    uint32_t dependencyCount;
+    safe_VkSubpassDependency2* pDependencies{};
+    uint32_t correlatedViewMaskCount;
+    const uint32_t* pCorrelatedViewMasks{};
+
+    safe_VkRenderPassCreateInfo2(const VkRenderPassCreateInfo2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkRenderPassCreateInfo2(const safe_VkRenderPassCreateInfo2& copy_src);
+    safe_VkRenderPassCreateInfo2& operator=(const safe_VkRenderPassCreateInfo2& copy_src);
+    safe_VkRenderPassCreateInfo2();
+    ~safe_VkRenderPassCreateInfo2();
+    void initialize(const VkRenderPassCreateInfo2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderPassCreateInfo2* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassCreateInfo2* ptr() { return reinterpret_cast<VkRenderPassCreateInfo2*>(this); }
+    VkRenderPassCreateInfo2 const* ptr() const { return reinterpret_cast<VkRenderPassCreateInfo2 const*>(this); }
+};
+struct safe_VkSubpassBeginInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSubpassContents contents;
+
+    safe_VkSubpassBeginInfo(const VkSubpassBeginInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSubpassBeginInfo(const safe_VkSubpassBeginInfo& copy_src);
+    safe_VkSubpassBeginInfo& operator=(const safe_VkSubpassBeginInfo& copy_src);
+    safe_VkSubpassBeginInfo();
+    ~safe_VkSubpassBeginInfo();
+    void initialize(const VkSubpassBeginInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSubpassBeginInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSubpassBeginInfo* ptr() { return reinterpret_cast<VkSubpassBeginInfo*>(this); }
+    VkSubpassBeginInfo const* ptr() const { return reinterpret_cast<VkSubpassBeginInfo const*>(this); }
+};
+struct safe_VkSubpassEndInfo {
+    VkStructureType sType;
+    const void* pNext{};
+
+    safe_VkSubpassEndInfo(const VkSubpassEndInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSubpassEndInfo(const safe_VkSubpassEndInfo& copy_src);
+    safe_VkSubpassEndInfo& operator=(const safe_VkSubpassEndInfo& copy_src);
+    safe_VkSubpassEndInfo();
+    ~safe_VkSubpassEndInfo();
+    void initialize(const VkSubpassEndInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSubpassEndInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSubpassEndInfo* ptr() { return reinterpret_cast<VkSubpassEndInfo*>(this); }
+    VkSubpassEndInfo const* ptr() const { return reinterpret_cast<VkSubpassEndInfo const*>(this); }
+};
+struct safe_VkPhysicalDevice8BitStorageFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 storageBuffer8BitAccess;
+    VkBool32 uniformAndStorageBuffer8BitAccess;
+    VkBool32 storagePushConstant8;
+
+    safe_VkPhysicalDevice8BitStorageFeatures(const VkPhysicalDevice8BitStorageFeatures* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkPhysicalDevice8BitStorageFeatures(const safe_VkPhysicalDevice8BitStorageFeatures& copy_src);
+    safe_VkPhysicalDevice8BitStorageFeatures& operator=(const safe_VkPhysicalDevice8BitStorageFeatures& copy_src);
+    safe_VkPhysicalDevice8BitStorageFeatures();
+    ~safe_VkPhysicalDevice8BitStorageFeatures();
+    void initialize(const VkPhysicalDevice8BitStorageFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevice8BitStorageFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevice8BitStorageFeatures* ptr() { return reinterpret_cast<VkPhysicalDevice8BitStorageFeatures*>(this); }
+    VkPhysicalDevice8BitStorageFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevice8BitStorageFeatures const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceDriverProperties {
+    VkStructureType sType;
+    void* pNext{};
+    VkDriverId driverID;
+    char driverName[VK_MAX_DRIVER_NAME_SIZE];
+    char driverInfo[VK_MAX_DRIVER_INFO_SIZE];
+    VkConformanceVersion conformanceVersion;
+
+    safe_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkPhysicalDeviceDriverProperties(const safe_VkPhysicalDeviceDriverProperties& copy_src);
+    safe_VkPhysicalDeviceDriverProperties& operator=(const safe_VkPhysicalDeviceDriverProperties& copy_src);
+    safe_VkPhysicalDeviceDriverProperties();
+    ~safe_VkPhysicalDeviceDriverProperties();
+    void initialize(const VkPhysicalDeviceDriverProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDriverProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDriverProperties* ptr() { return reinterpret_cast<VkPhysicalDeviceDriverProperties*>(this); }
+    VkPhysicalDeviceDriverProperties const* ptr() const { return reinterpret_cast<VkPhysicalDeviceDriverProperties const*>(this); }
+};
+struct safe_VkPhysicalDeviceShaderAtomicInt64Features {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderBufferInt64Atomics;
+    VkBool32 shaderSharedInt64Atomics;
+
+    safe_VkPhysicalDeviceShaderAtomicInt64Features(const VkPhysicalDeviceShaderAtomicInt64Features* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderAtomicInt64Features(const safe_VkPhysicalDeviceShaderAtomicInt64Features& copy_src);
+    safe_VkPhysicalDeviceShaderAtomicInt64Features& operator=(const safe_VkPhysicalDeviceShaderAtomicInt64Features& copy_src);
+    safe_VkPhysicalDeviceShaderAtomicInt64Features();
+    ~safe_VkPhysicalDeviceShaderAtomicInt64Features();
+    void initialize(const VkPhysicalDeviceShaderAtomicInt64Features* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderAtomicInt64Features* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderAtomicInt64Features* ptr() { return reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64Features*>(this); }
+    VkPhysicalDeviceShaderAtomicInt64Features const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64Features const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceShaderFloat16Int8Features {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderFloat16;
+    VkBool32 shaderInt8;
+
+    safe_VkPhysicalDeviceShaderFloat16Int8Features(const VkPhysicalDeviceShaderFloat16Int8Features* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderFloat16Int8Features(const safe_VkPhysicalDeviceShaderFloat16Int8Features& copy_src);
+    safe_VkPhysicalDeviceShaderFloat16Int8Features& operator=(const safe_VkPhysicalDeviceShaderFloat16Int8Features& copy_src);
+    safe_VkPhysicalDeviceShaderFloat16Int8Features();
+    ~safe_VkPhysicalDeviceShaderFloat16Int8Features();
+    void initialize(const VkPhysicalDeviceShaderFloat16Int8Features* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderFloat16Int8Features* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderFloat16Int8Features* ptr() { return reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features*>(this); }
+    VkPhysicalDeviceShaderFloat16Int8Features const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceFloatControlsProperties {
+    VkStructureType sType;
+    void* pNext{};
+    VkShaderFloatControlsIndependence denormBehaviorIndependence;
+    VkShaderFloatControlsIndependence roundingModeIndependence;
+    VkBool32 shaderSignedZeroInfNanPreserveFloat16;
+    VkBool32 shaderSignedZeroInfNanPreserveFloat32;
+    VkBool32 shaderSignedZeroInfNanPreserveFloat64;
+    VkBool32 shaderDenormPreserveFloat16;
+    VkBool32 shaderDenormPreserveFloat32;
+    VkBool32 shaderDenormPreserveFloat64;
+    VkBool32 shaderDenormFlushToZeroFloat16;
+    VkBool32 shaderDenormFlushToZeroFloat32;
+    VkBool32 shaderDenormFlushToZeroFloat64;
+    VkBool32 shaderRoundingModeRTEFloat16;
+    VkBool32 shaderRoundingModeRTEFloat32;
+    VkBool32 shaderRoundingModeRTEFloat64;
+    VkBool32 shaderRoundingModeRTZFloat16;
+    VkBool32 shaderRoundingModeRTZFloat32;
+    VkBool32 shaderRoundingModeRTZFloat64;
+
+    safe_VkPhysicalDeviceFloatControlsProperties(const VkPhysicalDeviceFloatControlsProperties* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceFloatControlsProperties(const safe_VkPhysicalDeviceFloatControlsProperties& copy_src);
+    safe_VkPhysicalDeviceFloatControlsProperties& operator=(const safe_VkPhysicalDeviceFloatControlsProperties& copy_src);
+    safe_VkPhysicalDeviceFloatControlsProperties();
+    ~safe_VkPhysicalDeviceFloatControlsProperties();
+    void initialize(const VkPhysicalDeviceFloatControlsProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceFloatControlsProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFloatControlsProperties* ptr() { return reinterpret_cast<VkPhysicalDeviceFloatControlsProperties*>(this); }
+    VkPhysicalDeviceFloatControlsProperties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFloatControlsProperties const*>(this);
+    }
+};
+struct safe_VkDescriptorSetLayoutBindingFlagsCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t bindingCount;
+    const VkDescriptorBindingFlags* pBindingFlags{};
+
+    safe_VkDescriptorSetLayoutBindingFlagsCreateInfo(const VkDescriptorSetLayoutBindingFlagsCreateInfo* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDescriptorSetLayoutBindingFlagsCreateInfo(const safe_VkDescriptorSetLayoutBindingFlagsCreateInfo& copy_src);
+    safe_VkDescriptorSetLayoutBindingFlagsCreateInfo& operator=(const safe_VkDescriptorSetLayoutBindingFlagsCreateInfo& copy_src);
+    safe_VkDescriptorSetLayoutBindingFlagsCreateInfo();
+    ~safe_VkDescriptorSetLayoutBindingFlagsCreateInfo();
+    void initialize(const VkDescriptorSetLayoutBindingFlagsCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDescriptorSetLayoutBindingFlagsCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorSetLayoutBindingFlagsCreateInfo* ptr() {
+        return reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo*>(this);
+    }
+    VkDescriptorSetLayoutBindingFlagsCreateInfo const* ptr() const {
+        return reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceDescriptorIndexingFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderInputAttachmentArrayDynamicIndexing;
+    VkBool32 shaderUniformTexelBufferArrayDynamicIndexing;
+    VkBool32 shaderStorageTexelBufferArrayDynamicIndexing;
+    VkBool32 shaderUniformBufferArrayNonUniformIndexing;
+    VkBool32 shaderSampledImageArrayNonUniformIndexing;
+    VkBool32 shaderStorageBufferArrayNonUniformIndexing;
+    VkBool32 shaderStorageImageArrayNonUniformIndexing;
+    VkBool32 shaderInputAttachmentArrayNonUniformIndexing;
+    VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing;
+    VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing;
+    VkBool32 descriptorBindingUniformBufferUpdateAfterBind;
+    VkBool32 descriptorBindingSampledImageUpdateAfterBind;
+    VkBool32 descriptorBindingStorageImageUpdateAfterBind;
+    VkBool32 descriptorBindingStorageBufferUpdateAfterBind;
+    VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind;
+    VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind;
+    VkBool32 descriptorBindingUpdateUnusedWhilePending;
+    VkBool32 descriptorBindingPartiallyBound;
+    VkBool32 descriptorBindingVariableDescriptorCount;
+    VkBool32 runtimeDescriptorArray;
+
+    safe_VkPhysicalDeviceDescriptorIndexingFeatures(const VkPhysicalDeviceDescriptorIndexingFeatures* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceDescriptorIndexingFeatures(const safe_VkPhysicalDeviceDescriptorIndexingFeatures& copy_src);
+    safe_VkPhysicalDeviceDescriptorIndexingFeatures& operator=(const safe_VkPhysicalDeviceDescriptorIndexingFeatures& copy_src);
+    safe_VkPhysicalDeviceDescriptorIndexingFeatures();
+    ~safe_VkPhysicalDeviceDescriptorIndexingFeatures();
+    void initialize(const VkPhysicalDeviceDescriptorIndexingFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDescriptorIndexingFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDescriptorIndexingFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeatures*>(this);
+    }
+    VkPhysicalDeviceDescriptorIndexingFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeatures const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceDescriptorIndexingProperties {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxUpdateAfterBindDescriptorsInAllPools;
+    VkBool32 shaderUniformBufferArrayNonUniformIndexingNative;
+    VkBool32 shaderSampledImageArrayNonUniformIndexingNative;
+    VkBool32 shaderStorageBufferArrayNonUniformIndexingNative;
+    VkBool32 shaderStorageImageArrayNonUniformIndexingNative;
+    VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative;
+    VkBool32 robustBufferAccessUpdateAfterBind;
+    VkBool32 quadDivergentImplicitLod;
+    uint32_t maxPerStageDescriptorUpdateAfterBindSamplers;
+    uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers;
+    uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers;
+    uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages;
+    uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages;
+    uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments;
+    uint32_t maxPerStageUpdateAfterBindResources;
+    uint32_t maxDescriptorSetUpdateAfterBindSamplers;
+    uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers;
+    uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
+    uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers;
+    uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
+    uint32_t maxDescriptorSetUpdateAfterBindSampledImages;
+    uint32_t maxDescriptorSetUpdateAfterBindStorageImages;
+    uint32_t maxDescriptorSetUpdateAfterBindInputAttachments;
+
+    safe_VkPhysicalDeviceDescriptorIndexingProperties(const VkPhysicalDeviceDescriptorIndexingProperties* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceDescriptorIndexingProperties(const safe_VkPhysicalDeviceDescriptorIndexingProperties& copy_src);
+    safe_VkPhysicalDeviceDescriptorIndexingProperties& operator=(const safe_VkPhysicalDeviceDescriptorIndexingProperties& copy_src);
+    safe_VkPhysicalDeviceDescriptorIndexingProperties();
+    ~safe_VkPhysicalDeviceDescriptorIndexingProperties();
+    void initialize(const VkPhysicalDeviceDescriptorIndexingProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDescriptorIndexingProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDescriptorIndexingProperties* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorIndexingProperties*>(this);
+    }
+    VkPhysicalDeviceDescriptorIndexingProperties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorIndexingProperties const*>(this);
+    }
+};
+struct safe_VkDescriptorSetVariableDescriptorCountAllocateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t descriptorSetCount;
+    const uint32_t* pDescriptorCounts{};
+
+    safe_VkDescriptorSetVariableDescriptorCountAllocateInfo(const VkDescriptorSetVariableDescriptorCountAllocateInfo* in_struct,
+                                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDescriptorSetVariableDescriptorCountAllocateInfo(
+        const safe_VkDescriptorSetVariableDescriptorCountAllocateInfo& copy_src);
+    safe_VkDescriptorSetVariableDescriptorCountAllocateInfo& operator=(
+        const safe_VkDescriptorSetVariableDescriptorCountAllocateInfo& copy_src);
+    safe_VkDescriptorSetVariableDescriptorCountAllocateInfo();
+    ~safe_VkDescriptorSetVariableDescriptorCountAllocateInfo();
+    void initialize(const VkDescriptorSetVariableDescriptorCountAllocateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDescriptorSetVariableDescriptorCountAllocateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorSetVariableDescriptorCountAllocateInfo* ptr() {
+        return reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo*>(this);
+    }
+    VkDescriptorSetVariableDescriptorCountAllocateInfo const* ptr() const {
+        return reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo const*>(this);
+    }
+};
+struct safe_VkDescriptorSetVariableDescriptorCountLayoutSupport {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxVariableDescriptorCount;
+
+    safe_VkDescriptorSetVariableDescriptorCountLayoutSupport(const VkDescriptorSetVariableDescriptorCountLayoutSupport* in_struct,
+                                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDescriptorSetVariableDescriptorCountLayoutSupport(
+        const safe_VkDescriptorSetVariableDescriptorCountLayoutSupport& copy_src);
+    safe_VkDescriptorSetVariableDescriptorCountLayoutSupport& operator=(
+        const safe_VkDescriptorSetVariableDescriptorCountLayoutSupport& copy_src);
+    safe_VkDescriptorSetVariableDescriptorCountLayoutSupport();
+    ~safe_VkDescriptorSetVariableDescriptorCountLayoutSupport();
+    void initialize(const VkDescriptorSetVariableDescriptorCountLayoutSupport* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDescriptorSetVariableDescriptorCountLayoutSupport* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorSetVariableDescriptorCountLayoutSupport* ptr() {
+        return reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport*>(this);
+    }
+    VkDescriptorSetVariableDescriptorCountLayoutSupport const* ptr() const {
+        return reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport const*>(this);
+    }
+};
+struct safe_VkSubpassDescriptionDepthStencilResolve {
+    VkStructureType sType;
+    const void* pNext{};
+    VkResolveModeFlagBits depthResolveMode;
+    VkResolveModeFlagBits stencilResolveMode;
+    safe_VkAttachmentReference2* pDepthStencilResolveAttachment{};
+
+    safe_VkSubpassDescriptionDepthStencilResolve(const VkSubpassDescriptionDepthStencilResolve* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSubpassDescriptionDepthStencilResolve(const safe_VkSubpassDescriptionDepthStencilResolve& copy_src);
+    safe_VkSubpassDescriptionDepthStencilResolve& operator=(const safe_VkSubpassDescriptionDepthStencilResolve& copy_src);
+    safe_VkSubpassDescriptionDepthStencilResolve();
+    ~safe_VkSubpassDescriptionDepthStencilResolve();
+    void initialize(const VkSubpassDescriptionDepthStencilResolve* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSubpassDescriptionDepthStencilResolve* copy_src, PNextCopyState* copy_state = {});
+    VkSubpassDescriptionDepthStencilResolve* ptr() { return reinterpret_cast<VkSubpassDescriptionDepthStencilResolve*>(this); }
+    VkSubpassDescriptionDepthStencilResolve const* ptr() const {
+        return reinterpret_cast<VkSubpassDescriptionDepthStencilResolve const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceDepthStencilResolveProperties {
+    VkStructureType sType;
+    void* pNext{};
+    VkResolveModeFlags supportedDepthResolveModes;
+    VkResolveModeFlags supportedStencilResolveModes;
+    VkBool32 independentResolveNone;
+    VkBool32 independentResolve;
+
+    safe_VkPhysicalDeviceDepthStencilResolveProperties(const VkPhysicalDeviceDepthStencilResolveProperties* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceDepthStencilResolveProperties(const safe_VkPhysicalDeviceDepthStencilResolveProperties& copy_src);
+    safe_VkPhysicalDeviceDepthStencilResolveProperties& operator=(
+        const safe_VkPhysicalDeviceDepthStencilResolveProperties& copy_src);
+    safe_VkPhysicalDeviceDepthStencilResolveProperties();
+    ~safe_VkPhysicalDeviceDepthStencilResolveProperties();
+    void initialize(const VkPhysicalDeviceDepthStencilResolveProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDepthStencilResolveProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDepthStencilResolveProperties* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDepthStencilResolveProperties*>(this);
+    }
+    VkPhysicalDeviceDepthStencilResolveProperties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDepthStencilResolveProperties const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceScalarBlockLayoutFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 scalarBlockLayout;
+
+    safe_VkPhysicalDeviceScalarBlockLayoutFeatures(const VkPhysicalDeviceScalarBlockLayoutFeatures* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceScalarBlockLayoutFeatures(const safe_VkPhysicalDeviceScalarBlockLayoutFeatures& copy_src);
+    safe_VkPhysicalDeviceScalarBlockLayoutFeatures& operator=(const safe_VkPhysicalDeviceScalarBlockLayoutFeatures& copy_src);
+    safe_VkPhysicalDeviceScalarBlockLayoutFeatures();
+    ~safe_VkPhysicalDeviceScalarBlockLayoutFeatures();
+    void initialize(const VkPhysicalDeviceScalarBlockLayoutFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceScalarBlockLayoutFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceScalarBlockLayoutFeatures* ptr() { return reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeatures*>(this); }
+    VkPhysicalDeviceScalarBlockLayoutFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeatures const*>(this);
+    }
+};
+struct safe_VkImageStencilUsageCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageUsageFlags stencilUsage;
+
+    safe_VkImageStencilUsageCreateInfo(const VkImageStencilUsageCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    safe_VkImageStencilUsageCreateInfo(const safe_VkImageStencilUsageCreateInfo& copy_src);
+    safe_VkImageStencilUsageCreateInfo& operator=(const safe_VkImageStencilUsageCreateInfo& copy_src);
+    safe_VkImageStencilUsageCreateInfo();
+    ~safe_VkImageStencilUsageCreateInfo();
+    void initialize(const VkImageStencilUsageCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageStencilUsageCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkImageStencilUsageCreateInfo* ptr() { return reinterpret_cast<VkImageStencilUsageCreateInfo*>(this); }
+    VkImageStencilUsageCreateInfo const* ptr() const { return reinterpret_cast<VkImageStencilUsageCreateInfo const*>(this); }
+};
+struct safe_VkSamplerReductionModeCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSamplerReductionMode reductionMode;
+
+    safe_VkSamplerReductionModeCreateInfo(const VkSamplerReductionModeCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkSamplerReductionModeCreateInfo(const safe_VkSamplerReductionModeCreateInfo& copy_src);
+    safe_VkSamplerReductionModeCreateInfo& operator=(const safe_VkSamplerReductionModeCreateInfo& copy_src);
+    safe_VkSamplerReductionModeCreateInfo();
+    ~safe_VkSamplerReductionModeCreateInfo();
+    void initialize(const VkSamplerReductionModeCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSamplerReductionModeCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSamplerReductionModeCreateInfo* ptr() { return reinterpret_cast<VkSamplerReductionModeCreateInfo*>(this); }
+    VkSamplerReductionModeCreateInfo const* ptr() const { return reinterpret_cast<VkSamplerReductionModeCreateInfo const*>(this); }
+};
+struct safe_VkPhysicalDeviceSamplerFilterMinmaxProperties {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 filterMinmaxSingleComponentFormats;
+    VkBool32 filterMinmaxImageComponentMapping;
+
+    safe_VkPhysicalDeviceSamplerFilterMinmaxProperties(const VkPhysicalDeviceSamplerFilterMinmaxProperties* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceSamplerFilterMinmaxProperties(const safe_VkPhysicalDeviceSamplerFilterMinmaxProperties& copy_src);
+    safe_VkPhysicalDeviceSamplerFilterMinmaxProperties& operator=(
+        const safe_VkPhysicalDeviceSamplerFilterMinmaxProperties& copy_src);
+    safe_VkPhysicalDeviceSamplerFilterMinmaxProperties();
+    ~safe_VkPhysicalDeviceSamplerFilterMinmaxProperties();
+    void initialize(const VkPhysicalDeviceSamplerFilterMinmaxProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceSamplerFilterMinmaxProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSamplerFilterMinmaxProperties* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxProperties*>(this);
+    }
+    VkPhysicalDeviceSamplerFilterMinmaxProperties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxProperties const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceVulkanMemoryModelFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 vulkanMemoryModel;
+    VkBool32 vulkanMemoryModelDeviceScope;
+    VkBool32 vulkanMemoryModelAvailabilityVisibilityChains;
+
+    safe_VkPhysicalDeviceVulkanMemoryModelFeatures(const VkPhysicalDeviceVulkanMemoryModelFeatures* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceVulkanMemoryModelFeatures(const safe_VkPhysicalDeviceVulkanMemoryModelFeatures& copy_src);
+    safe_VkPhysicalDeviceVulkanMemoryModelFeatures& operator=(const safe_VkPhysicalDeviceVulkanMemoryModelFeatures& copy_src);
+    safe_VkPhysicalDeviceVulkanMemoryModelFeatures();
+    ~safe_VkPhysicalDeviceVulkanMemoryModelFeatures();
+    void initialize(const VkPhysicalDeviceVulkanMemoryModelFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceVulkanMemoryModelFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVulkanMemoryModelFeatures* ptr() { return reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeatures*>(this); }
+    VkPhysicalDeviceVulkanMemoryModelFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeatures const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceImagelessFramebufferFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 imagelessFramebuffer;
+
+    safe_VkPhysicalDeviceImagelessFramebufferFeatures(const VkPhysicalDeviceImagelessFramebufferFeatures* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceImagelessFramebufferFeatures(const safe_VkPhysicalDeviceImagelessFramebufferFeatures& copy_src);
+    safe_VkPhysicalDeviceImagelessFramebufferFeatures& operator=(const safe_VkPhysicalDeviceImagelessFramebufferFeatures& copy_src);
+    safe_VkPhysicalDeviceImagelessFramebufferFeatures();
+    ~safe_VkPhysicalDeviceImagelessFramebufferFeatures();
+    void initialize(const VkPhysicalDeviceImagelessFramebufferFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceImagelessFramebufferFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceImagelessFramebufferFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeatures*>(this);
+    }
+    VkPhysicalDeviceImagelessFramebufferFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeatures const*>(this);
+    }
+};
+struct safe_VkFramebufferAttachmentImageInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageCreateFlags flags;
+    VkImageUsageFlags usage;
+    uint32_t width;
+    uint32_t height;
+    uint32_t layerCount;
+    uint32_t viewFormatCount;
+    const VkFormat* pViewFormats{};
+
+    safe_VkFramebufferAttachmentImageInfo(const VkFramebufferAttachmentImageInfo* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkFramebufferAttachmentImageInfo(const safe_VkFramebufferAttachmentImageInfo& copy_src);
+    safe_VkFramebufferAttachmentImageInfo& operator=(const safe_VkFramebufferAttachmentImageInfo& copy_src);
+    safe_VkFramebufferAttachmentImageInfo();
+    ~safe_VkFramebufferAttachmentImageInfo();
+    void initialize(const VkFramebufferAttachmentImageInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkFramebufferAttachmentImageInfo* copy_src, PNextCopyState* copy_state = {});
+    VkFramebufferAttachmentImageInfo* ptr() { return reinterpret_cast<VkFramebufferAttachmentImageInfo*>(this); }
+    VkFramebufferAttachmentImageInfo const* ptr() const { return reinterpret_cast<VkFramebufferAttachmentImageInfo const*>(this); }
+};
+struct safe_VkFramebufferAttachmentsCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t attachmentImageInfoCount;
+    safe_VkFramebufferAttachmentImageInfo* pAttachmentImageInfos{};
+
+    safe_VkFramebufferAttachmentsCreateInfo(const VkFramebufferAttachmentsCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                            bool copy_pnext = true);
+    safe_VkFramebufferAttachmentsCreateInfo(const safe_VkFramebufferAttachmentsCreateInfo& copy_src);
+    safe_VkFramebufferAttachmentsCreateInfo& operator=(const safe_VkFramebufferAttachmentsCreateInfo& copy_src);
+    safe_VkFramebufferAttachmentsCreateInfo();
+    ~safe_VkFramebufferAttachmentsCreateInfo();
+    void initialize(const VkFramebufferAttachmentsCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkFramebufferAttachmentsCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkFramebufferAttachmentsCreateInfo* ptr() { return reinterpret_cast<VkFramebufferAttachmentsCreateInfo*>(this); }
+    VkFramebufferAttachmentsCreateInfo const* ptr() const {
+        return reinterpret_cast<VkFramebufferAttachmentsCreateInfo const*>(this);
+    }
+};
+struct safe_VkRenderPassAttachmentBeginInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t attachmentCount;
+    VkImageView* pAttachments{};
+
+    safe_VkRenderPassAttachmentBeginInfo(const VkRenderPassAttachmentBeginInfo* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkRenderPassAttachmentBeginInfo(const safe_VkRenderPassAttachmentBeginInfo& copy_src);
+    safe_VkRenderPassAttachmentBeginInfo& operator=(const safe_VkRenderPassAttachmentBeginInfo& copy_src);
+    safe_VkRenderPassAttachmentBeginInfo();
+    ~safe_VkRenderPassAttachmentBeginInfo();
+    void initialize(const VkRenderPassAttachmentBeginInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderPassAttachmentBeginInfo* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassAttachmentBeginInfo* ptr() { return reinterpret_cast<VkRenderPassAttachmentBeginInfo*>(this); }
+    VkRenderPassAttachmentBeginInfo const* ptr() const { return reinterpret_cast<VkRenderPassAttachmentBeginInfo const*>(this); }
+};
+struct safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 uniformBufferStandardLayout;
+
+    safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* in_struct,
+                                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
+        const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures& copy_src);
+    safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures& operator=(
+        const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures& copy_src);
+    safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures();
+    ~safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures();
+    void initialize(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceUniformBufferStandardLayoutFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures*>(this);
+    }
+    VkPhysicalDeviceUniformBufferStandardLayoutFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderSubgroupExtendedTypes;
+
+    safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* in_struct,
+                                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
+        const safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& copy_src);
+    safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& operator=(
+        const safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& copy_src);
+    safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures();
+    ~safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures();
+    void initialize(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures*>(this);
+    }
+    VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 separateDepthStencilLayouts;
+
+    safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* in_struct,
+                                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
+        const safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& copy_src);
+    safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& operator=(
+        const safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& copy_src);
+    safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures();
+    ~safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures();
+    void initialize(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures*>(this);
+    }
+    VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures const*>(this);
+    }
+};
+struct safe_VkAttachmentReferenceStencilLayout {
+    VkStructureType sType;
+    void* pNext{};
+    VkImageLayout stencilLayout;
+
+    safe_VkAttachmentReferenceStencilLayout(const VkAttachmentReferenceStencilLayout* in_struct, PNextCopyState* copy_state = {},
+                                            bool copy_pnext = true);
+    safe_VkAttachmentReferenceStencilLayout(const safe_VkAttachmentReferenceStencilLayout& copy_src);
+    safe_VkAttachmentReferenceStencilLayout& operator=(const safe_VkAttachmentReferenceStencilLayout& copy_src);
+    safe_VkAttachmentReferenceStencilLayout();
+    ~safe_VkAttachmentReferenceStencilLayout();
+    void initialize(const VkAttachmentReferenceStencilLayout* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAttachmentReferenceStencilLayout* copy_src, PNextCopyState* copy_state = {});
+    VkAttachmentReferenceStencilLayout* ptr() { return reinterpret_cast<VkAttachmentReferenceStencilLayout*>(this); }
+    VkAttachmentReferenceStencilLayout const* ptr() const {
+        return reinterpret_cast<VkAttachmentReferenceStencilLayout const*>(this);
+    }
+};
+struct safe_VkAttachmentDescriptionStencilLayout {
+    VkStructureType sType;
+    void* pNext{};
+    VkImageLayout stencilInitialLayout;
+    VkImageLayout stencilFinalLayout;
+
+    safe_VkAttachmentDescriptionStencilLayout(const VkAttachmentDescriptionStencilLayout* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkAttachmentDescriptionStencilLayout(const safe_VkAttachmentDescriptionStencilLayout& copy_src);
+    safe_VkAttachmentDescriptionStencilLayout& operator=(const safe_VkAttachmentDescriptionStencilLayout& copy_src);
+    safe_VkAttachmentDescriptionStencilLayout();
+    ~safe_VkAttachmentDescriptionStencilLayout();
+    void initialize(const VkAttachmentDescriptionStencilLayout* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAttachmentDescriptionStencilLayout* copy_src, PNextCopyState* copy_state = {});
+    VkAttachmentDescriptionStencilLayout* ptr() { return reinterpret_cast<VkAttachmentDescriptionStencilLayout*>(this); }
+    VkAttachmentDescriptionStencilLayout const* ptr() const {
+        return reinterpret_cast<VkAttachmentDescriptionStencilLayout const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceHostQueryResetFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 hostQueryReset;
+
+    safe_VkPhysicalDeviceHostQueryResetFeatures(const VkPhysicalDeviceHostQueryResetFeatures* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceHostQueryResetFeatures(const safe_VkPhysicalDeviceHostQueryResetFeatures& copy_src);
+    safe_VkPhysicalDeviceHostQueryResetFeatures& operator=(const safe_VkPhysicalDeviceHostQueryResetFeatures& copy_src);
+    safe_VkPhysicalDeviceHostQueryResetFeatures();
+    ~safe_VkPhysicalDeviceHostQueryResetFeatures();
+    void initialize(const VkPhysicalDeviceHostQueryResetFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceHostQueryResetFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceHostQueryResetFeatures* ptr() { return reinterpret_cast<VkPhysicalDeviceHostQueryResetFeatures*>(this); }
+    VkPhysicalDeviceHostQueryResetFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceHostQueryResetFeatures const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceTimelineSemaphoreFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 timelineSemaphore;
+
+    safe_VkPhysicalDeviceTimelineSemaphoreFeatures(const VkPhysicalDeviceTimelineSemaphoreFeatures* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceTimelineSemaphoreFeatures(const safe_VkPhysicalDeviceTimelineSemaphoreFeatures& copy_src);
+    safe_VkPhysicalDeviceTimelineSemaphoreFeatures& operator=(const safe_VkPhysicalDeviceTimelineSemaphoreFeatures& copy_src);
+    safe_VkPhysicalDeviceTimelineSemaphoreFeatures();
+    ~safe_VkPhysicalDeviceTimelineSemaphoreFeatures();
+    void initialize(const VkPhysicalDeviceTimelineSemaphoreFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceTimelineSemaphoreFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceTimelineSemaphoreFeatures* ptr() { return reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeatures*>(this); }
+    VkPhysicalDeviceTimelineSemaphoreFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeatures const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceTimelineSemaphoreProperties {
+    VkStructureType sType;
+    void* pNext{};
+    uint64_t maxTimelineSemaphoreValueDifference;
+
+    safe_VkPhysicalDeviceTimelineSemaphoreProperties(const VkPhysicalDeviceTimelineSemaphoreProperties* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceTimelineSemaphoreProperties(const safe_VkPhysicalDeviceTimelineSemaphoreProperties& copy_src);
+    safe_VkPhysicalDeviceTimelineSemaphoreProperties& operator=(const safe_VkPhysicalDeviceTimelineSemaphoreProperties& copy_src);
+    safe_VkPhysicalDeviceTimelineSemaphoreProperties();
+    ~safe_VkPhysicalDeviceTimelineSemaphoreProperties();
+    void initialize(const VkPhysicalDeviceTimelineSemaphoreProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceTimelineSemaphoreProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceTimelineSemaphoreProperties* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreProperties*>(this);
+    }
+    VkPhysicalDeviceTimelineSemaphoreProperties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreProperties const*>(this);
+    }
+};
+struct safe_VkSemaphoreTypeCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSemaphoreType semaphoreType;
+    uint64_t initialValue;
+
+    safe_VkSemaphoreTypeCreateInfo(const VkSemaphoreTypeCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    safe_VkSemaphoreTypeCreateInfo(const safe_VkSemaphoreTypeCreateInfo& copy_src);
+    safe_VkSemaphoreTypeCreateInfo& operator=(const safe_VkSemaphoreTypeCreateInfo& copy_src);
+    safe_VkSemaphoreTypeCreateInfo();
+    ~safe_VkSemaphoreTypeCreateInfo();
+    void initialize(const VkSemaphoreTypeCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSemaphoreTypeCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSemaphoreTypeCreateInfo* ptr() { return reinterpret_cast<VkSemaphoreTypeCreateInfo*>(this); }
+    VkSemaphoreTypeCreateInfo const* ptr() const { return reinterpret_cast<VkSemaphoreTypeCreateInfo const*>(this); }
+};
+struct safe_VkTimelineSemaphoreSubmitInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t waitSemaphoreValueCount;
+    const uint64_t* pWaitSemaphoreValues{};
+    uint32_t signalSemaphoreValueCount;
+    const uint64_t* pSignalSemaphoreValues{};
+
+    safe_VkTimelineSemaphoreSubmitInfo(const VkTimelineSemaphoreSubmitInfo* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    safe_VkTimelineSemaphoreSubmitInfo(const safe_VkTimelineSemaphoreSubmitInfo& copy_src);
+    safe_VkTimelineSemaphoreSubmitInfo& operator=(const safe_VkTimelineSemaphoreSubmitInfo& copy_src);
+    safe_VkTimelineSemaphoreSubmitInfo();
+    ~safe_VkTimelineSemaphoreSubmitInfo();
+    void initialize(const VkTimelineSemaphoreSubmitInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkTimelineSemaphoreSubmitInfo* copy_src, PNextCopyState* copy_state = {});
+    VkTimelineSemaphoreSubmitInfo* ptr() { return reinterpret_cast<VkTimelineSemaphoreSubmitInfo*>(this); }
+    VkTimelineSemaphoreSubmitInfo const* ptr() const { return reinterpret_cast<VkTimelineSemaphoreSubmitInfo const*>(this); }
+};
+struct safe_VkSemaphoreWaitInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSemaphoreWaitFlags flags;
+    uint32_t semaphoreCount;
+    VkSemaphore* pSemaphores{};
+    const uint64_t* pValues{};
+
+    safe_VkSemaphoreWaitInfo(const VkSemaphoreWaitInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSemaphoreWaitInfo(const safe_VkSemaphoreWaitInfo& copy_src);
+    safe_VkSemaphoreWaitInfo& operator=(const safe_VkSemaphoreWaitInfo& copy_src);
+    safe_VkSemaphoreWaitInfo();
+    ~safe_VkSemaphoreWaitInfo();
+    void initialize(const VkSemaphoreWaitInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSemaphoreWaitInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSemaphoreWaitInfo* ptr() { return reinterpret_cast<VkSemaphoreWaitInfo*>(this); }
+    VkSemaphoreWaitInfo const* ptr() const { return reinterpret_cast<VkSemaphoreWaitInfo const*>(this); }
+};
+struct safe_VkSemaphoreSignalInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSemaphore semaphore;
+    uint64_t value;
+
+    safe_VkSemaphoreSignalInfo(const VkSemaphoreSignalInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSemaphoreSignalInfo(const safe_VkSemaphoreSignalInfo& copy_src);
+    safe_VkSemaphoreSignalInfo& operator=(const safe_VkSemaphoreSignalInfo& copy_src);
+    safe_VkSemaphoreSignalInfo();
+    ~safe_VkSemaphoreSignalInfo();
+    void initialize(const VkSemaphoreSignalInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSemaphoreSignalInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSemaphoreSignalInfo* ptr() { return reinterpret_cast<VkSemaphoreSignalInfo*>(this); }
+    VkSemaphoreSignalInfo const* ptr() const { return reinterpret_cast<VkSemaphoreSignalInfo const*>(this); }
+};
+struct safe_VkPhysicalDeviceBufferDeviceAddressFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 bufferDeviceAddress;
+    VkBool32 bufferDeviceAddressCaptureReplay;
+    VkBool32 bufferDeviceAddressMultiDevice;
+
+    safe_VkPhysicalDeviceBufferDeviceAddressFeatures(const VkPhysicalDeviceBufferDeviceAddressFeatures* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceBufferDeviceAddressFeatures(const safe_VkPhysicalDeviceBufferDeviceAddressFeatures& copy_src);
+    safe_VkPhysicalDeviceBufferDeviceAddressFeatures& operator=(const safe_VkPhysicalDeviceBufferDeviceAddressFeatures& copy_src);
+    safe_VkPhysicalDeviceBufferDeviceAddressFeatures();
+    ~safe_VkPhysicalDeviceBufferDeviceAddressFeatures();
+    void initialize(const VkPhysicalDeviceBufferDeviceAddressFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceBufferDeviceAddressFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceBufferDeviceAddressFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeatures*>(this);
+    }
+    VkPhysicalDeviceBufferDeviceAddressFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeatures const*>(this);
+    }
+};
+struct safe_VkBufferDeviceAddressInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBuffer buffer;
+
+    safe_VkBufferDeviceAddressInfo(const VkBufferDeviceAddressInfo* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    safe_VkBufferDeviceAddressInfo(const safe_VkBufferDeviceAddressInfo& copy_src);
+    safe_VkBufferDeviceAddressInfo& operator=(const safe_VkBufferDeviceAddressInfo& copy_src);
+    safe_VkBufferDeviceAddressInfo();
+    ~safe_VkBufferDeviceAddressInfo();
+    void initialize(const VkBufferDeviceAddressInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBufferDeviceAddressInfo* copy_src, PNextCopyState* copy_state = {});
+    VkBufferDeviceAddressInfo* ptr() { return reinterpret_cast<VkBufferDeviceAddressInfo*>(this); }
+    VkBufferDeviceAddressInfo const* ptr() const { return reinterpret_cast<VkBufferDeviceAddressInfo const*>(this); }
+};
+struct safe_VkBufferOpaqueCaptureAddressCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint64_t opaqueCaptureAddress;
+
+    safe_VkBufferOpaqueCaptureAddressCreateInfo(const VkBufferOpaqueCaptureAddressCreateInfo* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkBufferOpaqueCaptureAddressCreateInfo(const safe_VkBufferOpaqueCaptureAddressCreateInfo& copy_src);
+    safe_VkBufferOpaqueCaptureAddressCreateInfo& operator=(const safe_VkBufferOpaqueCaptureAddressCreateInfo& copy_src);
+    safe_VkBufferOpaqueCaptureAddressCreateInfo();
+    ~safe_VkBufferOpaqueCaptureAddressCreateInfo();
+    void initialize(const VkBufferOpaqueCaptureAddressCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBufferOpaqueCaptureAddressCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkBufferOpaqueCaptureAddressCreateInfo* ptr() { return reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo*>(this); }
+    VkBufferOpaqueCaptureAddressCreateInfo const* ptr() const {
+        return reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo const*>(this);
+    }
+};
+struct safe_VkMemoryOpaqueCaptureAddressAllocateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint64_t opaqueCaptureAddress;
+
+    safe_VkMemoryOpaqueCaptureAddressAllocateInfo(const VkMemoryOpaqueCaptureAddressAllocateInfo* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkMemoryOpaqueCaptureAddressAllocateInfo(const safe_VkMemoryOpaqueCaptureAddressAllocateInfo& copy_src);
+    safe_VkMemoryOpaqueCaptureAddressAllocateInfo& operator=(const safe_VkMemoryOpaqueCaptureAddressAllocateInfo& copy_src);
+    safe_VkMemoryOpaqueCaptureAddressAllocateInfo();
+    ~safe_VkMemoryOpaqueCaptureAddressAllocateInfo();
+    void initialize(const VkMemoryOpaqueCaptureAddressAllocateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMemoryOpaqueCaptureAddressAllocateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryOpaqueCaptureAddressAllocateInfo* ptr() { return reinterpret_cast<VkMemoryOpaqueCaptureAddressAllocateInfo*>(this); }
+    VkMemoryOpaqueCaptureAddressAllocateInfo const* ptr() const {
+        return reinterpret_cast<VkMemoryOpaqueCaptureAddressAllocateInfo const*>(this);
+    }
+};
+struct safe_VkDeviceMemoryOpaqueCaptureAddressInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceMemory memory;
+
+    safe_VkDeviceMemoryOpaqueCaptureAddressInfo(const VkDeviceMemoryOpaqueCaptureAddressInfo* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDeviceMemoryOpaqueCaptureAddressInfo(const safe_VkDeviceMemoryOpaqueCaptureAddressInfo& copy_src);
+    safe_VkDeviceMemoryOpaqueCaptureAddressInfo& operator=(const safe_VkDeviceMemoryOpaqueCaptureAddressInfo& copy_src);
+    safe_VkDeviceMemoryOpaqueCaptureAddressInfo();
+    ~safe_VkDeviceMemoryOpaqueCaptureAddressInfo();
+    void initialize(const VkDeviceMemoryOpaqueCaptureAddressInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDeviceMemoryOpaqueCaptureAddressInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceMemoryOpaqueCaptureAddressInfo* ptr() { return reinterpret_cast<VkDeviceMemoryOpaqueCaptureAddressInfo*>(this); }
+    VkDeviceMemoryOpaqueCaptureAddressInfo const* ptr() const {
+        return reinterpret_cast<VkDeviceMemoryOpaqueCaptureAddressInfo const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceVulkan13Features {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 robustImageAccess;
+    VkBool32 inlineUniformBlock;
+    VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind;
+    VkBool32 pipelineCreationCacheControl;
+    VkBool32 privateData;
+    VkBool32 shaderDemoteToHelperInvocation;
+    VkBool32 shaderTerminateInvocation;
+    VkBool32 subgroupSizeControl;
+    VkBool32 computeFullSubgroups;
+    VkBool32 synchronization2;
+    VkBool32 textureCompressionASTC_HDR;
+    VkBool32 shaderZeroInitializeWorkgroupMemory;
+    VkBool32 dynamicRendering;
+    VkBool32 shaderIntegerDotProduct;
+    VkBool32 maintenance4;
+
+    safe_VkPhysicalDeviceVulkan13Features(const VkPhysicalDeviceVulkan13Features* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkPhysicalDeviceVulkan13Features(const safe_VkPhysicalDeviceVulkan13Features& copy_src);
+    safe_VkPhysicalDeviceVulkan13Features& operator=(const safe_VkPhysicalDeviceVulkan13Features& copy_src);
+    safe_VkPhysicalDeviceVulkan13Features();
+    ~safe_VkPhysicalDeviceVulkan13Features();
+    void initialize(const VkPhysicalDeviceVulkan13Features* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceVulkan13Features* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVulkan13Features* ptr() { return reinterpret_cast<VkPhysicalDeviceVulkan13Features*>(this); }
+    VkPhysicalDeviceVulkan13Features const* ptr() const { return reinterpret_cast<VkPhysicalDeviceVulkan13Features const*>(this); }
+};
+struct safe_VkPhysicalDeviceVulkan13Properties {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t minSubgroupSize;
+    uint32_t maxSubgroupSize;
+    uint32_t maxComputeWorkgroupSubgroups;
+    VkShaderStageFlags requiredSubgroupSizeStages;
+    uint32_t maxInlineUniformBlockSize;
+    uint32_t maxPerStageDescriptorInlineUniformBlocks;
+    uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
+    uint32_t maxDescriptorSetInlineUniformBlocks;
+    uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
+    uint32_t maxInlineUniformTotalSize;
+    VkBool32 integerDotProduct8BitUnsignedAccelerated;
+    VkBool32 integerDotProduct8BitSignedAccelerated;
+    VkBool32 integerDotProduct8BitMixedSignednessAccelerated;
+    VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated;
+    VkBool32 integerDotProduct4x8BitPackedSignedAccelerated;
+    VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated;
+    VkBool32 integerDotProduct16BitUnsignedAccelerated;
+    VkBool32 integerDotProduct16BitSignedAccelerated;
+    VkBool32 integerDotProduct16BitMixedSignednessAccelerated;
+    VkBool32 integerDotProduct32BitUnsignedAccelerated;
+    VkBool32 integerDotProduct32BitSignedAccelerated;
+    VkBool32 integerDotProduct32BitMixedSignednessAccelerated;
+    VkBool32 integerDotProduct64BitUnsignedAccelerated;
+    VkBool32 integerDotProduct64BitSignedAccelerated;
+    VkBool32 integerDotProduct64BitMixedSignednessAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
+    VkDeviceSize storageTexelBufferOffsetAlignmentBytes;
+    VkBool32 storageTexelBufferOffsetSingleTexelAlignment;
+    VkDeviceSize uniformTexelBufferOffsetAlignmentBytes;
+    VkBool32 uniformTexelBufferOffsetSingleTexelAlignment;
+    VkDeviceSize maxBufferSize;
+
+    safe_VkPhysicalDeviceVulkan13Properties(const VkPhysicalDeviceVulkan13Properties* in_struct, PNextCopyState* copy_state = {},
+                                            bool copy_pnext = true);
+    safe_VkPhysicalDeviceVulkan13Properties(const safe_VkPhysicalDeviceVulkan13Properties& copy_src);
+    safe_VkPhysicalDeviceVulkan13Properties& operator=(const safe_VkPhysicalDeviceVulkan13Properties& copy_src);
+    safe_VkPhysicalDeviceVulkan13Properties();
+    ~safe_VkPhysicalDeviceVulkan13Properties();
+    void initialize(const VkPhysicalDeviceVulkan13Properties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceVulkan13Properties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVulkan13Properties* ptr() { return reinterpret_cast<VkPhysicalDeviceVulkan13Properties*>(this); }
+    VkPhysicalDeviceVulkan13Properties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceVulkan13Properties const*>(this);
+    }
+};
+struct safe_VkPipelineCreationFeedbackCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineCreationFeedback* pPipelineCreationFeedback{};
+    uint32_t pipelineStageCreationFeedbackCount;
+    VkPipelineCreationFeedback* pPipelineStageCreationFeedbacks{};
+
+    safe_VkPipelineCreationFeedbackCreateInfo(const VkPipelineCreationFeedbackCreateInfo* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineCreationFeedbackCreateInfo(const safe_VkPipelineCreationFeedbackCreateInfo& copy_src);
+    safe_VkPipelineCreationFeedbackCreateInfo& operator=(const safe_VkPipelineCreationFeedbackCreateInfo& copy_src);
+    safe_VkPipelineCreationFeedbackCreateInfo();
+    ~safe_VkPipelineCreationFeedbackCreateInfo();
+    void initialize(const VkPipelineCreationFeedbackCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineCreationFeedbackCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineCreationFeedbackCreateInfo* ptr() { return reinterpret_cast<VkPipelineCreationFeedbackCreateInfo*>(this); }
+    VkPipelineCreationFeedbackCreateInfo const* ptr() const {
+        return reinterpret_cast<VkPipelineCreationFeedbackCreateInfo const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceShaderTerminateInvocationFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderTerminateInvocation;
+
+    safe_VkPhysicalDeviceShaderTerminateInvocationFeatures(const VkPhysicalDeviceShaderTerminateInvocationFeatures* in_struct,
+                                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderTerminateInvocationFeatures(const safe_VkPhysicalDeviceShaderTerminateInvocationFeatures& copy_src);
+    safe_VkPhysicalDeviceShaderTerminateInvocationFeatures& operator=(
+        const safe_VkPhysicalDeviceShaderTerminateInvocationFeatures& copy_src);
+    safe_VkPhysicalDeviceShaderTerminateInvocationFeatures();
+    ~safe_VkPhysicalDeviceShaderTerminateInvocationFeatures();
+    void initialize(const VkPhysicalDeviceShaderTerminateInvocationFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderTerminateInvocationFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderTerminateInvocationFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeatures*>(this);
+    }
+    VkPhysicalDeviceShaderTerminateInvocationFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeatures const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceToolProperties {
+    VkStructureType sType;
+    void* pNext{};
+    char name[VK_MAX_EXTENSION_NAME_SIZE];
+    char version[VK_MAX_EXTENSION_NAME_SIZE];
+    VkToolPurposeFlags purposes;
+    char description[VK_MAX_DESCRIPTION_SIZE];
+    char layer[VK_MAX_EXTENSION_NAME_SIZE];
+
+    safe_VkPhysicalDeviceToolProperties(const VkPhysicalDeviceToolProperties* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkPhysicalDeviceToolProperties(const safe_VkPhysicalDeviceToolProperties& copy_src);
+    safe_VkPhysicalDeviceToolProperties& operator=(const safe_VkPhysicalDeviceToolProperties& copy_src);
+    safe_VkPhysicalDeviceToolProperties();
+    ~safe_VkPhysicalDeviceToolProperties();
+    void initialize(const VkPhysicalDeviceToolProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceToolProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceToolProperties* ptr() { return reinterpret_cast<VkPhysicalDeviceToolProperties*>(this); }
+    VkPhysicalDeviceToolProperties const* ptr() const { return reinterpret_cast<VkPhysicalDeviceToolProperties const*>(this); }
+};
+struct safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderDemoteToHelperInvocation;
+
+    safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+        const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+        const safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures& copy_src);
+    safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures& operator=(
+        const safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures& copy_src);
+    safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures();
+    ~safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures();
+    void initialize(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*>(this);
+    }
+    VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures const*>(this);
+    }
+};
+struct safe_VkPhysicalDevicePrivateDataFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 privateData;
+
+    safe_VkPhysicalDevicePrivateDataFeatures(const VkPhysicalDevicePrivateDataFeatures* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkPhysicalDevicePrivateDataFeatures(const safe_VkPhysicalDevicePrivateDataFeatures& copy_src);
+    safe_VkPhysicalDevicePrivateDataFeatures& operator=(const safe_VkPhysicalDevicePrivateDataFeatures& copy_src);
+    safe_VkPhysicalDevicePrivateDataFeatures();
+    ~safe_VkPhysicalDevicePrivateDataFeatures();
+    void initialize(const VkPhysicalDevicePrivateDataFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePrivateDataFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePrivateDataFeatures* ptr() { return reinterpret_cast<VkPhysicalDevicePrivateDataFeatures*>(this); }
+    VkPhysicalDevicePrivateDataFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePrivateDataFeatures const*>(this);
+    }
+};
+struct safe_VkDevicePrivateDataCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t privateDataSlotRequestCount;
+
+    safe_VkDevicePrivateDataCreateInfo(const VkDevicePrivateDataCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    safe_VkDevicePrivateDataCreateInfo(const safe_VkDevicePrivateDataCreateInfo& copy_src);
+    safe_VkDevicePrivateDataCreateInfo& operator=(const safe_VkDevicePrivateDataCreateInfo& copy_src);
+    safe_VkDevicePrivateDataCreateInfo();
+    ~safe_VkDevicePrivateDataCreateInfo();
+    void initialize(const VkDevicePrivateDataCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDevicePrivateDataCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDevicePrivateDataCreateInfo* ptr() { return reinterpret_cast<VkDevicePrivateDataCreateInfo*>(this); }
+    VkDevicePrivateDataCreateInfo const* ptr() const { return reinterpret_cast<VkDevicePrivateDataCreateInfo const*>(this); }
+};
+struct safe_VkPrivateDataSlotCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPrivateDataSlotCreateFlags flags;
+
+    safe_VkPrivateDataSlotCreateInfo(const VkPrivateDataSlotCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    safe_VkPrivateDataSlotCreateInfo(const safe_VkPrivateDataSlotCreateInfo& copy_src);
+    safe_VkPrivateDataSlotCreateInfo& operator=(const safe_VkPrivateDataSlotCreateInfo& copy_src);
+    safe_VkPrivateDataSlotCreateInfo();
+    ~safe_VkPrivateDataSlotCreateInfo();
+    void initialize(const VkPrivateDataSlotCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPrivateDataSlotCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPrivateDataSlotCreateInfo* ptr() { return reinterpret_cast<VkPrivateDataSlotCreateInfo*>(this); }
+    VkPrivateDataSlotCreateInfo const* ptr() const { return reinterpret_cast<VkPrivateDataSlotCreateInfo const*>(this); }
+};
+struct safe_VkPhysicalDevicePipelineCreationCacheControlFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 pipelineCreationCacheControl;
+
+    safe_VkPhysicalDevicePipelineCreationCacheControlFeatures(const VkPhysicalDevicePipelineCreationCacheControlFeatures* in_struct,
+                                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDevicePipelineCreationCacheControlFeatures(
+        const safe_VkPhysicalDevicePipelineCreationCacheControlFeatures& copy_src);
+    safe_VkPhysicalDevicePipelineCreationCacheControlFeatures& operator=(
+        const safe_VkPhysicalDevicePipelineCreationCacheControlFeatures& copy_src);
+    safe_VkPhysicalDevicePipelineCreationCacheControlFeatures();
+    ~safe_VkPhysicalDevicePipelineCreationCacheControlFeatures();
+    void initialize(const VkPhysicalDevicePipelineCreationCacheControlFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePipelineCreationCacheControlFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePipelineCreationCacheControlFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeatures*>(this);
+    }
+    VkPhysicalDevicePipelineCreationCacheControlFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeatures const*>(this);
+    }
+};
+struct safe_VkMemoryBarrier2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineStageFlags2 srcStageMask;
+    VkAccessFlags2 srcAccessMask;
+    VkPipelineStageFlags2 dstStageMask;
+    VkAccessFlags2 dstAccessMask;
+
+    safe_VkMemoryBarrier2(const VkMemoryBarrier2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkMemoryBarrier2(const safe_VkMemoryBarrier2& copy_src);
+    safe_VkMemoryBarrier2& operator=(const safe_VkMemoryBarrier2& copy_src);
+    safe_VkMemoryBarrier2();
+    ~safe_VkMemoryBarrier2();
+    void initialize(const VkMemoryBarrier2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMemoryBarrier2* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryBarrier2* ptr() { return reinterpret_cast<VkMemoryBarrier2*>(this); }
+    VkMemoryBarrier2 const* ptr() const { return reinterpret_cast<VkMemoryBarrier2 const*>(this); }
+};
+struct safe_VkBufferMemoryBarrier2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineStageFlags2 srcStageMask;
+    VkAccessFlags2 srcAccessMask;
+    VkPipelineStageFlags2 dstStageMask;
+    VkAccessFlags2 dstAccessMask;
+    uint32_t srcQueueFamilyIndex;
+    uint32_t dstQueueFamilyIndex;
+    VkBuffer buffer;
+    VkDeviceSize offset;
+    VkDeviceSize size;
+
+    safe_VkBufferMemoryBarrier2(const VkBufferMemoryBarrier2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkBufferMemoryBarrier2(const safe_VkBufferMemoryBarrier2& copy_src);
+    safe_VkBufferMemoryBarrier2& operator=(const safe_VkBufferMemoryBarrier2& copy_src);
+    safe_VkBufferMemoryBarrier2();
+    ~safe_VkBufferMemoryBarrier2();
+    void initialize(const VkBufferMemoryBarrier2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBufferMemoryBarrier2* copy_src, PNextCopyState* copy_state = {});
+    VkBufferMemoryBarrier2* ptr() { return reinterpret_cast<VkBufferMemoryBarrier2*>(this); }
+    VkBufferMemoryBarrier2 const* ptr() const { return reinterpret_cast<VkBufferMemoryBarrier2 const*>(this); }
+};
+struct safe_VkImageMemoryBarrier2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineStageFlags2 srcStageMask;
+    VkAccessFlags2 srcAccessMask;
+    VkPipelineStageFlags2 dstStageMask;
+    VkAccessFlags2 dstAccessMask;
+    VkImageLayout oldLayout;
+    VkImageLayout newLayout;
+    uint32_t srcQueueFamilyIndex;
+    uint32_t dstQueueFamilyIndex;
+    VkImage image;
+    VkImageSubresourceRange subresourceRange;
+
+    safe_VkImageMemoryBarrier2(const VkImageMemoryBarrier2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkImageMemoryBarrier2(const safe_VkImageMemoryBarrier2& copy_src);
+    safe_VkImageMemoryBarrier2& operator=(const safe_VkImageMemoryBarrier2& copy_src);
+    safe_VkImageMemoryBarrier2();
+    ~safe_VkImageMemoryBarrier2();
+    void initialize(const VkImageMemoryBarrier2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageMemoryBarrier2* copy_src, PNextCopyState* copy_state = {});
+    VkImageMemoryBarrier2* ptr() { return reinterpret_cast<VkImageMemoryBarrier2*>(this); }
+    VkImageMemoryBarrier2 const* ptr() const { return reinterpret_cast<VkImageMemoryBarrier2 const*>(this); }
+};
+struct safe_VkDependencyInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDependencyFlags dependencyFlags;
+    uint32_t memoryBarrierCount;
+    safe_VkMemoryBarrier2* pMemoryBarriers{};
+    uint32_t bufferMemoryBarrierCount;
+    safe_VkBufferMemoryBarrier2* pBufferMemoryBarriers{};
+    uint32_t imageMemoryBarrierCount;
+    safe_VkImageMemoryBarrier2* pImageMemoryBarriers{};
+
+    safe_VkDependencyInfo(const VkDependencyInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDependencyInfo(const safe_VkDependencyInfo& copy_src);
+    safe_VkDependencyInfo& operator=(const safe_VkDependencyInfo& copy_src);
+    safe_VkDependencyInfo();
+    ~safe_VkDependencyInfo();
+    void initialize(const VkDependencyInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDependencyInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDependencyInfo* ptr() { return reinterpret_cast<VkDependencyInfo*>(this); }
+    VkDependencyInfo const* ptr() const { return reinterpret_cast<VkDependencyInfo const*>(this); }
+};
+struct safe_VkSemaphoreSubmitInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSemaphore semaphore;
+    uint64_t value;
+    VkPipelineStageFlags2 stageMask;
+    uint32_t deviceIndex;
+
+    safe_VkSemaphoreSubmitInfo(const VkSemaphoreSubmitInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSemaphoreSubmitInfo(const safe_VkSemaphoreSubmitInfo& copy_src);
+    safe_VkSemaphoreSubmitInfo& operator=(const safe_VkSemaphoreSubmitInfo& copy_src);
+    safe_VkSemaphoreSubmitInfo();
+    ~safe_VkSemaphoreSubmitInfo();
+    void initialize(const VkSemaphoreSubmitInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSemaphoreSubmitInfo* copy_src, PNextCopyState* copy_state = {});
+    VkSemaphoreSubmitInfo* ptr() { return reinterpret_cast<VkSemaphoreSubmitInfo*>(this); }
+    VkSemaphoreSubmitInfo const* ptr() const { return reinterpret_cast<VkSemaphoreSubmitInfo const*>(this); }
+};
+struct safe_VkCommandBufferSubmitInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkCommandBuffer commandBuffer;
+    uint32_t deviceMask;
+
+    safe_VkCommandBufferSubmitInfo(const VkCommandBufferSubmitInfo* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    safe_VkCommandBufferSubmitInfo(const safe_VkCommandBufferSubmitInfo& copy_src);
+    safe_VkCommandBufferSubmitInfo& operator=(const safe_VkCommandBufferSubmitInfo& copy_src);
+    safe_VkCommandBufferSubmitInfo();
+    ~safe_VkCommandBufferSubmitInfo();
+    void initialize(const VkCommandBufferSubmitInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCommandBufferSubmitInfo* copy_src, PNextCopyState* copy_state = {});
+    VkCommandBufferSubmitInfo* ptr() { return reinterpret_cast<VkCommandBufferSubmitInfo*>(this); }
+    VkCommandBufferSubmitInfo const* ptr() const { return reinterpret_cast<VkCommandBufferSubmitInfo const*>(this); }
+};
+struct safe_VkSubmitInfo2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSubmitFlags flags;
+    uint32_t waitSemaphoreInfoCount;
+    safe_VkSemaphoreSubmitInfo* pWaitSemaphoreInfos{};
+    uint32_t commandBufferInfoCount;
+    safe_VkCommandBufferSubmitInfo* pCommandBufferInfos{};
+    uint32_t signalSemaphoreInfoCount;
+    safe_VkSemaphoreSubmitInfo* pSignalSemaphoreInfos{};
+
+    safe_VkSubmitInfo2(const VkSubmitInfo2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSubmitInfo2(const safe_VkSubmitInfo2& copy_src);
+    safe_VkSubmitInfo2& operator=(const safe_VkSubmitInfo2& copy_src);
+    safe_VkSubmitInfo2();
+    ~safe_VkSubmitInfo2();
+    void initialize(const VkSubmitInfo2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSubmitInfo2* copy_src, PNextCopyState* copy_state = {});
+    VkSubmitInfo2* ptr() { return reinterpret_cast<VkSubmitInfo2*>(this); }
+    VkSubmitInfo2 const* ptr() const { return reinterpret_cast<VkSubmitInfo2 const*>(this); }
+};
+struct safe_VkPhysicalDeviceSynchronization2Features {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 synchronization2;
+
+    safe_VkPhysicalDeviceSynchronization2Features(const VkPhysicalDeviceSynchronization2Features* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceSynchronization2Features(const safe_VkPhysicalDeviceSynchronization2Features& copy_src);
+    safe_VkPhysicalDeviceSynchronization2Features& operator=(const safe_VkPhysicalDeviceSynchronization2Features& copy_src);
+    safe_VkPhysicalDeviceSynchronization2Features();
+    ~safe_VkPhysicalDeviceSynchronization2Features();
+    void initialize(const VkPhysicalDeviceSynchronization2Features* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceSynchronization2Features* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSynchronization2Features* ptr() { return reinterpret_cast<VkPhysicalDeviceSynchronization2Features*>(this); }
+    VkPhysicalDeviceSynchronization2Features const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceSynchronization2Features const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderZeroInitializeWorkgroupMemory;
+
+    safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+        const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+        const safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures& copy_src);
+    safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures& operator=(
+        const safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures& copy_src);
+    safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures();
+    ~safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures();
+    void initialize(const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*>(this);
+    }
+    VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceImageRobustnessFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 robustImageAccess;
+
+    safe_VkPhysicalDeviceImageRobustnessFeatures(const VkPhysicalDeviceImageRobustnessFeatures* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceImageRobustnessFeatures(const safe_VkPhysicalDeviceImageRobustnessFeatures& copy_src);
+    safe_VkPhysicalDeviceImageRobustnessFeatures& operator=(const safe_VkPhysicalDeviceImageRobustnessFeatures& copy_src);
+    safe_VkPhysicalDeviceImageRobustnessFeatures();
+    ~safe_VkPhysicalDeviceImageRobustnessFeatures();
+    void initialize(const VkPhysicalDeviceImageRobustnessFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceImageRobustnessFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceImageRobustnessFeatures* ptr() { return reinterpret_cast<VkPhysicalDeviceImageRobustnessFeatures*>(this); }
+    VkPhysicalDeviceImageRobustnessFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceImageRobustnessFeatures const*>(this);
+    }
+};
+struct safe_VkBufferCopy2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceSize srcOffset;
+    VkDeviceSize dstOffset;
+    VkDeviceSize size;
+
+    safe_VkBufferCopy2(const VkBufferCopy2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkBufferCopy2(const safe_VkBufferCopy2& copy_src);
+    safe_VkBufferCopy2& operator=(const safe_VkBufferCopy2& copy_src);
+    safe_VkBufferCopy2();
+    ~safe_VkBufferCopy2();
+    void initialize(const VkBufferCopy2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBufferCopy2* copy_src, PNextCopyState* copy_state = {});
+    VkBufferCopy2* ptr() { return reinterpret_cast<VkBufferCopy2*>(this); }
+    VkBufferCopy2 const* ptr() const { return reinterpret_cast<VkBufferCopy2 const*>(this); }
+};
+struct safe_VkCopyBufferInfo2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBuffer srcBuffer;
+    VkBuffer dstBuffer;
+    uint32_t regionCount;
+    safe_VkBufferCopy2* pRegions{};
+
+    safe_VkCopyBufferInfo2(const VkCopyBufferInfo2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkCopyBufferInfo2(const safe_VkCopyBufferInfo2& copy_src);
+    safe_VkCopyBufferInfo2& operator=(const safe_VkCopyBufferInfo2& copy_src);
+    safe_VkCopyBufferInfo2();
+    ~safe_VkCopyBufferInfo2();
+    void initialize(const VkCopyBufferInfo2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCopyBufferInfo2* copy_src, PNextCopyState* copy_state = {});
+    VkCopyBufferInfo2* ptr() { return reinterpret_cast<VkCopyBufferInfo2*>(this); }
+    VkCopyBufferInfo2 const* ptr() const { return reinterpret_cast<VkCopyBufferInfo2 const*>(this); }
+};
+struct safe_VkImageCopy2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageSubresourceLayers srcSubresource;
+    VkOffset3D srcOffset;
+    VkImageSubresourceLayers dstSubresource;
+    VkOffset3D dstOffset;
+    VkExtent3D extent;
+
+    safe_VkImageCopy2(const VkImageCopy2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkImageCopy2(const safe_VkImageCopy2& copy_src);
+    safe_VkImageCopy2& operator=(const safe_VkImageCopy2& copy_src);
+    safe_VkImageCopy2();
+    ~safe_VkImageCopy2();
+    void initialize(const VkImageCopy2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageCopy2* copy_src, PNextCopyState* copy_state = {});
+    VkImageCopy2* ptr() { return reinterpret_cast<VkImageCopy2*>(this); }
+    VkImageCopy2 const* ptr() const { return reinterpret_cast<VkImageCopy2 const*>(this); }
+};
+struct safe_VkCopyImageInfo2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImage srcImage;
+    VkImageLayout srcImageLayout;
+    VkImage dstImage;
+    VkImageLayout dstImageLayout;
+    uint32_t regionCount;
+    safe_VkImageCopy2* pRegions{};
+
+    safe_VkCopyImageInfo2(const VkCopyImageInfo2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkCopyImageInfo2(const safe_VkCopyImageInfo2& copy_src);
+    safe_VkCopyImageInfo2& operator=(const safe_VkCopyImageInfo2& copy_src);
+    safe_VkCopyImageInfo2();
+    ~safe_VkCopyImageInfo2();
+    void initialize(const VkCopyImageInfo2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCopyImageInfo2* copy_src, PNextCopyState* copy_state = {});
+    VkCopyImageInfo2* ptr() { return reinterpret_cast<VkCopyImageInfo2*>(this); }
+    VkCopyImageInfo2 const* ptr() const { return reinterpret_cast<VkCopyImageInfo2 const*>(this); }
+};
+struct safe_VkBufferImageCopy2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceSize bufferOffset;
+    uint32_t bufferRowLength;
+    uint32_t bufferImageHeight;
+    VkImageSubresourceLayers imageSubresource;
+    VkOffset3D imageOffset;
+    VkExtent3D imageExtent;
+
+    safe_VkBufferImageCopy2(const VkBufferImageCopy2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkBufferImageCopy2(const safe_VkBufferImageCopy2& copy_src);
+    safe_VkBufferImageCopy2& operator=(const safe_VkBufferImageCopy2& copy_src);
+    safe_VkBufferImageCopy2();
+    ~safe_VkBufferImageCopy2();
+    void initialize(const VkBufferImageCopy2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBufferImageCopy2* copy_src, PNextCopyState* copy_state = {});
+    VkBufferImageCopy2* ptr() { return reinterpret_cast<VkBufferImageCopy2*>(this); }
+    VkBufferImageCopy2 const* ptr() const { return reinterpret_cast<VkBufferImageCopy2 const*>(this); }
+};
+struct safe_VkCopyBufferToImageInfo2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBuffer srcBuffer;
+    VkImage dstImage;
+    VkImageLayout dstImageLayout;
+    uint32_t regionCount;
+    safe_VkBufferImageCopy2* pRegions{};
+
+    safe_VkCopyBufferToImageInfo2(const VkCopyBufferToImageInfo2* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    safe_VkCopyBufferToImageInfo2(const safe_VkCopyBufferToImageInfo2& copy_src);
+    safe_VkCopyBufferToImageInfo2& operator=(const safe_VkCopyBufferToImageInfo2& copy_src);
+    safe_VkCopyBufferToImageInfo2();
+    ~safe_VkCopyBufferToImageInfo2();
+    void initialize(const VkCopyBufferToImageInfo2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCopyBufferToImageInfo2* copy_src, PNextCopyState* copy_state = {});
+    VkCopyBufferToImageInfo2* ptr() { return reinterpret_cast<VkCopyBufferToImageInfo2*>(this); }
+    VkCopyBufferToImageInfo2 const* ptr() const { return reinterpret_cast<VkCopyBufferToImageInfo2 const*>(this); }
+};
+struct safe_VkCopyImageToBufferInfo2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImage srcImage;
+    VkImageLayout srcImageLayout;
+    VkBuffer dstBuffer;
+    uint32_t regionCount;
+    safe_VkBufferImageCopy2* pRegions{};
+
+    safe_VkCopyImageToBufferInfo2(const VkCopyImageToBufferInfo2* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    safe_VkCopyImageToBufferInfo2(const safe_VkCopyImageToBufferInfo2& copy_src);
+    safe_VkCopyImageToBufferInfo2& operator=(const safe_VkCopyImageToBufferInfo2& copy_src);
+    safe_VkCopyImageToBufferInfo2();
+    ~safe_VkCopyImageToBufferInfo2();
+    void initialize(const VkCopyImageToBufferInfo2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCopyImageToBufferInfo2* copy_src, PNextCopyState* copy_state = {});
+    VkCopyImageToBufferInfo2* ptr() { return reinterpret_cast<VkCopyImageToBufferInfo2*>(this); }
+    VkCopyImageToBufferInfo2 const* ptr() const { return reinterpret_cast<VkCopyImageToBufferInfo2 const*>(this); }
+};
+struct safe_VkImageBlit2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageSubresourceLayers srcSubresource;
+    VkOffset3D srcOffsets[2];
+    VkImageSubresourceLayers dstSubresource;
+    VkOffset3D dstOffsets[2];
+
+    safe_VkImageBlit2(const VkImageBlit2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkImageBlit2(const safe_VkImageBlit2& copy_src);
+    safe_VkImageBlit2& operator=(const safe_VkImageBlit2& copy_src);
+    safe_VkImageBlit2();
+    ~safe_VkImageBlit2();
+    void initialize(const VkImageBlit2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageBlit2* copy_src, PNextCopyState* copy_state = {});
+    VkImageBlit2* ptr() { return reinterpret_cast<VkImageBlit2*>(this); }
+    VkImageBlit2 const* ptr() const { return reinterpret_cast<VkImageBlit2 const*>(this); }
+};
+struct safe_VkBlitImageInfo2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImage srcImage;
+    VkImageLayout srcImageLayout;
+    VkImage dstImage;
+    VkImageLayout dstImageLayout;
+    uint32_t regionCount;
+    safe_VkImageBlit2* pRegions{};
+    VkFilter filter;
+
+    safe_VkBlitImageInfo2(const VkBlitImageInfo2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkBlitImageInfo2(const safe_VkBlitImageInfo2& copy_src);
+    safe_VkBlitImageInfo2& operator=(const safe_VkBlitImageInfo2& copy_src);
+    safe_VkBlitImageInfo2();
+    ~safe_VkBlitImageInfo2();
+    void initialize(const VkBlitImageInfo2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBlitImageInfo2* copy_src, PNextCopyState* copy_state = {});
+    VkBlitImageInfo2* ptr() { return reinterpret_cast<VkBlitImageInfo2*>(this); }
+    VkBlitImageInfo2 const* ptr() const { return reinterpret_cast<VkBlitImageInfo2 const*>(this); }
+};
+struct safe_VkImageResolve2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageSubresourceLayers srcSubresource;
+    VkOffset3D srcOffset;
+    VkImageSubresourceLayers dstSubresource;
+    VkOffset3D dstOffset;
+    VkExtent3D extent;
+
+    safe_VkImageResolve2(const VkImageResolve2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkImageResolve2(const safe_VkImageResolve2& copy_src);
+    safe_VkImageResolve2& operator=(const safe_VkImageResolve2& copy_src);
+    safe_VkImageResolve2();
+    ~safe_VkImageResolve2();
+    void initialize(const VkImageResolve2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageResolve2* copy_src, PNextCopyState* copy_state = {});
+    VkImageResolve2* ptr() { return reinterpret_cast<VkImageResolve2*>(this); }
+    VkImageResolve2 const* ptr() const { return reinterpret_cast<VkImageResolve2 const*>(this); }
+};
+struct safe_VkResolveImageInfo2 {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImage srcImage;
+    VkImageLayout srcImageLayout;
+    VkImage dstImage;
+    VkImageLayout dstImageLayout;
+    uint32_t regionCount;
+    safe_VkImageResolve2* pRegions{};
+
+    safe_VkResolveImageInfo2(const VkResolveImageInfo2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkResolveImageInfo2(const safe_VkResolveImageInfo2& copy_src);
+    safe_VkResolveImageInfo2& operator=(const safe_VkResolveImageInfo2& copy_src);
+    safe_VkResolveImageInfo2();
+    ~safe_VkResolveImageInfo2();
+    void initialize(const VkResolveImageInfo2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkResolveImageInfo2* copy_src, PNextCopyState* copy_state = {});
+    VkResolveImageInfo2* ptr() { return reinterpret_cast<VkResolveImageInfo2*>(this); }
+    VkResolveImageInfo2 const* ptr() const { return reinterpret_cast<VkResolveImageInfo2 const*>(this); }
+};
+struct safe_VkPhysicalDeviceSubgroupSizeControlFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 subgroupSizeControl;
+    VkBool32 computeFullSubgroups;
+
+    safe_VkPhysicalDeviceSubgroupSizeControlFeatures(const VkPhysicalDeviceSubgroupSizeControlFeatures* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceSubgroupSizeControlFeatures(const safe_VkPhysicalDeviceSubgroupSizeControlFeatures& copy_src);
+    safe_VkPhysicalDeviceSubgroupSizeControlFeatures& operator=(const safe_VkPhysicalDeviceSubgroupSizeControlFeatures& copy_src);
+    safe_VkPhysicalDeviceSubgroupSizeControlFeatures();
+    ~safe_VkPhysicalDeviceSubgroupSizeControlFeatures();
+    void initialize(const VkPhysicalDeviceSubgroupSizeControlFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceSubgroupSizeControlFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSubgroupSizeControlFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeatures*>(this);
+    }
+    VkPhysicalDeviceSubgroupSizeControlFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeatures const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceSubgroupSizeControlProperties {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t minSubgroupSize;
+    uint32_t maxSubgroupSize;
+    uint32_t maxComputeWorkgroupSubgroups;
+    VkShaderStageFlags requiredSubgroupSizeStages;
+
+    safe_VkPhysicalDeviceSubgroupSizeControlProperties(const VkPhysicalDeviceSubgroupSizeControlProperties* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceSubgroupSizeControlProperties(const safe_VkPhysicalDeviceSubgroupSizeControlProperties& copy_src);
+    safe_VkPhysicalDeviceSubgroupSizeControlProperties& operator=(
+        const safe_VkPhysicalDeviceSubgroupSizeControlProperties& copy_src);
+    safe_VkPhysicalDeviceSubgroupSizeControlProperties();
+    ~safe_VkPhysicalDeviceSubgroupSizeControlProperties();
+    void initialize(const VkPhysicalDeviceSubgroupSizeControlProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceSubgroupSizeControlProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSubgroupSizeControlProperties* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlProperties*>(this);
+    }
+    VkPhysicalDeviceSubgroupSizeControlProperties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlProperties const*>(this);
+    }
+};
+struct safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t requiredSubgroupSize;
+
+    safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* in_struct,
+                                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
+        const safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo& copy_src);
+    safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo& operator=(
+        const safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo& copy_src);
+    safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo();
+    ~safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo();
+    void initialize(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* ptr() {
+        return reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfo*>(this);
+    }
+    VkPipelineShaderStageRequiredSubgroupSizeCreateInfo const* ptr() const {
+        return reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfo const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceInlineUniformBlockFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 inlineUniformBlock;
+    VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind;
+
+    safe_VkPhysicalDeviceInlineUniformBlockFeatures(const VkPhysicalDeviceInlineUniformBlockFeatures* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceInlineUniformBlockFeatures(const safe_VkPhysicalDeviceInlineUniformBlockFeatures& copy_src);
+    safe_VkPhysicalDeviceInlineUniformBlockFeatures& operator=(const safe_VkPhysicalDeviceInlineUniformBlockFeatures& copy_src);
+    safe_VkPhysicalDeviceInlineUniformBlockFeatures();
+    ~safe_VkPhysicalDeviceInlineUniformBlockFeatures();
+    void initialize(const VkPhysicalDeviceInlineUniformBlockFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceInlineUniformBlockFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceInlineUniformBlockFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeatures*>(this);
+    }
+    VkPhysicalDeviceInlineUniformBlockFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeatures const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceInlineUniformBlockProperties {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxInlineUniformBlockSize;
+    uint32_t maxPerStageDescriptorInlineUniformBlocks;
+    uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
+    uint32_t maxDescriptorSetInlineUniformBlocks;
+    uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
+
+    safe_VkPhysicalDeviceInlineUniformBlockProperties(const VkPhysicalDeviceInlineUniformBlockProperties* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceInlineUniformBlockProperties(const safe_VkPhysicalDeviceInlineUniformBlockProperties& copy_src);
+    safe_VkPhysicalDeviceInlineUniformBlockProperties& operator=(const safe_VkPhysicalDeviceInlineUniformBlockProperties& copy_src);
+    safe_VkPhysicalDeviceInlineUniformBlockProperties();
+    ~safe_VkPhysicalDeviceInlineUniformBlockProperties();
+    void initialize(const VkPhysicalDeviceInlineUniformBlockProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceInlineUniformBlockProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceInlineUniformBlockProperties* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceInlineUniformBlockProperties*>(this);
+    }
+    VkPhysicalDeviceInlineUniformBlockProperties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceInlineUniformBlockProperties const*>(this);
+    }
+};
+struct safe_VkWriteDescriptorSetInlineUniformBlock {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t dataSize;
+    const void* pData{};
+
+    safe_VkWriteDescriptorSetInlineUniformBlock(const VkWriteDescriptorSetInlineUniformBlock* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkWriteDescriptorSetInlineUniformBlock(const safe_VkWriteDescriptorSetInlineUniformBlock& copy_src);
+    safe_VkWriteDescriptorSetInlineUniformBlock& operator=(const safe_VkWriteDescriptorSetInlineUniformBlock& copy_src);
+    safe_VkWriteDescriptorSetInlineUniformBlock();
+    ~safe_VkWriteDescriptorSetInlineUniformBlock();
+    void initialize(const VkWriteDescriptorSetInlineUniformBlock* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkWriteDescriptorSetInlineUniformBlock* copy_src, PNextCopyState* copy_state = {});
+    VkWriteDescriptorSetInlineUniformBlock* ptr() { return reinterpret_cast<VkWriteDescriptorSetInlineUniformBlock*>(this); }
+    VkWriteDescriptorSetInlineUniformBlock const* ptr() const {
+        return reinterpret_cast<VkWriteDescriptorSetInlineUniformBlock const*>(this);
+    }
+};
+struct safe_VkDescriptorPoolInlineUniformBlockCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t maxInlineUniformBlockBindings;
+
+    safe_VkDescriptorPoolInlineUniformBlockCreateInfo(const VkDescriptorPoolInlineUniformBlockCreateInfo* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDescriptorPoolInlineUniformBlockCreateInfo(const safe_VkDescriptorPoolInlineUniformBlockCreateInfo& copy_src);
+    safe_VkDescriptorPoolInlineUniformBlockCreateInfo& operator=(const safe_VkDescriptorPoolInlineUniformBlockCreateInfo& copy_src);
+    safe_VkDescriptorPoolInlineUniformBlockCreateInfo();
+    ~safe_VkDescriptorPoolInlineUniformBlockCreateInfo();
+    void initialize(const VkDescriptorPoolInlineUniformBlockCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDescriptorPoolInlineUniformBlockCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorPoolInlineUniformBlockCreateInfo* ptr() {
+        return reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfo*>(this);
+    }
+    VkDescriptorPoolInlineUniformBlockCreateInfo const* ptr() const {
+        return reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfo const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 textureCompressionASTC_HDR;
+
+    safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(const VkPhysicalDeviceTextureCompressionASTCHDRFeatures* in_struct,
+                                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures& copy_src);
+    safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures& operator=(
+        const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures& copy_src);
+    safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures();
+    ~safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures();
+    void initialize(const VkPhysicalDeviceTextureCompressionASTCHDRFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceTextureCompressionASTCHDRFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeatures*>(this);
+    }
+    VkPhysicalDeviceTextureCompressionASTCHDRFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeatures const*>(this);
+    }
+};
+struct safe_VkRenderingAttachmentInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageView imageView;
+    VkImageLayout imageLayout;
+    VkResolveModeFlagBits resolveMode;
+    VkImageView resolveImageView;
+    VkImageLayout resolveImageLayout;
+    VkAttachmentLoadOp loadOp;
+    VkAttachmentStoreOp storeOp;
+    VkClearValue clearValue;
+
+    safe_VkRenderingAttachmentInfo(const VkRenderingAttachmentInfo* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    safe_VkRenderingAttachmentInfo(const safe_VkRenderingAttachmentInfo& copy_src);
+    safe_VkRenderingAttachmentInfo& operator=(const safe_VkRenderingAttachmentInfo& copy_src);
+    safe_VkRenderingAttachmentInfo();
+    ~safe_VkRenderingAttachmentInfo();
+    void initialize(const VkRenderingAttachmentInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderingAttachmentInfo* copy_src, PNextCopyState* copy_state = {});
+    VkRenderingAttachmentInfo* ptr() { return reinterpret_cast<VkRenderingAttachmentInfo*>(this); }
+    VkRenderingAttachmentInfo const* ptr() const { return reinterpret_cast<VkRenderingAttachmentInfo const*>(this); }
+};
+struct safe_VkRenderingInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkRenderingFlags flags;
+    VkRect2D renderArea;
+    uint32_t layerCount;
+    uint32_t viewMask;
+    uint32_t colorAttachmentCount;
+    safe_VkRenderingAttachmentInfo* pColorAttachments{};
+    safe_VkRenderingAttachmentInfo* pDepthAttachment{};
+    safe_VkRenderingAttachmentInfo* pStencilAttachment{};
+
+    safe_VkRenderingInfo(const VkRenderingInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkRenderingInfo(const safe_VkRenderingInfo& copy_src);
+    safe_VkRenderingInfo& operator=(const safe_VkRenderingInfo& copy_src);
+    safe_VkRenderingInfo();
+    ~safe_VkRenderingInfo();
+    void initialize(const VkRenderingInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderingInfo* copy_src, PNextCopyState* copy_state = {});
+    VkRenderingInfo* ptr() { return reinterpret_cast<VkRenderingInfo*>(this); }
+    VkRenderingInfo const* ptr() const { return reinterpret_cast<VkRenderingInfo const*>(this); }
+};
+struct safe_VkPipelineRenderingCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t viewMask;
+    uint32_t colorAttachmentCount;
+    const VkFormat* pColorAttachmentFormats{};
+    VkFormat depthAttachmentFormat;
+    VkFormat stencilAttachmentFormat;
+
+    safe_VkPipelineRenderingCreateInfo(const VkPipelineRenderingCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    safe_VkPipelineRenderingCreateInfo(const safe_VkPipelineRenderingCreateInfo& copy_src);
+    safe_VkPipelineRenderingCreateInfo& operator=(const safe_VkPipelineRenderingCreateInfo& copy_src);
+    safe_VkPipelineRenderingCreateInfo();
+    ~safe_VkPipelineRenderingCreateInfo();
+    void initialize(const VkPipelineRenderingCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineRenderingCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineRenderingCreateInfo* ptr() { return reinterpret_cast<VkPipelineRenderingCreateInfo*>(this); }
+    VkPipelineRenderingCreateInfo const* ptr() const { return reinterpret_cast<VkPipelineRenderingCreateInfo const*>(this); }
+};
+struct safe_VkPhysicalDeviceDynamicRenderingFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 dynamicRendering;
+
+    safe_VkPhysicalDeviceDynamicRenderingFeatures(const VkPhysicalDeviceDynamicRenderingFeatures* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceDynamicRenderingFeatures(const safe_VkPhysicalDeviceDynamicRenderingFeatures& copy_src);
+    safe_VkPhysicalDeviceDynamicRenderingFeatures& operator=(const safe_VkPhysicalDeviceDynamicRenderingFeatures& copy_src);
+    safe_VkPhysicalDeviceDynamicRenderingFeatures();
+    ~safe_VkPhysicalDeviceDynamicRenderingFeatures();
+    void initialize(const VkPhysicalDeviceDynamicRenderingFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDynamicRenderingFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDynamicRenderingFeatures* ptr() { return reinterpret_cast<VkPhysicalDeviceDynamicRenderingFeatures*>(this); }
+    VkPhysicalDeviceDynamicRenderingFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDynamicRenderingFeatures const*>(this);
+    }
+};
+struct safe_VkCommandBufferInheritanceRenderingInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkRenderingFlags flags;
+    uint32_t viewMask;
+    uint32_t colorAttachmentCount;
+    const VkFormat* pColorAttachmentFormats{};
+    VkFormat depthAttachmentFormat;
+    VkFormat stencilAttachmentFormat;
+    VkSampleCountFlagBits rasterizationSamples;
+
+    safe_VkCommandBufferInheritanceRenderingInfo(const VkCommandBufferInheritanceRenderingInfo* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkCommandBufferInheritanceRenderingInfo(const safe_VkCommandBufferInheritanceRenderingInfo& copy_src);
+    safe_VkCommandBufferInheritanceRenderingInfo& operator=(const safe_VkCommandBufferInheritanceRenderingInfo& copy_src);
+    safe_VkCommandBufferInheritanceRenderingInfo();
+    ~safe_VkCommandBufferInheritanceRenderingInfo();
+    void initialize(const VkCommandBufferInheritanceRenderingInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCommandBufferInheritanceRenderingInfo* copy_src, PNextCopyState* copy_state = {});
+    VkCommandBufferInheritanceRenderingInfo* ptr() { return reinterpret_cast<VkCommandBufferInheritanceRenderingInfo*>(this); }
+    VkCommandBufferInheritanceRenderingInfo const* ptr() const {
+        return reinterpret_cast<VkCommandBufferInheritanceRenderingInfo const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceShaderIntegerDotProductFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderIntegerDotProduct;
+
+    safe_VkPhysicalDeviceShaderIntegerDotProductFeatures(const VkPhysicalDeviceShaderIntegerDotProductFeatures* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderIntegerDotProductFeatures(const safe_VkPhysicalDeviceShaderIntegerDotProductFeatures& copy_src);
+    safe_VkPhysicalDeviceShaderIntegerDotProductFeatures& operator=(
+        const safe_VkPhysicalDeviceShaderIntegerDotProductFeatures& copy_src);
+    safe_VkPhysicalDeviceShaderIntegerDotProductFeatures();
+    ~safe_VkPhysicalDeviceShaderIntegerDotProductFeatures();
+    void initialize(const VkPhysicalDeviceShaderIntegerDotProductFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderIntegerDotProductFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderIntegerDotProductFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductFeatures*>(this);
+    }
+    VkPhysicalDeviceShaderIntegerDotProductFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductFeatures const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceShaderIntegerDotProductProperties {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 integerDotProduct8BitUnsignedAccelerated;
+    VkBool32 integerDotProduct8BitSignedAccelerated;
+    VkBool32 integerDotProduct8BitMixedSignednessAccelerated;
+    VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated;
+    VkBool32 integerDotProduct4x8BitPackedSignedAccelerated;
+    VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated;
+    VkBool32 integerDotProduct16BitUnsignedAccelerated;
+    VkBool32 integerDotProduct16BitSignedAccelerated;
+    VkBool32 integerDotProduct16BitMixedSignednessAccelerated;
+    VkBool32 integerDotProduct32BitUnsignedAccelerated;
+    VkBool32 integerDotProduct32BitSignedAccelerated;
+    VkBool32 integerDotProduct32BitMixedSignednessAccelerated;
+    VkBool32 integerDotProduct64BitUnsignedAccelerated;
+    VkBool32 integerDotProduct64BitSignedAccelerated;
+    VkBool32 integerDotProduct64BitMixedSignednessAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated;
+    VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
+
+    safe_VkPhysicalDeviceShaderIntegerDotProductProperties(const VkPhysicalDeviceShaderIntegerDotProductProperties* in_struct,
+                                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderIntegerDotProductProperties(const safe_VkPhysicalDeviceShaderIntegerDotProductProperties& copy_src);
+    safe_VkPhysicalDeviceShaderIntegerDotProductProperties& operator=(
+        const safe_VkPhysicalDeviceShaderIntegerDotProductProperties& copy_src);
+    safe_VkPhysicalDeviceShaderIntegerDotProductProperties();
+    ~safe_VkPhysicalDeviceShaderIntegerDotProductProperties();
+    void initialize(const VkPhysicalDeviceShaderIntegerDotProductProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderIntegerDotProductProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderIntegerDotProductProperties* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductProperties*>(this);
+    }
+    VkPhysicalDeviceShaderIntegerDotProductProperties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductProperties const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceTexelBufferAlignmentProperties {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceSize storageTexelBufferOffsetAlignmentBytes;
+    VkBool32 storageTexelBufferOffsetSingleTexelAlignment;
+    VkDeviceSize uniformTexelBufferOffsetAlignmentBytes;
+    VkBool32 uniformTexelBufferOffsetSingleTexelAlignment;
+
+    safe_VkPhysicalDeviceTexelBufferAlignmentProperties(const VkPhysicalDeviceTexelBufferAlignmentProperties* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceTexelBufferAlignmentProperties(const safe_VkPhysicalDeviceTexelBufferAlignmentProperties& copy_src);
+    safe_VkPhysicalDeviceTexelBufferAlignmentProperties& operator=(
+        const safe_VkPhysicalDeviceTexelBufferAlignmentProperties& copy_src);
+    safe_VkPhysicalDeviceTexelBufferAlignmentProperties();
+    ~safe_VkPhysicalDeviceTexelBufferAlignmentProperties();
+    void initialize(const VkPhysicalDeviceTexelBufferAlignmentProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceTexelBufferAlignmentProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceTexelBufferAlignmentProperties* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentProperties*>(this);
+    }
+    VkPhysicalDeviceTexelBufferAlignmentProperties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentProperties const*>(this);
+    }
+};
+struct safe_VkFormatProperties3 {
+    VkStructureType sType;
+    void* pNext{};
+    VkFormatFeatureFlags2 linearTilingFeatures;
+    VkFormatFeatureFlags2 optimalTilingFeatures;
+    VkFormatFeatureFlags2 bufferFeatures;
+
+    safe_VkFormatProperties3(const VkFormatProperties3* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkFormatProperties3(const safe_VkFormatProperties3& copy_src);
+    safe_VkFormatProperties3& operator=(const safe_VkFormatProperties3& copy_src);
+    safe_VkFormatProperties3();
+    ~safe_VkFormatProperties3();
+    void initialize(const VkFormatProperties3* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkFormatProperties3* copy_src, PNextCopyState* copy_state = {});
+    VkFormatProperties3* ptr() { return reinterpret_cast<VkFormatProperties3*>(this); }
+    VkFormatProperties3 const* ptr() const { return reinterpret_cast<VkFormatProperties3 const*>(this); }
+};
+struct safe_VkPhysicalDeviceMaintenance4Features {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 maintenance4;
+
+    safe_VkPhysicalDeviceMaintenance4Features(const VkPhysicalDeviceMaintenance4Features* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceMaintenance4Features(const safe_VkPhysicalDeviceMaintenance4Features& copy_src);
+    safe_VkPhysicalDeviceMaintenance4Features& operator=(const safe_VkPhysicalDeviceMaintenance4Features& copy_src);
+    safe_VkPhysicalDeviceMaintenance4Features();
+    ~safe_VkPhysicalDeviceMaintenance4Features();
+    void initialize(const VkPhysicalDeviceMaintenance4Features* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMaintenance4Features* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMaintenance4Features* ptr() { return reinterpret_cast<VkPhysicalDeviceMaintenance4Features*>(this); }
+    VkPhysicalDeviceMaintenance4Features const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMaintenance4Features const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceMaintenance4Properties {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceSize maxBufferSize;
+
+    safe_VkPhysicalDeviceMaintenance4Properties(const VkPhysicalDeviceMaintenance4Properties* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceMaintenance4Properties(const safe_VkPhysicalDeviceMaintenance4Properties& copy_src);
+    safe_VkPhysicalDeviceMaintenance4Properties& operator=(const safe_VkPhysicalDeviceMaintenance4Properties& copy_src);
+    safe_VkPhysicalDeviceMaintenance4Properties();
+    ~safe_VkPhysicalDeviceMaintenance4Properties();
+    void initialize(const VkPhysicalDeviceMaintenance4Properties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMaintenance4Properties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMaintenance4Properties* ptr() { return reinterpret_cast<VkPhysicalDeviceMaintenance4Properties*>(this); }
+    VkPhysicalDeviceMaintenance4Properties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMaintenance4Properties const*>(this);
+    }
+};
+struct safe_VkDeviceBufferMemoryRequirements {
+    VkStructureType sType;
+    const void* pNext{};
+    safe_VkBufferCreateInfo* pCreateInfo{};
+
+    safe_VkDeviceBufferMemoryRequirements(const VkDeviceBufferMemoryRequirements* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkDeviceBufferMemoryRequirements(const safe_VkDeviceBufferMemoryRequirements& copy_src);
+    safe_VkDeviceBufferMemoryRequirements& operator=(const safe_VkDeviceBufferMemoryRequirements& copy_src);
+    safe_VkDeviceBufferMemoryRequirements();
+    ~safe_VkDeviceBufferMemoryRequirements();
+    void initialize(const VkDeviceBufferMemoryRequirements* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDeviceBufferMemoryRequirements* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceBufferMemoryRequirements* ptr() { return reinterpret_cast<VkDeviceBufferMemoryRequirements*>(this); }
+    VkDeviceBufferMemoryRequirements const* ptr() const { return reinterpret_cast<VkDeviceBufferMemoryRequirements const*>(this); }
+};
+struct safe_VkDeviceImageMemoryRequirements {
+    VkStructureType sType;
+    const void* pNext{};
+    safe_VkImageCreateInfo* pCreateInfo{};
+    VkImageAspectFlagBits planeAspect;
+
+    safe_VkDeviceImageMemoryRequirements(const VkDeviceImageMemoryRequirements* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkDeviceImageMemoryRequirements(const safe_VkDeviceImageMemoryRequirements& copy_src);
+    safe_VkDeviceImageMemoryRequirements& operator=(const safe_VkDeviceImageMemoryRequirements& copy_src);
+    safe_VkDeviceImageMemoryRequirements();
+    ~safe_VkDeviceImageMemoryRequirements();
+    void initialize(const VkDeviceImageMemoryRequirements* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDeviceImageMemoryRequirements* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceImageMemoryRequirements* ptr() { return reinterpret_cast<VkDeviceImageMemoryRequirements*>(this); }
+    VkDeviceImageMemoryRequirements const* ptr() const { return reinterpret_cast<VkDeviceImageMemoryRequirements const*>(this); }
+};
+struct safe_VkSwapchainCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSwapchainCreateFlagsKHR flags;
+    VkSurfaceKHR surface;
+    uint32_t minImageCount;
+    VkFormat imageFormat;
+    VkColorSpaceKHR imageColorSpace;
+    VkExtent2D imageExtent;
+    uint32_t imageArrayLayers;
+    VkImageUsageFlags imageUsage;
+    VkSharingMode imageSharingMode;
+    uint32_t queueFamilyIndexCount;
+    const uint32_t* pQueueFamilyIndices{};
+    VkSurfaceTransformFlagBitsKHR preTransform;
+    VkCompositeAlphaFlagBitsKHR compositeAlpha;
+    VkPresentModeKHR presentMode;
+    VkBool32 clipped;
+    VkSwapchainKHR oldSwapchain;
+
+    safe_VkSwapchainCreateInfoKHR(const VkSwapchainCreateInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    safe_VkSwapchainCreateInfoKHR(const safe_VkSwapchainCreateInfoKHR& copy_src);
+    safe_VkSwapchainCreateInfoKHR& operator=(const safe_VkSwapchainCreateInfoKHR& copy_src);
+    safe_VkSwapchainCreateInfoKHR();
+    ~safe_VkSwapchainCreateInfoKHR();
+    void initialize(const VkSwapchainCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSwapchainCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkSwapchainCreateInfoKHR* ptr() { return reinterpret_cast<VkSwapchainCreateInfoKHR*>(this); }
+    VkSwapchainCreateInfoKHR const* ptr() const { return reinterpret_cast<VkSwapchainCreateInfoKHR const*>(this); }
+};
+struct safe_VkPresentInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t waitSemaphoreCount;
+    VkSemaphore* pWaitSemaphores{};
+    uint32_t swapchainCount;
+    VkSwapchainKHR* pSwapchains{};
+    const uint32_t* pImageIndices{};
+    VkResult* pResults{};
+
+    safe_VkPresentInfoKHR(const VkPresentInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPresentInfoKHR(const safe_VkPresentInfoKHR& copy_src);
+    safe_VkPresentInfoKHR& operator=(const safe_VkPresentInfoKHR& copy_src);
+    safe_VkPresentInfoKHR();
+    ~safe_VkPresentInfoKHR();
+    void initialize(const VkPresentInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPresentInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPresentInfoKHR* ptr() { return reinterpret_cast<VkPresentInfoKHR*>(this); }
+    VkPresentInfoKHR const* ptr() const { return reinterpret_cast<VkPresentInfoKHR const*>(this); }
+};
+struct safe_VkImageSwapchainCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSwapchainKHR swapchain;
+
+    safe_VkImageSwapchainCreateInfoKHR(const VkImageSwapchainCreateInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    safe_VkImageSwapchainCreateInfoKHR(const safe_VkImageSwapchainCreateInfoKHR& copy_src);
+    safe_VkImageSwapchainCreateInfoKHR& operator=(const safe_VkImageSwapchainCreateInfoKHR& copy_src);
+    safe_VkImageSwapchainCreateInfoKHR();
+    ~safe_VkImageSwapchainCreateInfoKHR();
+    void initialize(const VkImageSwapchainCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageSwapchainCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkImageSwapchainCreateInfoKHR* ptr() { return reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(this); }
+    VkImageSwapchainCreateInfoKHR const* ptr() const { return reinterpret_cast<VkImageSwapchainCreateInfoKHR const*>(this); }
+};
+struct safe_VkBindImageMemorySwapchainInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSwapchainKHR swapchain;
+    uint32_t imageIndex;
+
+    safe_VkBindImageMemorySwapchainInfoKHR(const VkBindImageMemorySwapchainInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                           bool copy_pnext = true);
+    safe_VkBindImageMemorySwapchainInfoKHR(const safe_VkBindImageMemorySwapchainInfoKHR& copy_src);
+    safe_VkBindImageMemorySwapchainInfoKHR& operator=(const safe_VkBindImageMemorySwapchainInfoKHR& copy_src);
+    safe_VkBindImageMemorySwapchainInfoKHR();
+    ~safe_VkBindImageMemorySwapchainInfoKHR();
+    void initialize(const VkBindImageMemorySwapchainInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBindImageMemorySwapchainInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkBindImageMemorySwapchainInfoKHR* ptr() { return reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(this); }
+    VkBindImageMemorySwapchainInfoKHR const* ptr() const {
+        return reinterpret_cast<VkBindImageMemorySwapchainInfoKHR const*>(this);
+    }
+};
+struct safe_VkAcquireNextImageInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSwapchainKHR swapchain;
+    uint64_t timeout;
+    VkSemaphore semaphore;
+    VkFence fence;
+    uint32_t deviceMask;
+
+    safe_VkAcquireNextImageInfoKHR(const VkAcquireNextImageInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    safe_VkAcquireNextImageInfoKHR(const safe_VkAcquireNextImageInfoKHR& copy_src);
+    safe_VkAcquireNextImageInfoKHR& operator=(const safe_VkAcquireNextImageInfoKHR& copy_src);
+    safe_VkAcquireNextImageInfoKHR();
+    ~safe_VkAcquireNextImageInfoKHR();
+    void initialize(const VkAcquireNextImageInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAcquireNextImageInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkAcquireNextImageInfoKHR* ptr() { return reinterpret_cast<VkAcquireNextImageInfoKHR*>(this); }
+    VkAcquireNextImageInfoKHR const* ptr() const { return reinterpret_cast<VkAcquireNextImageInfoKHR const*>(this); }
+};
+struct safe_VkDeviceGroupPresentCapabilitiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE];
+    VkDeviceGroupPresentModeFlagsKHR modes;
+
+    safe_VkDeviceGroupPresentCapabilitiesKHR(const VkDeviceGroupPresentCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkDeviceGroupPresentCapabilitiesKHR(const safe_VkDeviceGroupPresentCapabilitiesKHR& copy_src);
+    safe_VkDeviceGroupPresentCapabilitiesKHR& operator=(const safe_VkDeviceGroupPresentCapabilitiesKHR& copy_src);
+    safe_VkDeviceGroupPresentCapabilitiesKHR();
+    ~safe_VkDeviceGroupPresentCapabilitiesKHR();
+    void initialize(const VkDeviceGroupPresentCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDeviceGroupPresentCapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceGroupPresentCapabilitiesKHR* ptr() { return reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR*>(this); }
+    VkDeviceGroupPresentCapabilitiesKHR const* ptr() const {
+        return reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR const*>(this);
+    }
+};
+struct safe_VkDeviceGroupPresentInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t swapchainCount;
+    const uint32_t* pDeviceMasks{};
+    VkDeviceGroupPresentModeFlagBitsKHR mode;
+
+    safe_VkDeviceGroupPresentInfoKHR(const VkDeviceGroupPresentInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    safe_VkDeviceGroupPresentInfoKHR(const safe_VkDeviceGroupPresentInfoKHR& copy_src);
+    safe_VkDeviceGroupPresentInfoKHR& operator=(const safe_VkDeviceGroupPresentInfoKHR& copy_src);
+    safe_VkDeviceGroupPresentInfoKHR();
+    ~safe_VkDeviceGroupPresentInfoKHR();
+    void initialize(const VkDeviceGroupPresentInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDeviceGroupPresentInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceGroupPresentInfoKHR* ptr() { return reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(this); }
+    VkDeviceGroupPresentInfoKHR const* ptr() const { return reinterpret_cast<VkDeviceGroupPresentInfoKHR const*>(this); }
+};
+struct safe_VkDeviceGroupSwapchainCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceGroupPresentModeFlagsKHR modes;
+
+    safe_VkDeviceGroupSwapchainCreateInfoKHR(const VkDeviceGroupSwapchainCreateInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkDeviceGroupSwapchainCreateInfoKHR(const safe_VkDeviceGroupSwapchainCreateInfoKHR& copy_src);
+    safe_VkDeviceGroupSwapchainCreateInfoKHR& operator=(const safe_VkDeviceGroupSwapchainCreateInfoKHR& copy_src);
+    safe_VkDeviceGroupSwapchainCreateInfoKHR();
+    ~safe_VkDeviceGroupSwapchainCreateInfoKHR();
+    void initialize(const VkDeviceGroupSwapchainCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDeviceGroupSwapchainCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceGroupSwapchainCreateInfoKHR* ptr() { return reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(this); }
+    VkDeviceGroupSwapchainCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR const*>(this);
+    }
+};
+struct safe_VkDisplayModeCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDisplayModeCreateFlagsKHR flags;
+    VkDisplayModeParametersKHR parameters;
+
+    safe_VkDisplayModeCreateInfoKHR(const VkDisplayModeCreateInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    safe_VkDisplayModeCreateInfoKHR(const safe_VkDisplayModeCreateInfoKHR& copy_src);
+    safe_VkDisplayModeCreateInfoKHR& operator=(const safe_VkDisplayModeCreateInfoKHR& copy_src);
+    safe_VkDisplayModeCreateInfoKHR();
+    ~safe_VkDisplayModeCreateInfoKHR();
+    void initialize(const VkDisplayModeCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDisplayModeCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkDisplayModeCreateInfoKHR* ptr() { return reinterpret_cast<VkDisplayModeCreateInfoKHR*>(this); }
+    VkDisplayModeCreateInfoKHR const* ptr() const { return reinterpret_cast<VkDisplayModeCreateInfoKHR const*>(this); }
+};
+struct safe_VkDisplayPropertiesKHR {
+    VkDisplayKHR display;
+    const char* displayName{};
+    VkExtent2D physicalDimensions;
+    VkExtent2D physicalResolution;
+    VkSurfaceTransformFlagsKHR supportedTransforms;
+    VkBool32 planeReorderPossible;
+    VkBool32 persistentContent;
+
+    safe_VkDisplayPropertiesKHR(const VkDisplayPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    safe_VkDisplayPropertiesKHR(const safe_VkDisplayPropertiesKHR& copy_src);
+    safe_VkDisplayPropertiesKHR& operator=(const safe_VkDisplayPropertiesKHR& copy_src);
+    safe_VkDisplayPropertiesKHR();
+    ~safe_VkDisplayPropertiesKHR();
+    void initialize(const VkDisplayPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDisplayPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkDisplayPropertiesKHR* ptr() { return reinterpret_cast<VkDisplayPropertiesKHR*>(this); }
+    VkDisplayPropertiesKHR const* ptr() const { return reinterpret_cast<VkDisplayPropertiesKHR const*>(this); }
+};
+struct safe_VkDisplaySurfaceCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDisplaySurfaceCreateFlagsKHR flags;
+    VkDisplayModeKHR displayMode;
+    uint32_t planeIndex;
+    uint32_t planeStackIndex;
+    VkSurfaceTransformFlagBitsKHR transform;
+    float globalAlpha;
+    VkDisplayPlaneAlphaFlagBitsKHR alphaMode;
+    VkExtent2D imageExtent;
+
+    safe_VkDisplaySurfaceCreateInfoKHR(const VkDisplaySurfaceCreateInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    safe_VkDisplaySurfaceCreateInfoKHR(const safe_VkDisplaySurfaceCreateInfoKHR& copy_src);
+    safe_VkDisplaySurfaceCreateInfoKHR& operator=(const safe_VkDisplaySurfaceCreateInfoKHR& copy_src);
+    safe_VkDisplaySurfaceCreateInfoKHR();
+    ~safe_VkDisplaySurfaceCreateInfoKHR();
+    void initialize(const VkDisplaySurfaceCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDisplaySurfaceCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkDisplaySurfaceCreateInfoKHR* ptr() { return reinterpret_cast<VkDisplaySurfaceCreateInfoKHR*>(this); }
+    VkDisplaySurfaceCreateInfoKHR const* ptr() const { return reinterpret_cast<VkDisplaySurfaceCreateInfoKHR const*>(this); }
+};
+struct safe_VkDisplayPresentInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkRect2D srcRect;
+    VkRect2D dstRect;
+    VkBool32 persistent;
+
+    safe_VkDisplayPresentInfoKHR(const VkDisplayPresentInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDisplayPresentInfoKHR(const safe_VkDisplayPresentInfoKHR& copy_src);
+    safe_VkDisplayPresentInfoKHR& operator=(const safe_VkDisplayPresentInfoKHR& copy_src);
+    safe_VkDisplayPresentInfoKHR();
+    ~safe_VkDisplayPresentInfoKHR();
+    void initialize(const VkDisplayPresentInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDisplayPresentInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkDisplayPresentInfoKHR* ptr() { return reinterpret_cast<VkDisplayPresentInfoKHR*>(this); }
+    VkDisplayPresentInfoKHR const* ptr() const { return reinterpret_cast<VkDisplayPresentInfoKHR const*>(this); }
+};
+struct safe_VkQueueFamilyQueryResultStatusPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 queryResultStatusSupport;
+
+    safe_VkQueueFamilyQueryResultStatusPropertiesKHR(const VkQueueFamilyQueryResultStatusPropertiesKHR* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkQueueFamilyQueryResultStatusPropertiesKHR(const safe_VkQueueFamilyQueryResultStatusPropertiesKHR& copy_src);
+    safe_VkQueueFamilyQueryResultStatusPropertiesKHR& operator=(const safe_VkQueueFamilyQueryResultStatusPropertiesKHR& copy_src);
+    safe_VkQueueFamilyQueryResultStatusPropertiesKHR();
+    ~safe_VkQueueFamilyQueryResultStatusPropertiesKHR();
+    void initialize(const VkQueueFamilyQueryResultStatusPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkQueueFamilyQueryResultStatusPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkQueueFamilyQueryResultStatusPropertiesKHR* ptr() {
+        return reinterpret_cast<VkQueueFamilyQueryResultStatusPropertiesKHR*>(this);
+    }
+    VkQueueFamilyQueryResultStatusPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkQueueFamilyQueryResultStatusPropertiesKHR const*>(this);
+    }
+};
+struct safe_VkQueueFamilyVideoPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkVideoCodecOperationFlagsKHR videoCodecOperations;
+
+    safe_VkQueueFamilyVideoPropertiesKHR(const VkQueueFamilyVideoPropertiesKHR* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkQueueFamilyVideoPropertiesKHR(const safe_VkQueueFamilyVideoPropertiesKHR& copy_src);
+    safe_VkQueueFamilyVideoPropertiesKHR& operator=(const safe_VkQueueFamilyVideoPropertiesKHR& copy_src);
+    safe_VkQueueFamilyVideoPropertiesKHR();
+    ~safe_VkQueueFamilyVideoPropertiesKHR();
+    void initialize(const VkQueueFamilyVideoPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkQueueFamilyVideoPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkQueueFamilyVideoPropertiesKHR* ptr() { return reinterpret_cast<VkQueueFamilyVideoPropertiesKHR*>(this); }
+    VkQueueFamilyVideoPropertiesKHR const* ptr() const { return reinterpret_cast<VkQueueFamilyVideoPropertiesKHR const*>(this); }
+};
+struct safe_VkVideoProfileInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkVideoCodecOperationFlagBitsKHR videoCodecOperation;
+    VkVideoChromaSubsamplingFlagsKHR chromaSubsampling;
+    VkVideoComponentBitDepthFlagsKHR lumaBitDepth;
+    VkVideoComponentBitDepthFlagsKHR chromaBitDepth;
+
+    safe_VkVideoProfileInfoKHR(const VkVideoProfileInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoProfileInfoKHR(const safe_VkVideoProfileInfoKHR& copy_src);
+    safe_VkVideoProfileInfoKHR& operator=(const safe_VkVideoProfileInfoKHR& copy_src);
+    safe_VkVideoProfileInfoKHR();
+    ~safe_VkVideoProfileInfoKHR();
+    void initialize(const VkVideoProfileInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoProfileInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoProfileInfoKHR* ptr() { return reinterpret_cast<VkVideoProfileInfoKHR*>(this); }
+    VkVideoProfileInfoKHR const* ptr() const { return reinterpret_cast<VkVideoProfileInfoKHR const*>(this); }
+};
+struct safe_VkVideoProfileListInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t profileCount;
+    safe_VkVideoProfileInfoKHR* pProfiles{};
+
+    safe_VkVideoProfileListInfoKHR(const VkVideoProfileListInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    safe_VkVideoProfileListInfoKHR(const safe_VkVideoProfileListInfoKHR& copy_src);
+    safe_VkVideoProfileListInfoKHR& operator=(const safe_VkVideoProfileListInfoKHR& copy_src);
+    safe_VkVideoProfileListInfoKHR();
+    ~safe_VkVideoProfileListInfoKHR();
+    void initialize(const VkVideoProfileListInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoProfileListInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoProfileListInfoKHR* ptr() { return reinterpret_cast<VkVideoProfileListInfoKHR*>(this); }
+    VkVideoProfileListInfoKHR const* ptr() const { return reinterpret_cast<VkVideoProfileListInfoKHR const*>(this); }
+};
+struct safe_VkVideoCapabilitiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkVideoCapabilityFlagsKHR flags;
+    VkDeviceSize minBitstreamBufferOffsetAlignment;
+    VkDeviceSize minBitstreamBufferSizeAlignment;
+    VkExtent2D pictureAccessGranularity;
+    VkExtent2D minCodedExtent;
+    VkExtent2D maxCodedExtent;
+    uint32_t maxDpbSlots;
+    uint32_t maxActiveReferencePictures;
+    VkExtensionProperties stdHeaderVersion;
+
+    safe_VkVideoCapabilitiesKHR(const VkVideoCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoCapabilitiesKHR(const safe_VkVideoCapabilitiesKHR& copy_src);
+    safe_VkVideoCapabilitiesKHR& operator=(const safe_VkVideoCapabilitiesKHR& copy_src);
+    safe_VkVideoCapabilitiesKHR();
+    ~safe_VkVideoCapabilitiesKHR();
+    void initialize(const VkVideoCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoCapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoCapabilitiesKHR* ptr() { return reinterpret_cast<VkVideoCapabilitiesKHR*>(this); }
+    VkVideoCapabilitiesKHR const* ptr() const { return reinterpret_cast<VkVideoCapabilitiesKHR const*>(this); }
+};
+struct safe_VkPhysicalDeviceVideoFormatInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageUsageFlags imageUsage;
+
+    safe_VkPhysicalDeviceVideoFormatInfoKHR(const VkPhysicalDeviceVideoFormatInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                            bool copy_pnext = true);
+    safe_VkPhysicalDeviceVideoFormatInfoKHR(const safe_VkPhysicalDeviceVideoFormatInfoKHR& copy_src);
+    safe_VkPhysicalDeviceVideoFormatInfoKHR& operator=(const safe_VkPhysicalDeviceVideoFormatInfoKHR& copy_src);
+    safe_VkPhysicalDeviceVideoFormatInfoKHR();
+    ~safe_VkPhysicalDeviceVideoFormatInfoKHR();
+    void initialize(const VkPhysicalDeviceVideoFormatInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceVideoFormatInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVideoFormatInfoKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceVideoFormatInfoKHR*>(this); }
+    VkPhysicalDeviceVideoFormatInfoKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceVideoFormatInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoFormatPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkFormat format;
+    VkComponentMapping componentMapping;
+    VkImageCreateFlags imageCreateFlags;
+    VkImageType imageType;
+    VkImageTiling imageTiling;
+    VkImageUsageFlags imageUsageFlags;
+
+    safe_VkVideoFormatPropertiesKHR(const VkVideoFormatPropertiesKHR* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    safe_VkVideoFormatPropertiesKHR(const safe_VkVideoFormatPropertiesKHR& copy_src);
+    safe_VkVideoFormatPropertiesKHR& operator=(const safe_VkVideoFormatPropertiesKHR& copy_src);
+    safe_VkVideoFormatPropertiesKHR();
+    ~safe_VkVideoFormatPropertiesKHR();
+    void initialize(const VkVideoFormatPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoFormatPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoFormatPropertiesKHR* ptr() { return reinterpret_cast<VkVideoFormatPropertiesKHR*>(this); }
+    VkVideoFormatPropertiesKHR const* ptr() const { return reinterpret_cast<VkVideoFormatPropertiesKHR const*>(this); }
+};
+struct safe_VkVideoPictureResourceInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkOffset2D codedOffset;
+    VkExtent2D codedExtent;
+    uint32_t baseArrayLayer;
+    VkImageView imageViewBinding;
+
+    safe_VkVideoPictureResourceInfoKHR(const VkVideoPictureResourceInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    safe_VkVideoPictureResourceInfoKHR(const safe_VkVideoPictureResourceInfoKHR& copy_src);
+    safe_VkVideoPictureResourceInfoKHR& operator=(const safe_VkVideoPictureResourceInfoKHR& copy_src);
+    safe_VkVideoPictureResourceInfoKHR();
+    ~safe_VkVideoPictureResourceInfoKHR();
+    void initialize(const VkVideoPictureResourceInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoPictureResourceInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoPictureResourceInfoKHR* ptr() { return reinterpret_cast<VkVideoPictureResourceInfoKHR*>(this); }
+    VkVideoPictureResourceInfoKHR const* ptr() const { return reinterpret_cast<VkVideoPictureResourceInfoKHR const*>(this); }
+};
+struct safe_VkVideoReferenceSlotInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    int32_t slotIndex;
+    safe_VkVideoPictureResourceInfoKHR* pPictureResource{};
+
+    safe_VkVideoReferenceSlotInfoKHR(const VkVideoReferenceSlotInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    safe_VkVideoReferenceSlotInfoKHR(const safe_VkVideoReferenceSlotInfoKHR& copy_src);
+    safe_VkVideoReferenceSlotInfoKHR& operator=(const safe_VkVideoReferenceSlotInfoKHR& copy_src);
+    safe_VkVideoReferenceSlotInfoKHR();
+    ~safe_VkVideoReferenceSlotInfoKHR();
+    void initialize(const VkVideoReferenceSlotInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoReferenceSlotInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoReferenceSlotInfoKHR* ptr() { return reinterpret_cast<VkVideoReferenceSlotInfoKHR*>(this); }
+    VkVideoReferenceSlotInfoKHR const* ptr() const { return reinterpret_cast<VkVideoReferenceSlotInfoKHR const*>(this); }
+};
+struct safe_VkVideoSessionMemoryRequirementsKHR {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t memoryBindIndex;
+    VkMemoryRequirements memoryRequirements;
+
+    safe_VkVideoSessionMemoryRequirementsKHR(const VkVideoSessionMemoryRequirementsKHR* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkVideoSessionMemoryRequirementsKHR(const safe_VkVideoSessionMemoryRequirementsKHR& copy_src);
+    safe_VkVideoSessionMemoryRequirementsKHR& operator=(const safe_VkVideoSessionMemoryRequirementsKHR& copy_src);
+    safe_VkVideoSessionMemoryRequirementsKHR();
+    ~safe_VkVideoSessionMemoryRequirementsKHR();
+    void initialize(const VkVideoSessionMemoryRequirementsKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoSessionMemoryRequirementsKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoSessionMemoryRequirementsKHR* ptr() { return reinterpret_cast<VkVideoSessionMemoryRequirementsKHR*>(this); }
+    VkVideoSessionMemoryRequirementsKHR const* ptr() const {
+        return reinterpret_cast<VkVideoSessionMemoryRequirementsKHR const*>(this);
+    }
+};
+struct safe_VkBindVideoSessionMemoryInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t memoryBindIndex;
+    VkDeviceMemory memory;
+    VkDeviceSize memoryOffset;
+    VkDeviceSize memorySize;
+
+    safe_VkBindVideoSessionMemoryInfoKHR(const VkBindVideoSessionMemoryInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkBindVideoSessionMemoryInfoKHR(const safe_VkBindVideoSessionMemoryInfoKHR& copy_src);
+    safe_VkBindVideoSessionMemoryInfoKHR& operator=(const safe_VkBindVideoSessionMemoryInfoKHR& copy_src);
+    safe_VkBindVideoSessionMemoryInfoKHR();
+    ~safe_VkBindVideoSessionMemoryInfoKHR();
+    void initialize(const VkBindVideoSessionMemoryInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBindVideoSessionMemoryInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkBindVideoSessionMemoryInfoKHR* ptr() { return reinterpret_cast<VkBindVideoSessionMemoryInfoKHR*>(this); }
+    VkBindVideoSessionMemoryInfoKHR const* ptr() const { return reinterpret_cast<VkBindVideoSessionMemoryInfoKHR const*>(this); }
+};
+struct safe_VkVideoSessionCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t queueFamilyIndex;
+    VkVideoSessionCreateFlagsKHR flags;
+    safe_VkVideoProfileInfoKHR* pVideoProfile{};
+    VkFormat pictureFormat;
+    VkExtent2D maxCodedExtent;
+    VkFormat referencePictureFormat;
+    uint32_t maxDpbSlots;
+    uint32_t maxActiveReferencePictures;
+    const VkExtensionProperties* pStdHeaderVersion{};
+
+    safe_VkVideoSessionCreateInfoKHR(const VkVideoSessionCreateInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    safe_VkVideoSessionCreateInfoKHR(const safe_VkVideoSessionCreateInfoKHR& copy_src);
+    safe_VkVideoSessionCreateInfoKHR& operator=(const safe_VkVideoSessionCreateInfoKHR& copy_src);
+    safe_VkVideoSessionCreateInfoKHR();
+    ~safe_VkVideoSessionCreateInfoKHR();
+    void initialize(const VkVideoSessionCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoSessionCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoSessionCreateInfoKHR* ptr() { return reinterpret_cast<VkVideoSessionCreateInfoKHR*>(this); }
+    VkVideoSessionCreateInfoKHR const* ptr() const { return reinterpret_cast<VkVideoSessionCreateInfoKHR const*>(this); }
+};
+struct safe_VkVideoSessionParametersCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkVideoSessionParametersCreateFlagsKHR flags;
+    VkVideoSessionParametersKHR videoSessionParametersTemplate;
+    VkVideoSessionKHR videoSession;
+
+    safe_VkVideoSessionParametersCreateInfoKHR(const VkVideoSessionParametersCreateInfoKHR* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoSessionParametersCreateInfoKHR(const safe_VkVideoSessionParametersCreateInfoKHR& copy_src);
+    safe_VkVideoSessionParametersCreateInfoKHR& operator=(const safe_VkVideoSessionParametersCreateInfoKHR& copy_src);
+    safe_VkVideoSessionParametersCreateInfoKHR();
+    ~safe_VkVideoSessionParametersCreateInfoKHR();
+    void initialize(const VkVideoSessionParametersCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoSessionParametersCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoSessionParametersCreateInfoKHR* ptr() { return reinterpret_cast<VkVideoSessionParametersCreateInfoKHR*>(this); }
+    VkVideoSessionParametersCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoSessionParametersCreateInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoSessionParametersUpdateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t updateSequenceCount;
+
+    safe_VkVideoSessionParametersUpdateInfoKHR(const VkVideoSessionParametersUpdateInfoKHR* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoSessionParametersUpdateInfoKHR(const safe_VkVideoSessionParametersUpdateInfoKHR& copy_src);
+    safe_VkVideoSessionParametersUpdateInfoKHR& operator=(const safe_VkVideoSessionParametersUpdateInfoKHR& copy_src);
+    safe_VkVideoSessionParametersUpdateInfoKHR();
+    ~safe_VkVideoSessionParametersUpdateInfoKHR();
+    void initialize(const VkVideoSessionParametersUpdateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoSessionParametersUpdateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoSessionParametersUpdateInfoKHR* ptr() { return reinterpret_cast<VkVideoSessionParametersUpdateInfoKHR*>(this); }
+    VkVideoSessionParametersUpdateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoSessionParametersUpdateInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoBeginCodingInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkVideoBeginCodingFlagsKHR flags;
+    VkVideoSessionKHR videoSession;
+    VkVideoSessionParametersKHR videoSessionParameters;
+    uint32_t referenceSlotCount;
+    safe_VkVideoReferenceSlotInfoKHR* pReferenceSlots{};
+
+    safe_VkVideoBeginCodingInfoKHR(const VkVideoBeginCodingInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    safe_VkVideoBeginCodingInfoKHR(const safe_VkVideoBeginCodingInfoKHR& copy_src);
+    safe_VkVideoBeginCodingInfoKHR& operator=(const safe_VkVideoBeginCodingInfoKHR& copy_src);
+    safe_VkVideoBeginCodingInfoKHR();
+    ~safe_VkVideoBeginCodingInfoKHR();
+    void initialize(const VkVideoBeginCodingInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoBeginCodingInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoBeginCodingInfoKHR* ptr() { return reinterpret_cast<VkVideoBeginCodingInfoKHR*>(this); }
+    VkVideoBeginCodingInfoKHR const* ptr() const { return reinterpret_cast<VkVideoBeginCodingInfoKHR const*>(this); }
+};
+struct safe_VkVideoEndCodingInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkVideoEndCodingFlagsKHR flags;
+
+    safe_VkVideoEndCodingInfoKHR(const VkVideoEndCodingInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEndCodingInfoKHR(const safe_VkVideoEndCodingInfoKHR& copy_src);
+    safe_VkVideoEndCodingInfoKHR& operator=(const safe_VkVideoEndCodingInfoKHR& copy_src);
+    safe_VkVideoEndCodingInfoKHR();
+    ~safe_VkVideoEndCodingInfoKHR();
+    void initialize(const VkVideoEndCodingInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEndCodingInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEndCodingInfoKHR* ptr() { return reinterpret_cast<VkVideoEndCodingInfoKHR*>(this); }
+    VkVideoEndCodingInfoKHR const* ptr() const { return reinterpret_cast<VkVideoEndCodingInfoKHR const*>(this); }
+};
+struct safe_VkVideoCodingControlInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkVideoCodingControlFlagsKHR flags;
+
+    safe_VkVideoCodingControlInfoKHR(const VkVideoCodingControlInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    safe_VkVideoCodingControlInfoKHR(const safe_VkVideoCodingControlInfoKHR& copy_src);
+    safe_VkVideoCodingControlInfoKHR& operator=(const safe_VkVideoCodingControlInfoKHR& copy_src);
+    safe_VkVideoCodingControlInfoKHR();
+    ~safe_VkVideoCodingControlInfoKHR();
+    void initialize(const VkVideoCodingControlInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoCodingControlInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoCodingControlInfoKHR* ptr() { return reinterpret_cast<VkVideoCodingControlInfoKHR*>(this); }
+    VkVideoCodingControlInfoKHR const* ptr() const { return reinterpret_cast<VkVideoCodingControlInfoKHR const*>(this); }
+};
+struct safe_VkVideoDecodeCapabilitiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkVideoDecodeCapabilityFlagsKHR flags;
+
+    safe_VkVideoDecodeCapabilitiesKHR(const VkVideoDecodeCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    safe_VkVideoDecodeCapabilitiesKHR(const safe_VkVideoDecodeCapabilitiesKHR& copy_src);
+    safe_VkVideoDecodeCapabilitiesKHR& operator=(const safe_VkVideoDecodeCapabilitiesKHR& copy_src);
+    safe_VkVideoDecodeCapabilitiesKHR();
+    ~safe_VkVideoDecodeCapabilitiesKHR();
+    void initialize(const VkVideoDecodeCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoDecodeCapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeCapabilitiesKHR* ptr() { return reinterpret_cast<VkVideoDecodeCapabilitiesKHR*>(this); }
+    VkVideoDecodeCapabilitiesKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeCapabilitiesKHR const*>(this); }
+};
+struct safe_VkVideoDecodeUsageInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkVideoDecodeUsageFlagsKHR videoUsageHints;
+
+    safe_VkVideoDecodeUsageInfoKHR(const VkVideoDecodeUsageInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    safe_VkVideoDecodeUsageInfoKHR(const safe_VkVideoDecodeUsageInfoKHR& copy_src);
+    safe_VkVideoDecodeUsageInfoKHR& operator=(const safe_VkVideoDecodeUsageInfoKHR& copy_src);
+    safe_VkVideoDecodeUsageInfoKHR();
+    ~safe_VkVideoDecodeUsageInfoKHR();
+    void initialize(const VkVideoDecodeUsageInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoDecodeUsageInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeUsageInfoKHR* ptr() { return reinterpret_cast<VkVideoDecodeUsageInfoKHR*>(this); }
+    VkVideoDecodeUsageInfoKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeUsageInfoKHR const*>(this); }
+};
+struct safe_VkVideoDecodeInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkVideoDecodeFlagsKHR flags;
+    VkBuffer srcBuffer;
+    VkDeviceSize srcBufferOffset;
+    VkDeviceSize srcBufferRange;
+    safe_VkVideoPictureResourceInfoKHR dstPictureResource;
+    safe_VkVideoReferenceSlotInfoKHR* pSetupReferenceSlot{};
+    uint32_t referenceSlotCount;
+    safe_VkVideoReferenceSlotInfoKHR* pReferenceSlots{};
+
+    safe_VkVideoDecodeInfoKHR(const VkVideoDecodeInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoDecodeInfoKHR(const safe_VkVideoDecodeInfoKHR& copy_src);
+    safe_VkVideoDecodeInfoKHR& operator=(const safe_VkVideoDecodeInfoKHR& copy_src);
+    safe_VkVideoDecodeInfoKHR();
+    ~safe_VkVideoDecodeInfoKHR();
+    void initialize(const VkVideoDecodeInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoDecodeInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeInfoKHR* ptr() { return reinterpret_cast<VkVideoDecodeInfoKHR*>(this); }
+    VkVideoDecodeInfoKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeInfoKHR const*>(this); }
+};
+struct safe_VkVideoEncodeH264CapabilitiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkVideoEncodeH264CapabilityFlagsKHR flags;
+    StdVideoH264LevelIdc maxLevelIdc;
+    uint32_t maxSliceCount;
+    uint32_t maxPPictureL0ReferenceCount;
+    uint32_t maxBPictureL0ReferenceCount;
+    uint32_t maxL1ReferenceCount;
+    uint32_t maxTemporalLayerCount;
+    VkBool32 expectDyadicTemporalLayerPattern;
+    int32_t minQp;
+    int32_t maxQp;
+    VkBool32 prefersGopRemainingFrames;
+    VkBool32 requiresGopRemainingFrames;
+    VkVideoEncodeH264StdFlagsKHR stdSyntaxFlags;
+
+    safe_VkVideoEncodeH264CapabilitiesKHR(const VkVideoEncodeH264CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkVideoEncodeH264CapabilitiesKHR(const safe_VkVideoEncodeH264CapabilitiesKHR& copy_src);
+    safe_VkVideoEncodeH264CapabilitiesKHR& operator=(const safe_VkVideoEncodeH264CapabilitiesKHR& copy_src);
+    safe_VkVideoEncodeH264CapabilitiesKHR();
+    ~safe_VkVideoEncodeH264CapabilitiesKHR();
+    void initialize(const VkVideoEncodeH264CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeH264CapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH264CapabilitiesKHR* ptr() { return reinterpret_cast<VkVideoEncodeH264CapabilitiesKHR*>(this); }
+    VkVideoEncodeH264CapabilitiesKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeH264CapabilitiesKHR const*>(this); }
+};
+struct safe_VkVideoEncodeH264QualityLevelPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkVideoEncodeH264RateControlFlagsKHR preferredRateControlFlags;
+    uint32_t preferredGopFrameCount;
+    uint32_t preferredIdrPeriod;
+    uint32_t preferredConsecutiveBFrameCount;
+    uint32_t preferredTemporalLayerCount;
+    VkVideoEncodeH264QpKHR preferredConstantQp;
+    uint32_t preferredMaxL0ReferenceCount;
+    uint32_t preferredMaxL1ReferenceCount;
+    VkBool32 preferredStdEntropyCodingModeFlag;
+
+    safe_VkVideoEncodeH264QualityLevelPropertiesKHR(const VkVideoEncodeH264QualityLevelPropertiesKHR* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEncodeH264QualityLevelPropertiesKHR(const safe_VkVideoEncodeH264QualityLevelPropertiesKHR& copy_src);
+    safe_VkVideoEncodeH264QualityLevelPropertiesKHR& operator=(const safe_VkVideoEncodeH264QualityLevelPropertiesKHR& copy_src);
+    safe_VkVideoEncodeH264QualityLevelPropertiesKHR();
+    ~safe_VkVideoEncodeH264QualityLevelPropertiesKHR();
+    void initialize(const VkVideoEncodeH264QualityLevelPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeH264QualityLevelPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH264QualityLevelPropertiesKHR* ptr() {
+        return reinterpret_cast<VkVideoEncodeH264QualityLevelPropertiesKHR*>(this);
+    }
+    VkVideoEncodeH264QualityLevelPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH264QualityLevelPropertiesKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeH264SessionCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 useMaxLevelIdc;
+    StdVideoH264LevelIdc maxLevelIdc;
+
+    safe_VkVideoEncodeH264SessionCreateInfoKHR(const VkVideoEncodeH264SessionCreateInfoKHR* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEncodeH264SessionCreateInfoKHR(const safe_VkVideoEncodeH264SessionCreateInfoKHR& copy_src);
+    safe_VkVideoEncodeH264SessionCreateInfoKHR& operator=(const safe_VkVideoEncodeH264SessionCreateInfoKHR& copy_src);
+    safe_VkVideoEncodeH264SessionCreateInfoKHR();
+    ~safe_VkVideoEncodeH264SessionCreateInfoKHR();
+    void initialize(const VkVideoEncodeH264SessionCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeH264SessionCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH264SessionCreateInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH264SessionCreateInfoKHR*>(this); }
+    VkVideoEncodeH264SessionCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH264SessionCreateInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeH264SessionParametersAddInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t stdSPSCount;
+    const StdVideoH264SequenceParameterSet* pStdSPSs{};
+    uint32_t stdPPSCount;
+    const StdVideoH264PictureParameterSet* pStdPPSs{};
+
+    safe_VkVideoEncodeH264SessionParametersAddInfoKHR(const VkVideoEncodeH264SessionParametersAddInfoKHR* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEncodeH264SessionParametersAddInfoKHR(const safe_VkVideoEncodeH264SessionParametersAddInfoKHR& copy_src);
+    safe_VkVideoEncodeH264SessionParametersAddInfoKHR& operator=(const safe_VkVideoEncodeH264SessionParametersAddInfoKHR& copy_src);
+    safe_VkVideoEncodeH264SessionParametersAddInfoKHR();
+    ~safe_VkVideoEncodeH264SessionParametersAddInfoKHR();
+    void initialize(const VkVideoEncodeH264SessionParametersAddInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeH264SessionParametersAddInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH264SessionParametersAddInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoEncodeH264SessionParametersAddInfoKHR*>(this);
+    }
+    VkVideoEncodeH264SessionParametersAddInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH264SessionParametersAddInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeH264SessionParametersCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t maxStdSPSCount;
+    uint32_t maxStdPPSCount;
+    safe_VkVideoEncodeH264SessionParametersAddInfoKHR* pParametersAddInfo{};
+
+    safe_VkVideoEncodeH264SessionParametersCreateInfoKHR(const VkVideoEncodeH264SessionParametersCreateInfoKHR* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEncodeH264SessionParametersCreateInfoKHR(const safe_VkVideoEncodeH264SessionParametersCreateInfoKHR& copy_src);
+    safe_VkVideoEncodeH264SessionParametersCreateInfoKHR& operator=(
+        const safe_VkVideoEncodeH264SessionParametersCreateInfoKHR& copy_src);
+    safe_VkVideoEncodeH264SessionParametersCreateInfoKHR();
+    ~safe_VkVideoEncodeH264SessionParametersCreateInfoKHR();
+    void initialize(const VkVideoEncodeH264SessionParametersCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeH264SessionParametersCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH264SessionParametersCreateInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoEncodeH264SessionParametersCreateInfoKHR*>(this);
+    }
+    VkVideoEncodeH264SessionParametersCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH264SessionParametersCreateInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeH264SessionParametersGetInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 writeStdSPS;
+    VkBool32 writeStdPPS;
+    uint32_t stdSPSId;
+    uint32_t stdPPSId;
+
+    safe_VkVideoEncodeH264SessionParametersGetInfoKHR(const VkVideoEncodeH264SessionParametersGetInfoKHR* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEncodeH264SessionParametersGetInfoKHR(const safe_VkVideoEncodeH264SessionParametersGetInfoKHR& copy_src);
+    safe_VkVideoEncodeH264SessionParametersGetInfoKHR& operator=(const safe_VkVideoEncodeH264SessionParametersGetInfoKHR& copy_src);
+    safe_VkVideoEncodeH264SessionParametersGetInfoKHR();
+    ~safe_VkVideoEncodeH264SessionParametersGetInfoKHR();
+    void initialize(const VkVideoEncodeH264SessionParametersGetInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeH264SessionParametersGetInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH264SessionParametersGetInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoEncodeH264SessionParametersGetInfoKHR*>(this);
+    }
+    VkVideoEncodeH264SessionParametersGetInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH264SessionParametersGetInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 hasStdSPSOverrides;
+    VkBool32 hasStdPPSOverrides;
+
+    safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR(const VkVideoEncodeH264SessionParametersFeedbackInfoKHR* in_struct,
+                                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR(const safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR& copy_src);
+    safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR& operator=(
+        const safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR& copy_src);
+    safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR();
+    ~safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR();
+    void initialize(const VkVideoEncodeH264SessionParametersFeedbackInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH264SessionParametersFeedbackInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoEncodeH264SessionParametersFeedbackInfoKHR*>(this);
+    }
+    VkVideoEncodeH264SessionParametersFeedbackInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH264SessionParametersFeedbackInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeH264NaluSliceInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    int32_t constantQp;
+    const StdVideoEncodeH264SliceHeader* pStdSliceHeader{};
+
+    safe_VkVideoEncodeH264NaluSliceInfoKHR(const VkVideoEncodeH264NaluSliceInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                           bool copy_pnext = true);
+    safe_VkVideoEncodeH264NaluSliceInfoKHR(const safe_VkVideoEncodeH264NaluSliceInfoKHR& copy_src);
+    safe_VkVideoEncodeH264NaluSliceInfoKHR& operator=(const safe_VkVideoEncodeH264NaluSliceInfoKHR& copy_src);
+    safe_VkVideoEncodeH264NaluSliceInfoKHR();
+    ~safe_VkVideoEncodeH264NaluSliceInfoKHR();
+    void initialize(const VkVideoEncodeH264NaluSliceInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeH264NaluSliceInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH264NaluSliceInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH264NaluSliceInfoKHR*>(this); }
+    VkVideoEncodeH264NaluSliceInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH264NaluSliceInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeH264PictureInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t naluSliceEntryCount;
+    safe_VkVideoEncodeH264NaluSliceInfoKHR* pNaluSliceEntries{};
+    const StdVideoEncodeH264PictureInfo* pStdPictureInfo{};
+    VkBool32 generatePrefixNalu;
+
+    safe_VkVideoEncodeH264PictureInfoKHR(const VkVideoEncodeH264PictureInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkVideoEncodeH264PictureInfoKHR(const safe_VkVideoEncodeH264PictureInfoKHR& copy_src);
+    safe_VkVideoEncodeH264PictureInfoKHR& operator=(const safe_VkVideoEncodeH264PictureInfoKHR& copy_src);
+    safe_VkVideoEncodeH264PictureInfoKHR();
+    ~safe_VkVideoEncodeH264PictureInfoKHR();
+    void initialize(const VkVideoEncodeH264PictureInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeH264PictureInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH264PictureInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH264PictureInfoKHR*>(this); }
+    VkVideoEncodeH264PictureInfoKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeH264PictureInfoKHR const*>(this); }
+};
+struct safe_VkVideoEncodeH264DpbSlotInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    const StdVideoEncodeH264ReferenceInfo* pStdReferenceInfo{};
+
+    safe_VkVideoEncodeH264DpbSlotInfoKHR(const VkVideoEncodeH264DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkVideoEncodeH264DpbSlotInfoKHR(const safe_VkVideoEncodeH264DpbSlotInfoKHR& copy_src);
+    safe_VkVideoEncodeH264DpbSlotInfoKHR& operator=(const safe_VkVideoEncodeH264DpbSlotInfoKHR& copy_src);
+    safe_VkVideoEncodeH264DpbSlotInfoKHR();
+    ~safe_VkVideoEncodeH264DpbSlotInfoKHR();
+    void initialize(const VkVideoEncodeH264DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeH264DpbSlotInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH264DpbSlotInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH264DpbSlotInfoKHR*>(this); }
+    VkVideoEncodeH264DpbSlotInfoKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeH264DpbSlotInfoKHR const*>(this); }
+};
+struct safe_VkVideoEncodeH264ProfileInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    StdVideoH264ProfileIdc stdProfileIdc;
+
+    safe_VkVideoEncodeH264ProfileInfoKHR(const VkVideoEncodeH264ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkVideoEncodeH264ProfileInfoKHR(const safe_VkVideoEncodeH264ProfileInfoKHR& copy_src);
+    safe_VkVideoEncodeH264ProfileInfoKHR& operator=(const safe_VkVideoEncodeH264ProfileInfoKHR& copy_src);
+    safe_VkVideoEncodeH264ProfileInfoKHR();
+    ~safe_VkVideoEncodeH264ProfileInfoKHR();
+    void initialize(const VkVideoEncodeH264ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeH264ProfileInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH264ProfileInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH264ProfileInfoKHR*>(this); }
+    VkVideoEncodeH264ProfileInfoKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeH264ProfileInfoKHR const*>(this); }
+};
+struct safe_VkVideoEncodeH264RateControlInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkVideoEncodeH264RateControlFlagsKHR flags;
+    uint32_t gopFrameCount;
+    uint32_t idrPeriod;
+    uint32_t consecutiveBFrameCount;
+    uint32_t temporalLayerCount;
+
+    safe_VkVideoEncodeH264RateControlInfoKHR(const VkVideoEncodeH264RateControlInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkVideoEncodeH264RateControlInfoKHR(const safe_VkVideoEncodeH264RateControlInfoKHR& copy_src);
+    safe_VkVideoEncodeH264RateControlInfoKHR& operator=(const safe_VkVideoEncodeH264RateControlInfoKHR& copy_src);
+    safe_VkVideoEncodeH264RateControlInfoKHR();
+    ~safe_VkVideoEncodeH264RateControlInfoKHR();
+    void initialize(const VkVideoEncodeH264RateControlInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeH264RateControlInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH264RateControlInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH264RateControlInfoKHR*>(this); }
+    VkVideoEncodeH264RateControlInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH264RateControlInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeH264RateControlLayerInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 useMinQp;
+    VkVideoEncodeH264QpKHR minQp;
+    VkBool32 useMaxQp;
+    VkVideoEncodeH264QpKHR maxQp;
+    VkBool32 useMaxFrameSize;
+    VkVideoEncodeH264FrameSizeKHR maxFrameSize;
+
+    safe_VkVideoEncodeH264RateControlLayerInfoKHR(const VkVideoEncodeH264RateControlLayerInfoKHR* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEncodeH264RateControlLayerInfoKHR(const safe_VkVideoEncodeH264RateControlLayerInfoKHR& copy_src);
+    safe_VkVideoEncodeH264RateControlLayerInfoKHR& operator=(const safe_VkVideoEncodeH264RateControlLayerInfoKHR& copy_src);
+    safe_VkVideoEncodeH264RateControlLayerInfoKHR();
+    ~safe_VkVideoEncodeH264RateControlLayerInfoKHR();
+    void initialize(const VkVideoEncodeH264RateControlLayerInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeH264RateControlLayerInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH264RateControlLayerInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH264RateControlLayerInfoKHR*>(this); }
+    VkVideoEncodeH264RateControlLayerInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH264RateControlLayerInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeH264GopRemainingFrameInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 useGopRemainingFrames;
+    uint32_t gopRemainingI;
+    uint32_t gopRemainingP;
+    uint32_t gopRemainingB;
+
+    safe_VkVideoEncodeH264GopRemainingFrameInfoKHR(const VkVideoEncodeH264GopRemainingFrameInfoKHR* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEncodeH264GopRemainingFrameInfoKHR(const safe_VkVideoEncodeH264GopRemainingFrameInfoKHR& copy_src);
+    safe_VkVideoEncodeH264GopRemainingFrameInfoKHR& operator=(const safe_VkVideoEncodeH264GopRemainingFrameInfoKHR& copy_src);
+    safe_VkVideoEncodeH264GopRemainingFrameInfoKHR();
+    ~safe_VkVideoEncodeH264GopRemainingFrameInfoKHR();
+    void initialize(const VkVideoEncodeH264GopRemainingFrameInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeH264GopRemainingFrameInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH264GopRemainingFrameInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH264GopRemainingFrameInfoKHR*>(this); }
+    VkVideoEncodeH264GopRemainingFrameInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH264GopRemainingFrameInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeH265CapabilitiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkVideoEncodeH265CapabilityFlagsKHR flags;
+    StdVideoH265LevelIdc maxLevelIdc;
+    uint32_t maxSliceSegmentCount;
+    VkExtent2D maxTiles;
+    VkVideoEncodeH265CtbSizeFlagsKHR ctbSizes;
+    VkVideoEncodeH265TransformBlockSizeFlagsKHR transformBlockSizes;
+    uint32_t maxPPictureL0ReferenceCount;
+    uint32_t maxBPictureL0ReferenceCount;
+    uint32_t maxL1ReferenceCount;
+    uint32_t maxSubLayerCount;
+    VkBool32 expectDyadicTemporalSubLayerPattern;
+    int32_t minQp;
+    int32_t maxQp;
+    VkBool32 prefersGopRemainingFrames;
+    VkBool32 requiresGopRemainingFrames;
+    VkVideoEncodeH265StdFlagsKHR stdSyntaxFlags;
+
+    safe_VkVideoEncodeH265CapabilitiesKHR(const VkVideoEncodeH265CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkVideoEncodeH265CapabilitiesKHR(const safe_VkVideoEncodeH265CapabilitiesKHR& copy_src);
+    safe_VkVideoEncodeH265CapabilitiesKHR& operator=(const safe_VkVideoEncodeH265CapabilitiesKHR& copy_src);
+    safe_VkVideoEncodeH265CapabilitiesKHR();
+    ~safe_VkVideoEncodeH265CapabilitiesKHR();
+    void initialize(const VkVideoEncodeH265CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeH265CapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH265CapabilitiesKHR* ptr() { return reinterpret_cast<VkVideoEncodeH265CapabilitiesKHR*>(this); }
+    VkVideoEncodeH265CapabilitiesKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeH265CapabilitiesKHR const*>(this); }
+};
+struct safe_VkVideoEncodeH265SessionCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 useMaxLevelIdc;
+    StdVideoH265LevelIdc maxLevelIdc;
+
+    safe_VkVideoEncodeH265SessionCreateInfoKHR(const VkVideoEncodeH265SessionCreateInfoKHR* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEncodeH265SessionCreateInfoKHR(const safe_VkVideoEncodeH265SessionCreateInfoKHR& copy_src);
+    safe_VkVideoEncodeH265SessionCreateInfoKHR& operator=(const safe_VkVideoEncodeH265SessionCreateInfoKHR& copy_src);
+    safe_VkVideoEncodeH265SessionCreateInfoKHR();
+    ~safe_VkVideoEncodeH265SessionCreateInfoKHR();
+    void initialize(const VkVideoEncodeH265SessionCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeH265SessionCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH265SessionCreateInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH265SessionCreateInfoKHR*>(this); }
+    VkVideoEncodeH265SessionCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH265SessionCreateInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeH265QualityLevelPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkVideoEncodeH265RateControlFlagsKHR preferredRateControlFlags;
+    uint32_t preferredGopFrameCount;
+    uint32_t preferredIdrPeriod;
+    uint32_t preferredConsecutiveBFrameCount;
+    uint32_t preferredSubLayerCount;
+    VkVideoEncodeH265QpKHR preferredConstantQp;
+    uint32_t preferredMaxL0ReferenceCount;
+    uint32_t preferredMaxL1ReferenceCount;
+
+    safe_VkVideoEncodeH265QualityLevelPropertiesKHR(const VkVideoEncodeH265QualityLevelPropertiesKHR* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEncodeH265QualityLevelPropertiesKHR(const safe_VkVideoEncodeH265QualityLevelPropertiesKHR& copy_src);
+    safe_VkVideoEncodeH265QualityLevelPropertiesKHR& operator=(const safe_VkVideoEncodeH265QualityLevelPropertiesKHR& copy_src);
+    safe_VkVideoEncodeH265QualityLevelPropertiesKHR();
+    ~safe_VkVideoEncodeH265QualityLevelPropertiesKHR();
+    void initialize(const VkVideoEncodeH265QualityLevelPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeH265QualityLevelPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH265QualityLevelPropertiesKHR* ptr() {
+        return reinterpret_cast<VkVideoEncodeH265QualityLevelPropertiesKHR*>(this);
+    }
+    VkVideoEncodeH265QualityLevelPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH265QualityLevelPropertiesKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeH265SessionParametersAddInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t stdVPSCount;
+    const StdVideoH265VideoParameterSet* pStdVPSs{};
+    uint32_t stdSPSCount;
+    const StdVideoH265SequenceParameterSet* pStdSPSs{};
+    uint32_t stdPPSCount;
+    const StdVideoH265PictureParameterSet* pStdPPSs{};
+
+    safe_VkVideoEncodeH265SessionParametersAddInfoKHR(const VkVideoEncodeH265SessionParametersAddInfoKHR* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEncodeH265SessionParametersAddInfoKHR(const safe_VkVideoEncodeH265SessionParametersAddInfoKHR& copy_src);
+    safe_VkVideoEncodeH265SessionParametersAddInfoKHR& operator=(const safe_VkVideoEncodeH265SessionParametersAddInfoKHR& copy_src);
+    safe_VkVideoEncodeH265SessionParametersAddInfoKHR();
+    ~safe_VkVideoEncodeH265SessionParametersAddInfoKHR();
+    void initialize(const VkVideoEncodeH265SessionParametersAddInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeH265SessionParametersAddInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH265SessionParametersAddInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoEncodeH265SessionParametersAddInfoKHR*>(this);
+    }
+    VkVideoEncodeH265SessionParametersAddInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH265SessionParametersAddInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeH265SessionParametersCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t maxStdVPSCount;
+    uint32_t maxStdSPSCount;
+    uint32_t maxStdPPSCount;
+    safe_VkVideoEncodeH265SessionParametersAddInfoKHR* pParametersAddInfo{};
+
+    safe_VkVideoEncodeH265SessionParametersCreateInfoKHR(const VkVideoEncodeH265SessionParametersCreateInfoKHR* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEncodeH265SessionParametersCreateInfoKHR(const safe_VkVideoEncodeH265SessionParametersCreateInfoKHR& copy_src);
+    safe_VkVideoEncodeH265SessionParametersCreateInfoKHR& operator=(
+        const safe_VkVideoEncodeH265SessionParametersCreateInfoKHR& copy_src);
+    safe_VkVideoEncodeH265SessionParametersCreateInfoKHR();
+    ~safe_VkVideoEncodeH265SessionParametersCreateInfoKHR();
+    void initialize(const VkVideoEncodeH265SessionParametersCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeH265SessionParametersCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH265SessionParametersCreateInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoEncodeH265SessionParametersCreateInfoKHR*>(this);
+    }
+    VkVideoEncodeH265SessionParametersCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH265SessionParametersCreateInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeH265SessionParametersGetInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 writeStdVPS;
+    VkBool32 writeStdSPS;
+    VkBool32 writeStdPPS;
+    uint32_t stdVPSId;
+    uint32_t stdSPSId;
+    uint32_t stdPPSId;
+
+    safe_VkVideoEncodeH265SessionParametersGetInfoKHR(const VkVideoEncodeH265SessionParametersGetInfoKHR* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEncodeH265SessionParametersGetInfoKHR(const safe_VkVideoEncodeH265SessionParametersGetInfoKHR& copy_src);
+    safe_VkVideoEncodeH265SessionParametersGetInfoKHR& operator=(const safe_VkVideoEncodeH265SessionParametersGetInfoKHR& copy_src);
+    safe_VkVideoEncodeH265SessionParametersGetInfoKHR();
+    ~safe_VkVideoEncodeH265SessionParametersGetInfoKHR();
+    void initialize(const VkVideoEncodeH265SessionParametersGetInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeH265SessionParametersGetInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH265SessionParametersGetInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoEncodeH265SessionParametersGetInfoKHR*>(this);
+    }
+    VkVideoEncodeH265SessionParametersGetInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH265SessionParametersGetInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 hasStdVPSOverrides;
+    VkBool32 hasStdSPSOverrides;
+    VkBool32 hasStdPPSOverrides;
+
+    safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR(const VkVideoEncodeH265SessionParametersFeedbackInfoKHR* in_struct,
+                                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR(const safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR& copy_src);
+    safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR& operator=(
+        const safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR& copy_src);
+    safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR();
+    ~safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR();
+    void initialize(const VkVideoEncodeH265SessionParametersFeedbackInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH265SessionParametersFeedbackInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoEncodeH265SessionParametersFeedbackInfoKHR*>(this);
+    }
+    VkVideoEncodeH265SessionParametersFeedbackInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH265SessionParametersFeedbackInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    int32_t constantQp;
+    const StdVideoEncodeH265SliceSegmentHeader* pStdSliceSegmentHeader{};
+
+    safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR(const VkVideoEncodeH265NaluSliceSegmentInfoKHR* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR(const safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR& copy_src);
+    safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR& operator=(const safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR& copy_src);
+    safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR();
+    ~safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR();
+    void initialize(const VkVideoEncodeH265NaluSliceSegmentInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH265NaluSliceSegmentInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH265NaluSliceSegmentInfoKHR*>(this); }
+    VkVideoEncodeH265NaluSliceSegmentInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH265NaluSliceSegmentInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeH265PictureInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t naluSliceSegmentEntryCount;
+    safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR* pNaluSliceSegmentEntries{};
+    const StdVideoEncodeH265PictureInfo* pStdPictureInfo{};
+
+    safe_VkVideoEncodeH265PictureInfoKHR(const VkVideoEncodeH265PictureInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkVideoEncodeH265PictureInfoKHR(const safe_VkVideoEncodeH265PictureInfoKHR& copy_src);
+    safe_VkVideoEncodeH265PictureInfoKHR& operator=(const safe_VkVideoEncodeH265PictureInfoKHR& copy_src);
+    safe_VkVideoEncodeH265PictureInfoKHR();
+    ~safe_VkVideoEncodeH265PictureInfoKHR();
+    void initialize(const VkVideoEncodeH265PictureInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeH265PictureInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH265PictureInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH265PictureInfoKHR*>(this); }
+    VkVideoEncodeH265PictureInfoKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeH265PictureInfoKHR const*>(this); }
+};
+struct safe_VkVideoEncodeH265DpbSlotInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    const StdVideoEncodeH265ReferenceInfo* pStdReferenceInfo{};
+
+    safe_VkVideoEncodeH265DpbSlotInfoKHR(const VkVideoEncodeH265DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkVideoEncodeH265DpbSlotInfoKHR(const safe_VkVideoEncodeH265DpbSlotInfoKHR& copy_src);
+    safe_VkVideoEncodeH265DpbSlotInfoKHR& operator=(const safe_VkVideoEncodeH265DpbSlotInfoKHR& copy_src);
+    safe_VkVideoEncodeH265DpbSlotInfoKHR();
+    ~safe_VkVideoEncodeH265DpbSlotInfoKHR();
+    void initialize(const VkVideoEncodeH265DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeH265DpbSlotInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH265DpbSlotInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH265DpbSlotInfoKHR*>(this); }
+    VkVideoEncodeH265DpbSlotInfoKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeH265DpbSlotInfoKHR const*>(this); }
+};
+struct safe_VkVideoEncodeH265ProfileInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    StdVideoH265ProfileIdc stdProfileIdc;
+
+    safe_VkVideoEncodeH265ProfileInfoKHR(const VkVideoEncodeH265ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkVideoEncodeH265ProfileInfoKHR(const safe_VkVideoEncodeH265ProfileInfoKHR& copy_src);
+    safe_VkVideoEncodeH265ProfileInfoKHR& operator=(const safe_VkVideoEncodeH265ProfileInfoKHR& copy_src);
+    safe_VkVideoEncodeH265ProfileInfoKHR();
+    ~safe_VkVideoEncodeH265ProfileInfoKHR();
+    void initialize(const VkVideoEncodeH265ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeH265ProfileInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH265ProfileInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH265ProfileInfoKHR*>(this); }
+    VkVideoEncodeH265ProfileInfoKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeH265ProfileInfoKHR const*>(this); }
+};
+struct safe_VkVideoEncodeH265RateControlInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkVideoEncodeH265RateControlFlagsKHR flags;
+    uint32_t gopFrameCount;
+    uint32_t idrPeriod;
+    uint32_t consecutiveBFrameCount;
+    uint32_t subLayerCount;
+
+    safe_VkVideoEncodeH265RateControlInfoKHR(const VkVideoEncodeH265RateControlInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkVideoEncodeH265RateControlInfoKHR(const safe_VkVideoEncodeH265RateControlInfoKHR& copy_src);
+    safe_VkVideoEncodeH265RateControlInfoKHR& operator=(const safe_VkVideoEncodeH265RateControlInfoKHR& copy_src);
+    safe_VkVideoEncodeH265RateControlInfoKHR();
+    ~safe_VkVideoEncodeH265RateControlInfoKHR();
+    void initialize(const VkVideoEncodeH265RateControlInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeH265RateControlInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH265RateControlInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH265RateControlInfoKHR*>(this); }
+    VkVideoEncodeH265RateControlInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH265RateControlInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeH265RateControlLayerInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 useMinQp;
+    VkVideoEncodeH265QpKHR minQp;
+    VkBool32 useMaxQp;
+    VkVideoEncodeH265QpKHR maxQp;
+    VkBool32 useMaxFrameSize;
+    VkVideoEncodeH265FrameSizeKHR maxFrameSize;
+
+    safe_VkVideoEncodeH265RateControlLayerInfoKHR(const VkVideoEncodeH265RateControlLayerInfoKHR* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEncodeH265RateControlLayerInfoKHR(const safe_VkVideoEncodeH265RateControlLayerInfoKHR& copy_src);
+    safe_VkVideoEncodeH265RateControlLayerInfoKHR& operator=(const safe_VkVideoEncodeH265RateControlLayerInfoKHR& copy_src);
+    safe_VkVideoEncodeH265RateControlLayerInfoKHR();
+    ~safe_VkVideoEncodeH265RateControlLayerInfoKHR();
+    void initialize(const VkVideoEncodeH265RateControlLayerInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeH265RateControlLayerInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH265RateControlLayerInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH265RateControlLayerInfoKHR*>(this); }
+    VkVideoEncodeH265RateControlLayerInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH265RateControlLayerInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeH265GopRemainingFrameInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 useGopRemainingFrames;
+    uint32_t gopRemainingI;
+    uint32_t gopRemainingP;
+    uint32_t gopRemainingB;
+
+    safe_VkVideoEncodeH265GopRemainingFrameInfoKHR(const VkVideoEncodeH265GopRemainingFrameInfoKHR* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEncodeH265GopRemainingFrameInfoKHR(const safe_VkVideoEncodeH265GopRemainingFrameInfoKHR& copy_src);
+    safe_VkVideoEncodeH265GopRemainingFrameInfoKHR& operator=(const safe_VkVideoEncodeH265GopRemainingFrameInfoKHR& copy_src);
+    safe_VkVideoEncodeH265GopRemainingFrameInfoKHR();
+    ~safe_VkVideoEncodeH265GopRemainingFrameInfoKHR();
+    void initialize(const VkVideoEncodeH265GopRemainingFrameInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeH265GopRemainingFrameInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH265GopRemainingFrameInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeH265GopRemainingFrameInfoKHR*>(this); }
+    VkVideoEncodeH265GopRemainingFrameInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH265GopRemainingFrameInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoDecodeH264ProfileInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    StdVideoH264ProfileIdc stdProfileIdc;
+    VkVideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout;
+
+    safe_VkVideoDecodeH264ProfileInfoKHR(const VkVideoDecodeH264ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkVideoDecodeH264ProfileInfoKHR(const safe_VkVideoDecodeH264ProfileInfoKHR& copy_src);
+    safe_VkVideoDecodeH264ProfileInfoKHR& operator=(const safe_VkVideoDecodeH264ProfileInfoKHR& copy_src);
+    safe_VkVideoDecodeH264ProfileInfoKHR();
+    ~safe_VkVideoDecodeH264ProfileInfoKHR();
+    void initialize(const VkVideoDecodeH264ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoDecodeH264ProfileInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeH264ProfileInfoKHR* ptr() { return reinterpret_cast<VkVideoDecodeH264ProfileInfoKHR*>(this); }
+    VkVideoDecodeH264ProfileInfoKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeH264ProfileInfoKHR const*>(this); }
+};
+struct safe_VkVideoDecodeH264CapabilitiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    StdVideoH264LevelIdc maxLevelIdc;
+    VkOffset2D fieldOffsetGranularity;
+
+    safe_VkVideoDecodeH264CapabilitiesKHR(const VkVideoDecodeH264CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkVideoDecodeH264CapabilitiesKHR(const safe_VkVideoDecodeH264CapabilitiesKHR& copy_src);
+    safe_VkVideoDecodeH264CapabilitiesKHR& operator=(const safe_VkVideoDecodeH264CapabilitiesKHR& copy_src);
+    safe_VkVideoDecodeH264CapabilitiesKHR();
+    ~safe_VkVideoDecodeH264CapabilitiesKHR();
+    void initialize(const VkVideoDecodeH264CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoDecodeH264CapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeH264CapabilitiesKHR* ptr() { return reinterpret_cast<VkVideoDecodeH264CapabilitiesKHR*>(this); }
+    VkVideoDecodeH264CapabilitiesKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeH264CapabilitiesKHR const*>(this); }
+};
+struct safe_VkVideoDecodeH264SessionParametersAddInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t stdSPSCount;
+    const StdVideoH264SequenceParameterSet* pStdSPSs{};
+    uint32_t stdPPSCount;
+    const StdVideoH264PictureParameterSet* pStdPPSs{};
+
+    safe_VkVideoDecodeH264SessionParametersAddInfoKHR(const VkVideoDecodeH264SessionParametersAddInfoKHR* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoDecodeH264SessionParametersAddInfoKHR(const safe_VkVideoDecodeH264SessionParametersAddInfoKHR& copy_src);
+    safe_VkVideoDecodeH264SessionParametersAddInfoKHR& operator=(const safe_VkVideoDecodeH264SessionParametersAddInfoKHR& copy_src);
+    safe_VkVideoDecodeH264SessionParametersAddInfoKHR();
+    ~safe_VkVideoDecodeH264SessionParametersAddInfoKHR();
+    void initialize(const VkVideoDecodeH264SessionParametersAddInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoDecodeH264SessionParametersAddInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeH264SessionParametersAddInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoDecodeH264SessionParametersAddInfoKHR*>(this);
+    }
+    VkVideoDecodeH264SessionParametersAddInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoDecodeH264SessionParametersAddInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoDecodeH264SessionParametersCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t maxStdSPSCount;
+    uint32_t maxStdPPSCount;
+    safe_VkVideoDecodeH264SessionParametersAddInfoKHR* pParametersAddInfo{};
+
+    safe_VkVideoDecodeH264SessionParametersCreateInfoKHR(const VkVideoDecodeH264SessionParametersCreateInfoKHR* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoDecodeH264SessionParametersCreateInfoKHR(const safe_VkVideoDecodeH264SessionParametersCreateInfoKHR& copy_src);
+    safe_VkVideoDecodeH264SessionParametersCreateInfoKHR& operator=(
+        const safe_VkVideoDecodeH264SessionParametersCreateInfoKHR& copy_src);
+    safe_VkVideoDecodeH264SessionParametersCreateInfoKHR();
+    ~safe_VkVideoDecodeH264SessionParametersCreateInfoKHR();
+    void initialize(const VkVideoDecodeH264SessionParametersCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoDecodeH264SessionParametersCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeH264SessionParametersCreateInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoDecodeH264SessionParametersCreateInfoKHR*>(this);
+    }
+    VkVideoDecodeH264SessionParametersCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoDecodeH264SessionParametersCreateInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoDecodeH264PictureInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    const StdVideoDecodeH264PictureInfo* pStdPictureInfo{};
+    uint32_t sliceCount;
+    const uint32_t* pSliceOffsets{};
+
+    safe_VkVideoDecodeH264PictureInfoKHR(const VkVideoDecodeH264PictureInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkVideoDecodeH264PictureInfoKHR(const safe_VkVideoDecodeH264PictureInfoKHR& copy_src);
+    safe_VkVideoDecodeH264PictureInfoKHR& operator=(const safe_VkVideoDecodeH264PictureInfoKHR& copy_src);
+    safe_VkVideoDecodeH264PictureInfoKHR();
+    ~safe_VkVideoDecodeH264PictureInfoKHR();
+    void initialize(const VkVideoDecodeH264PictureInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoDecodeH264PictureInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeH264PictureInfoKHR* ptr() { return reinterpret_cast<VkVideoDecodeH264PictureInfoKHR*>(this); }
+    VkVideoDecodeH264PictureInfoKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeH264PictureInfoKHR const*>(this); }
+};
+struct safe_VkVideoDecodeH264DpbSlotInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    const StdVideoDecodeH264ReferenceInfo* pStdReferenceInfo{};
+
+    safe_VkVideoDecodeH264DpbSlotInfoKHR(const VkVideoDecodeH264DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkVideoDecodeH264DpbSlotInfoKHR(const safe_VkVideoDecodeH264DpbSlotInfoKHR& copy_src);
+    safe_VkVideoDecodeH264DpbSlotInfoKHR& operator=(const safe_VkVideoDecodeH264DpbSlotInfoKHR& copy_src);
+    safe_VkVideoDecodeH264DpbSlotInfoKHR();
+    ~safe_VkVideoDecodeH264DpbSlotInfoKHR();
+    void initialize(const VkVideoDecodeH264DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoDecodeH264DpbSlotInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeH264DpbSlotInfoKHR* ptr() { return reinterpret_cast<VkVideoDecodeH264DpbSlotInfoKHR*>(this); }
+    VkVideoDecodeH264DpbSlotInfoKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeH264DpbSlotInfoKHR const*>(this); }
+};
+struct safe_VkRenderingFragmentShadingRateAttachmentInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageView imageView;
+    VkImageLayout imageLayout;
+    VkExtent2D shadingRateAttachmentTexelSize;
+
+    safe_VkRenderingFragmentShadingRateAttachmentInfoKHR(const VkRenderingFragmentShadingRateAttachmentInfoKHR* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkRenderingFragmentShadingRateAttachmentInfoKHR(const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& copy_src);
+    safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& operator=(
+        const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& copy_src);
+    safe_VkRenderingFragmentShadingRateAttachmentInfoKHR();
+    ~safe_VkRenderingFragmentShadingRateAttachmentInfoKHR();
+    void initialize(const VkRenderingFragmentShadingRateAttachmentInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkRenderingFragmentShadingRateAttachmentInfoKHR* ptr() {
+        return reinterpret_cast<VkRenderingFragmentShadingRateAttachmentInfoKHR*>(this);
+    }
+    VkRenderingFragmentShadingRateAttachmentInfoKHR const* ptr() const {
+        return reinterpret_cast<VkRenderingFragmentShadingRateAttachmentInfoKHR const*>(this);
+    }
+};
+struct safe_VkRenderingFragmentDensityMapAttachmentInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageView imageView;
+    VkImageLayout imageLayout;
+
+    safe_VkRenderingFragmentDensityMapAttachmentInfoEXT(const VkRenderingFragmentDensityMapAttachmentInfoEXT* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkRenderingFragmentDensityMapAttachmentInfoEXT(const safe_VkRenderingFragmentDensityMapAttachmentInfoEXT& copy_src);
+    safe_VkRenderingFragmentDensityMapAttachmentInfoEXT& operator=(
+        const safe_VkRenderingFragmentDensityMapAttachmentInfoEXT& copy_src);
+    safe_VkRenderingFragmentDensityMapAttachmentInfoEXT();
+    ~safe_VkRenderingFragmentDensityMapAttachmentInfoEXT();
+    void initialize(const VkRenderingFragmentDensityMapAttachmentInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderingFragmentDensityMapAttachmentInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkRenderingFragmentDensityMapAttachmentInfoEXT* ptr() {
+        return reinterpret_cast<VkRenderingFragmentDensityMapAttachmentInfoEXT*>(this);
+    }
+    VkRenderingFragmentDensityMapAttachmentInfoEXT const* ptr() const {
+        return reinterpret_cast<VkRenderingFragmentDensityMapAttachmentInfoEXT const*>(this);
+    }
+};
+struct safe_VkAttachmentSampleCountInfoAMD {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t colorAttachmentCount;
+    const VkSampleCountFlagBits* pColorAttachmentSamples{};
+    VkSampleCountFlagBits depthStencilAttachmentSamples;
+
+    safe_VkAttachmentSampleCountInfoAMD(const VkAttachmentSampleCountInfoAMD* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkAttachmentSampleCountInfoAMD(const safe_VkAttachmentSampleCountInfoAMD& copy_src);
+    safe_VkAttachmentSampleCountInfoAMD& operator=(const safe_VkAttachmentSampleCountInfoAMD& copy_src);
+    safe_VkAttachmentSampleCountInfoAMD();
+    ~safe_VkAttachmentSampleCountInfoAMD();
+    void initialize(const VkAttachmentSampleCountInfoAMD* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAttachmentSampleCountInfoAMD* copy_src, PNextCopyState* copy_state = {});
+    VkAttachmentSampleCountInfoAMD* ptr() { return reinterpret_cast<VkAttachmentSampleCountInfoAMD*>(this); }
+    VkAttachmentSampleCountInfoAMD const* ptr() const { return reinterpret_cast<VkAttachmentSampleCountInfoAMD const*>(this); }
+};
+struct safe_VkMultiviewPerViewAttributesInfoNVX {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 perViewAttributes;
+    VkBool32 perViewAttributesPositionXOnly;
+
+    safe_VkMultiviewPerViewAttributesInfoNVX(const VkMultiviewPerViewAttributesInfoNVX* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkMultiviewPerViewAttributesInfoNVX(const safe_VkMultiviewPerViewAttributesInfoNVX& copy_src);
+    safe_VkMultiviewPerViewAttributesInfoNVX& operator=(const safe_VkMultiviewPerViewAttributesInfoNVX& copy_src);
+    safe_VkMultiviewPerViewAttributesInfoNVX();
+    ~safe_VkMultiviewPerViewAttributesInfoNVX();
+    void initialize(const VkMultiviewPerViewAttributesInfoNVX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMultiviewPerViewAttributesInfoNVX* copy_src, PNextCopyState* copy_state = {});
+    VkMultiviewPerViewAttributesInfoNVX* ptr() { return reinterpret_cast<VkMultiviewPerViewAttributesInfoNVX*>(this); }
+    VkMultiviewPerViewAttributesInfoNVX const* ptr() const {
+        return reinterpret_cast<VkMultiviewPerViewAttributesInfoNVX const*>(this);
+    }
+};
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+struct safe_VkImportMemoryWin32HandleInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalMemoryHandleTypeFlagBits handleType;
+    HANDLE handle;
+    LPCWSTR name;
+
+    safe_VkImportMemoryWin32HandleInfoKHR(const VkImportMemoryWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkImportMemoryWin32HandleInfoKHR(const safe_VkImportMemoryWin32HandleInfoKHR& copy_src);
+    safe_VkImportMemoryWin32HandleInfoKHR& operator=(const safe_VkImportMemoryWin32HandleInfoKHR& copy_src);
+    safe_VkImportMemoryWin32HandleInfoKHR();
+    ~safe_VkImportMemoryWin32HandleInfoKHR();
+    void initialize(const VkImportMemoryWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImportMemoryWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkImportMemoryWin32HandleInfoKHR* ptr() { return reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(this); }
+    VkImportMemoryWin32HandleInfoKHR const* ptr() const { return reinterpret_cast<VkImportMemoryWin32HandleInfoKHR const*>(this); }
+};
+struct safe_VkExportMemoryWin32HandleInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    const SECURITY_ATTRIBUTES* pAttributes{};
+    DWORD dwAccess;
+    LPCWSTR name;
+
+    safe_VkExportMemoryWin32HandleInfoKHR(const VkExportMemoryWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkExportMemoryWin32HandleInfoKHR(const safe_VkExportMemoryWin32HandleInfoKHR& copy_src);
+    safe_VkExportMemoryWin32HandleInfoKHR& operator=(const safe_VkExportMemoryWin32HandleInfoKHR& copy_src);
+    safe_VkExportMemoryWin32HandleInfoKHR();
+    ~safe_VkExportMemoryWin32HandleInfoKHR();
+    void initialize(const VkExportMemoryWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExportMemoryWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkExportMemoryWin32HandleInfoKHR* ptr() { return reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(this); }
+    VkExportMemoryWin32HandleInfoKHR const* ptr() const { return reinterpret_cast<VkExportMemoryWin32HandleInfoKHR const*>(this); }
+};
+struct safe_VkMemoryWin32HandlePropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t memoryTypeBits;
+
+    safe_VkMemoryWin32HandlePropertiesKHR(const VkMemoryWin32HandlePropertiesKHR* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkMemoryWin32HandlePropertiesKHR(const safe_VkMemoryWin32HandlePropertiesKHR& copy_src);
+    safe_VkMemoryWin32HandlePropertiesKHR& operator=(const safe_VkMemoryWin32HandlePropertiesKHR& copy_src);
+    safe_VkMemoryWin32HandlePropertiesKHR();
+    ~safe_VkMemoryWin32HandlePropertiesKHR();
+    void initialize(const VkMemoryWin32HandlePropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMemoryWin32HandlePropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryWin32HandlePropertiesKHR* ptr() { return reinterpret_cast<VkMemoryWin32HandlePropertiesKHR*>(this); }
+    VkMemoryWin32HandlePropertiesKHR const* ptr() const { return reinterpret_cast<VkMemoryWin32HandlePropertiesKHR const*>(this); }
+};
+struct safe_VkMemoryGetWin32HandleInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceMemory memory;
+    VkExternalMemoryHandleTypeFlagBits handleType;
+
+    safe_VkMemoryGetWin32HandleInfoKHR(const VkMemoryGetWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    safe_VkMemoryGetWin32HandleInfoKHR(const safe_VkMemoryGetWin32HandleInfoKHR& copy_src);
+    safe_VkMemoryGetWin32HandleInfoKHR& operator=(const safe_VkMemoryGetWin32HandleInfoKHR& copy_src);
+    safe_VkMemoryGetWin32HandleInfoKHR();
+    ~safe_VkMemoryGetWin32HandleInfoKHR();
+    void initialize(const VkMemoryGetWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMemoryGetWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryGetWin32HandleInfoKHR* ptr() { return reinterpret_cast<VkMemoryGetWin32HandleInfoKHR*>(this); }
+    VkMemoryGetWin32HandleInfoKHR const* ptr() const { return reinterpret_cast<VkMemoryGetWin32HandleInfoKHR const*>(this); }
+};
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+struct safe_VkImportMemoryFdInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalMemoryHandleTypeFlagBits handleType;
+    int fd;
+
+    safe_VkImportMemoryFdInfoKHR(const VkImportMemoryFdInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkImportMemoryFdInfoKHR(const safe_VkImportMemoryFdInfoKHR& copy_src);
+    safe_VkImportMemoryFdInfoKHR& operator=(const safe_VkImportMemoryFdInfoKHR& copy_src);
+    safe_VkImportMemoryFdInfoKHR();
+    ~safe_VkImportMemoryFdInfoKHR();
+    void initialize(const VkImportMemoryFdInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImportMemoryFdInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkImportMemoryFdInfoKHR* ptr() { return reinterpret_cast<VkImportMemoryFdInfoKHR*>(this); }
+    VkImportMemoryFdInfoKHR const* ptr() const { return reinterpret_cast<VkImportMemoryFdInfoKHR const*>(this); }
+};
+struct safe_VkMemoryFdPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t memoryTypeBits;
+
+    safe_VkMemoryFdPropertiesKHR(const VkMemoryFdPropertiesKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkMemoryFdPropertiesKHR(const safe_VkMemoryFdPropertiesKHR& copy_src);
+    safe_VkMemoryFdPropertiesKHR& operator=(const safe_VkMemoryFdPropertiesKHR& copy_src);
+    safe_VkMemoryFdPropertiesKHR();
+    ~safe_VkMemoryFdPropertiesKHR();
+    void initialize(const VkMemoryFdPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMemoryFdPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryFdPropertiesKHR* ptr() { return reinterpret_cast<VkMemoryFdPropertiesKHR*>(this); }
+    VkMemoryFdPropertiesKHR const* ptr() const { return reinterpret_cast<VkMemoryFdPropertiesKHR const*>(this); }
+};
+struct safe_VkMemoryGetFdInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceMemory memory;
+    VkExternalMemoryHandleTypeFlagBits handleType;
+
+    safe_VkMemoryGetFdInfoKHR(const VkMemoryGetFdInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkMemoryGetFdInfoKHR(const safe_VkMemoryGetFdInfoKHR& copy_src);
+    safe_VkMemoryGetFdInfoKHR& operator=(const safe_VkMemoryGetFdInfoKHR& copy_src);
+    safe_VkMemoryGetFdInfoKHR();
+    ~safe_VkMemoryGetFdInfoKHR();
+    void initialize(const VkMemoryGetFdInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMemoryGetFdInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryGetFdInfoKHR* ptr() { return reinterpret_cast<VkMemoryGetFdInfoKHR*>(this); }
+    VkMemoryGetFdInfoKHR const* ptr() const { return reinterpret_cast<VkMemoryGetFdInfoKHR const*>(this); }
+};
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+struct safe_VkWin32KeyedMutexAcquireReleaseInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t acquireCount;
+    VkDeviceMemory* pAcquireSyncs{};
+    const uint64_t* pAcquireKeys{};
+    const uint32_t* pAcquireTimeouts{};
+    uint32_t releaseCount;
+    VkDeviceMemory* pReleaseSyncs{};
+    const uint64_t* pReleaseKeys{};
+
+    safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& copy_src);
+    safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& operator=(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& copy_src);
+    safe_VkWin32KeyedMutexAcquireReleaseInfoKHR();
+    ~safe_VkWin32KeyedMutexAcquireReleaseInfoKHR();
+    void initialize(const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkWin32KeyedMutexAcquireReleaseInfoKHR* ptr() { return reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(this); }
+    VkWin32KeyedMutexAcquireReleaseInfoKHR const* ptr() const {
+        return reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR const*>(this);
+    }
+};
+struct safe_VkImportSemaphoreWin32HandleInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSemaphore semaphore;
+    VkSemaphoreImportFlags flags;
+    VkExternalSemaphoreHandleTypeFlagBits handleType;
+    HANDLE handle;
+    LPCWSTR name;
+
+    safe_VkImportSemaphoreWin32HandleInfoKHR(const VkImportSemaphoreWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkImportSemaphoreWin32HandleInfoKHR(const safe_VkImportSemaphoreWin32HandleInfoKHR& copy_src);
+    safe_VkImportSemaphoreWin32HandleInfoKHR& operator=(const safe_VkImportSemaphoreWin32HandleInfoKHR& copy_src);
+    safe_VkImportSemaphoreWin32HandleInfoKHR();
+    ~safe_VkImportSemaphoreWin32HandleInfoKHR();
+    void initialize(const VkImportSemaphoreWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImportSemaphoreWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkImportSemaphoreWin32HandleInfoKHR* ptr() { return reinterpret_cast<VkImportSemaphoreWin32HandleInfoKHR*>(this); }
+    VkImportSemaphoreWin32HandleInfoKHR const* ptr() const {
+        return reinterpret_cast<VkImportSemaphoreWin32HandleInfoKHR const*>(this);
+    }
+};
+struct safe_VkExportSemaphoreWin32HandleInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    const SECURITY_ATTRIBUTES* pAttributes{};
+    DWORD dwAccess;
+    LPCWSTR name;
+
+    safe_VkExportSemaphoreWin32HandleInfoKHR(const VkExportSemaphoreWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkExportSemaphoreWin32HandleInfoKHR(const safe_VkExportSemaphoreWin32HandleInfoKHR& copy_src);
+    safe_VkExportSemaphoreWin32HandleInfoKHR& operator=(const safe_VkExportSemaphoreWin32HandleInfoKHR& copy_src);
+    safe_VkExportSemaphoreWin32HandleInfoKHR();
+    ~safe_VkExportSemaphoreWin32HandleInfoKHR();
+    void initialize(const VkExportSemaphoreWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExportSemaphoreWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkExportSemaphoreWin32HandleInfoKHR* ptr() { return reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(this); }
+    VkExportSemaphoreWin32HandleInfoKHR const* ptr() const {
+        return reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR const*>(this);
+    }
+};
+struct safe_VkD3D12FenceSubmitInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t waitSemaphoreValuesCount;
+    const uint64_t* pWaitSemaphoreValues{};
+    uint32_t signalSemaphoreValuesCount;
+    const uint64_t* pSignalSemaphoreValues{};
+
+    safe_VkD3D12FenceSubmitInfoKHR(const VkD3D12FenceSubmitInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    safe_VkD3D12FenceSubmitInfoKHR(const safe_VkD3D12FenceSubmitInfoKHR& copy_src);
+    safe_VkD3D12FenceSubmitInfoKHR& operator=(const safe_VkD3D12FenceSubmitInfoKHR& copy_src);
+    safe_VkD3D12FenceSubmitInfoKHR();
+    ~safe_VkD3D12FenceSubmitInfoKHR();
+    void initialize(const VkD3D12FenceSubmitInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkD3D12FenceSubmitInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkD3D12FenceSubmitInfoKHR* ptr() { return reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(this); }
+    VkD3D12FenceSubmitInfoKHR const* ptr() const { return reinterpret_cast<VkD3D12FenceSubmitInfoKHR const*>(this); }
+};
+struct safe_VkSemaphoreGetWin32HandleInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSemaphore semaphore;
+    VkExternalSemaphoreHandleTypeFlagBits handleType;
+
+    safe_VkSemaphoreGetWin32HandleInfoKHR(const VkSemaphoreGetWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkSemaphoreGetWin32HandleInfoKHR(const safe_VkSemaphoreGetWin32HandleInfoKHR& copy_src);
+    safe_VkSemaphoreGetWin32HandleInfoKHR& operator=(const safe_VkSemaphoreGetWin32HandleInfoKHR& copy_src);
+    safe_VkSemaphoreGetWin32HandleInfoKHR();
+    ~safe_VkSemaphoreGetWin32HandleInfoKHR();
+    void initialize(const VkSemaphoreGetWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSemaphoreGetWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkSemaphoreGetWin32HandleInfoKHR* ptr() { return reinterpret_cast<VkSemaphoreGetWin32HandleInfoKHR*>(this); }
+    VkSemaphoreGetWin32HandleInfoKHR const* ptr() const { return reinterpret_cast<VkSemaphoreGetWin32HandleInfoKHR const*>(this); }
+};
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+struct safe_VkImportSemaphoreFdInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSemaphore semaphore;
+    VkSemaphoreImportFlags flags;
+    VkExternalSemaphoreHandleTypeFlagBits handleType;
+    int fd;
+
+    safe_VkImportSemaphoreFdInfoKHR(const VkImportSemaphoreFdInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    safe_VkImportSemaphoreFdInfoKHR(const safe_VkImportSemaphoreFdInfoKHR& copy_src);
+    safe_VkImportSemaphoreFdInfoKHR& operator=(const safe_VkImportSemaphoreFdInfoKHR& copy_src);
+    safe_VkImportSemaphoreFdInfoKHR();
+    ~safe_VkImportSemaphoreFdInfoKHR();
+    void initialize(const VkImportSemaphoreFdInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImportSemaphoreFdInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkImportSemaphoreFdInfoKHR* ptr() { return reinterpret_cast<VkImportSemaphoreFdInfoKHR*>(this); }
+    VkImportSemaphoreFdInfoKHR const* ptr() const { return reinterpret_cast<VkImportSemaphoreFdInfoKHR const*>(this); }
+};
+struct safe_VkSemaphoreGetFdInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSemaphore semaphore;
+    VkExternalSemaphoreHandleTypeFlagBits handleType;
+
+    safe_VkSemaphoreGetFdInfoKHR(const VkSemaphoreGetFdInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSemaphoreGetFdInfoKHR(const safe_VkSemaphoreGetFdInfoKHR& copy_src);
+    safe_VkSemaphoreGetFdInfoKHR& operator=(const safe_VkSemaphoreGetFdInfoKHR& copy_src);
+    safe_VkSemaphoreGetFdInfoKHR();
+    ~safe_VkSemaphoreGetFdInfoKHR();
+    void initialize(const VkSemaphoreGetFdInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSemaphoreGetFdInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkSemaphoreGetFdInfoKHR* ptr() { return reinterpret_cast<VkSemaphoreGetFdInfoKHR*>(this); }
+    VkSemaphoreGetFdInfoKHR const* ptr() const { return reinterpret_cast<VkSemaphoreGetFdInfoKHR const*>(this); }
+};
+struct safe_VkPhysicalDevicePushDescriptorPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxPushDescriptors;
+
+    safe_VkPhysicalDevicePushDescriptorPropertiesKHR(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDevicePushDescriptorPropertiesKHR(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& copy_src);
+    safe_VkPhysicalDevicePushDescriptorPropertiesKHR& operator=(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& copy_src);
+    safe_VkPhysicalDevicePushDescriptorPropertiesKHR();
+    ~safe_VkPhysicalDevicePushDescriptorPropertiesKHR();
+    void initialize(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePushDescriptorPropertiesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(this);
+    }
+    VkPhysicalDevicePushDescriptorPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR const*>(this);
+    }
+};
+struct safe_VkPresentRegionKHR {
+    uint32_t rectangleCount;
+    const VkRectLayerKHR* pRectangles{};
+
+    safe_VkPresentRegionKHR(const VkPresentRegionKHR* in_struct, PNextCopyState* copy_state = {});
+    safe_VkPresentRegionKHR(const safe_VkPresentRegionKHR& copy_src);
+    safe_VkPresentRegionKHR& operator=(const safe_VkPresentRegionKHR& copy_src);
+    safe_VkPresentRegionKHR();
+    ~safe_VkPresentRegionKHR();
+    void initialize(const VkPresentRegionKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPresentRegionKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPresentRegionKHR* ptr() { return reinterpret_cast<VkPresentRegionKHR*>(this); }
+    VkPresentRegionKHR const* ptr() const { return reinterpret_cast<VkPresentRegionKHR const*>(this); }
+};
+struct safe_VkPresentRegionsKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t swapchainCount;
+    safe_VkPresentRegionKHR* pRegions{};
+
+    safe_VkPresentRegionsKHR(const VkPresentRegionsKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPresentRegionsKHR(const safe_VkPresentRegionsKHR& copy_src);
+    safe_VkPresentRegionsKHR& operator=(const safe_VkPresentRegionsKHR& copy_src);
+    safe_VkPresentRegionsKHR();
+    ~safe_VkPresentRegionsKHR();
+    void initialize(const VkPresentRegionsKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPresentRegionsKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPresentRegionsKHR* ptr() { return reinterpret_cast<VkPresentRegionsKHR*>(this); }
+    VkPresentRegionsKHR const* ptr() const { return reinterpret_cast<VkPresentRegionsKHR const*>(this); }
+};
+struct safe_VkSharedPresentSurfaceCapabilitiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkImageUsageFlags sharedPresentSupportedUsageFlags;
+
+    safe_VkSharedPresentSurfaceCapabilitiesKHR(const VkSharedPresentSurfaceCapabilitiesKHR* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSharedPresentSurfaceCapabilitiesKHR(const safe_VkSharedPresentSurfaceCapabilitiesKHR& copy_src);
+    safe_VkSharedPresentSurfaceCapabilitiesKHR& operator=(const safe_VkSharedPresentSurfaceCapabilitiesKHR& copy_src);
+    safe_VkSharedPresentSurfaceCapabilitiesKHR();
+    ~safe_VkSharedPresentSurfaceCapabilitiesKHR();
+    void initialize(const VkSharedPresentSurfaceCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSharedPresentSurfaceCapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkSharedPresentSurfaceCapabilitiesKHR* ptr() { return reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(this); }
+    VkSharedPresentSurfaceCapabilitiesKHR const* ptr() const {
+        return reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR const*>(this);
+    }
+};
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+struct safe_VkImportFenceWin32HandleInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkFence fence;
+    VkFenceImportFlags flags;
+    VkExternalFenceHandleTypeFlagBits handleType;
+    HANDLE handle;
+    LPCWSTR name;
+
+    safe_VkImportFenceWin32HandleInfoKHR(const VkImportFenceWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkImportFenceWin32HandleInfoKHR(const safe_VkImportFenceWin32HandleInfoKHR& copy_src);
+    safe_VkImportFenceWin32HandleInfoKHR& operator=(const safe_VkImportFenceWin32HandleInfoKHR& copy_src);
+    safe_VkImportFenceWin32HandleInfoKHR();
+    ~safe_VkImportFenceWin32HandleInfoKHR();
+    void initialize(const VkImportFenceWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImportFenceWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkImportFenceWin32HandleInfoKHR* ptr() { return reinterpret_cast<VkImportFenceWin32HandleInfoKHR*>(this); }
+    VkImportFenceWin32HandleInfoKHR const* ptr() const { return reinterpret_cast<VkImportFenceWin32HandleInfoKHR const*>(this); }
+};
+struct safe_VkExportFenceWin32HandleInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    const SECURITY_ATTRIBUTES* pAttributes{};
+    DWORD dwAccess;
+    LPCWSTR name;
+
+    safe_VkExportFenceWin32HandleInfoKHR(const VkExportFenceWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkExportFenceWin32HandleInfoKHR(const safe_VkExportFenceWin32HandleInfoKHR& copy_src);
+    safe_VkExportFenceWin32HandleInfoKHR& operator=(const safe_VkExportFenceWin32HandleInfoKHR& copy_src);
+    safe_VkExportFenceWin32HandleInfoKHR();
+    ~safe_VkExportFenceWin32HandleInfoKHR();
+    void initialize(const VkExportFenceWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExportFenceWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkExportFenceWin32HandleInfoKHR* ptr() { return reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(this); }
+    VkExportFenceWin32HandleInfoKHR const* ptr() const { return reinterpret_cast<VkExportFenceWin32HandleInfoKHR const*>(this); }
+};
+struct safe_VkFenceGetWin32HandleInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkFence fence;
+    VkExternalFenceHandleTypeFlagBits handleType;
+
+    safe_VkFenceGetWin32HandleInfoKHR(const VkFenceGetWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    safe_VkFenceGetWin32HandleInfoKHR(const safe_VkFenceGetWin32HandleInfoKHR& copy_src);
+    safe_VkFenceGetWin32HandleInfoKHR& operator=(const safe_VkFenceGetWin32HandleInfoKHR& copy_src);
+    safe_VkFenceGetWin32HandleInfoKHR();
+    ~safe_VkFenceGetWin32HandleInfoKHR();
+    void initialize(const VkFenceGetWin32HandleInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkFenceGetWin32HandleInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkFenceGetWin32HandleInfoKHR* ptr() { return reinterpret_cast<VkFenceGetWin32HandleInfoKHR*>(this); }
+    VkFenceGetWin32HandleInfoKHR const* ptr() const { return reinterpret_cast<VkFenceGetWin32HandleInfoKHR const*>(this); }
+};
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+struct safe_VkImportFenceFdInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkFence fence;
+    VkFenceImportFlags flags;
+    VkExternalFenceHandleTypeFlagBits handleType;
+    int fd;
+
+    safe_VkImportFenceFdInfoKHR(const VkImportFenceFdInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkImportFenceFdInfoKHR(const safe_VkImportFenceFdInfoKHR& copy_src);
+    safe_VkImportFenceFdInfoKHR& operator=(const safe_VkImportFenceFdInfoKHR& copy_src);
+    safe_VkImportFenceFdInfoKHR();
+    ~safe_VkImportFenceFdInfoKHR();
+    void initialize(const VkImportFenceFdInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImportFenceFdInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkImportFenceFdInfoKHR* ptr() { return reinterpret_cast<VkImportFenceFdInfoKHR*>(this); }
+    VkImportFenceFdInfoKHR const* ptr() const { return reinterpret_cast<VkImportFenceFdInfoKHR const*>(this); }
+};
+struct safe_VkFenceGetFdInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkFence fence;
+    VkExternalFenceHandleTypeFlagBits handleType;
+
+    safe_VkFenceGetFdInfoKHR(const VkFenceGetFdInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkFenceGetFdInfoKHR(const safe_VkFenceGetFdInfoKHR& copy_src);
+    safe_VkFenceGetFdInfoKHR& operator=(const safe_VkFenceGetFdInfoKHR& copy_src);
+    safe_VkFenceGetFdInfoKHR();
+    ~safe_VkFenceGetFdInfoKHR();
+    void initialize(const VkFenceGetFdInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkFenceGetFdInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkFenceGetFdInfoKHR* ptr() { return reinterpret_cast<VkFenceGetFdInfoKHR*>(this); }
+    VkFenceGetFdInfoKHR const* ptr() const { return reinterpret_cast<VkFenceGetFdInfoKHR const*>(this); }
+};
+struct safe_VkPhysicalDevicePerformanceQueryFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 performanceCounterQueryPools;
+    VkBool32 performanceCounterMultipleQueryPools;
+
+    safe_VkPhysicalDevicePerformanceQueryFeaturesKHR(const VkPhysicalDevicePerformanceQueryFeaturesKHR* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDevicePerformanceQueryFeaturesKHR(const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& copy_src);
+    safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& operator=(const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& copy_src);
+    safe_VkPhysicalDevicePerformanceQueryFeaturesKHR();
+    ~safe_VkPhysicalDevicePerformanceQueryFeaturesKHR();
+    void initialize(const VkPhysicalDevicePerformanceQueryFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePerformanceQueryFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR*>(this);
+    }
+    VkPhysicalDevicePerformanceQueryFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDevicePerformanceQueryPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 allowCommandBufferQueryCopies;
+
+    safe_VkPhysicalDevicePerformanceQueryPropertiesKHR(const VkPhysicalDevicePerformanceQueryPropertiesKHR* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDevicePerformanceQueryPropertiesKHR(const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& copy_src);
+    safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& operator=(
+        const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& copy_src);
+    safe_VkPhysicalDevicePerformanceQueryPropertiesKHR();
+    ~safe_VkPhysicalDevicePerformanceQueryPropertiesKHR();
+    void initialize(const VkPhysicalDevicePerformanceQueryPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePerformanceQueryPropertiesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePerformanceQueryPropertiesKHR*>(this);
+    }
+    VkPhysicalDevicePerformanceQueryPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePerformanceQueryPropertiesKHR const*>(this);
+    }
+};
+struct safe_VkPerformanceCounterKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkPerformanceCounterUnitKHR unit;
+    VkPerformanceCounterScopeKHR scope;
+    VkPerformanceCounterStorageKHR storage;
+    uint8_t uuid[VK_UUID_SIZE];
+
+    safe_VkPerformanceCounterKHR(const VkPerformanceCounterKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPerformanceCounterKHR(const safe_VkPerformanceCounterKHR& copy_src);
+    safe_VkPerformanceCounterKHR& operator=(const safe_VkPerformanceCounterKHR& copy_src);
+    safe_VkPerformanceCounterKHR();
+    ~safe_VkPerformanceCounterKHR();
+    void initialize(const VkPerformanceCounterKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPerformanceCounterKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPerformanceCounterKHR* ptr() { return reinterpret_cast<VkPerformanceCounterKHR*>(this); }
+    VkPerformanceCounterKHR const* ptr() const { return reinterpret_cast<VkPerformanceCounterKHR const*>(this); }
+};
+struct safe_VkPerformanceCounterDescriptionKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkPerformanceCounterDescriptionFlagsKHR flags;
+    char name[VK_MAX_DESCRIPTION_SIZE];
+    char category[VK_MAX_DESCRIPTION_SIZE];
+    char description[VK_MAX_DESCRIPTION_SIZE];
+
+    safe_VkPerformanceCounterDescriptionKHR(const VkPerformanceCounterDescriptionKHR* in_struct, PNextCopyState* copy_state = {},
+                                            bool copy_pnext = true);
+    safe_VkPerformanceCounterDescriptionKHR(const safe_VkPerformanceCounterDescriptionKHR& copy_src);
+    safe_VkPerformanceCounterDescriptionKHR& operator=(const safe_VkPerformanceCounterDescriptionKHR& copy_src);
+    safe_VkPerformanceCounterDescriptionKHR();
+    ~safe_VkPerformanceCounterDescriptionKHR();
+    void initialize(const VkPerformanceCounterDescriptionKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPerformanceCounterDescriptionKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPerformanceCounterDescriptionKHR* ptr() { return reinterpret_cast<VkPerformanceCounterDescriptionKHR*>(this); }
+    VkPerformanceCounterDescriptionKHR const* ptr() const {
+        return reinterpret_cast<VkPerformanceCounterDescriptionKHR const*>(this);
+    }
+};
+struct safe_VkQueryPoolPerformanceCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t queueFamilyIndex;
+    uint32_t counterIndexCount;
+    const uint32_t* pCounterIndices{};
+
+    safe_VkQueryPoolPerformanceCreateInfoKHR(const VkQueryPoolPerformanceCreateInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkQueryPoolPerformanceCreateInfoKHR(const safe_VkQueryPoolPerformanceCreateInfoKHR& copy_src);
+    safe_VkQueryPoolPerformanceCreateInfoKHR& operator=(const safe_VkQueryPoolPerformanceCreateInfoKHR& copy_src);
+    safe_VkQueryPoolPerformanceCreateInfoKHR();
+    ~safe_VkQueryPoolPerformanceCreateInfoKHR();
+    void initialize(const VkQueryPoolPerformanceCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkQueryPoolPerformanceCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkQueryPoolPerformanceCreateInfoKHR* ptr() { return reinterpret_cast<VkQueryPoolPerformanceCreateInfoKHR*>(this); }
+    VkQueryPoolPerformanceCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkQueryPoolPerformanceCreateInfoKHR const*>(this);
+    }
+};
+struct safe_VkAcquireProfilingLockInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAcquireProfilingLockFlagsKHR flags;
+    uint64_t timeout;
+
+    safe_VkAcquireProfilingLockInfoKHR(const VkAcquireProfilingLockInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    safe_VkAcquireProfilingLockInfoKHR(const safe_VkAcquireProfilingLockInfoKHR& copy_src);
+    safe_VkAcquireProfilingLockInfoKHR& operator=(const safe_VkAcquireProfilingLockInfoKHR& copy_src);
+    safe_VkAcquireProfilingLockInfoKHR();
+    ~safe_VkAcquireProfilingLockInfoKHR();
+    void initialize(const VkAcquireProfilingLockInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAcquireProfilingLockInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkAcquireProfilingLockInfoKHR* ptr() { return reinterpret_cast<VkAcquireProfilingLockInfoKHR*>(this); }
+    VkAcquireProfilingLockInfoKHR const* ptr() const { return reinterpret_cast<VkAcquireProfilingLockInfoKHR const*>(this); }
+};
+struct safe_VkPerformanceQuerySubmitInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t counterPassIndex;
+
+    safe_VkPerformanceQuerySubmitInfoKHR(const VkPerformanceQuerySubmitInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkPerformanceQuerySubmitInfoKHR(const safe_VkPerformanceQuerySubmitInfoKHR& copy_src);
+    safe_VkPerformanceQuerySubmitInfoKHR& operator=(const safe_VkPerformanceQuerySubmitInfoKHR& copy_src);
+    safe_VkPerformanceQuerySubmitInfoKHR();
+    ~safe_VkPerformanceQuerySubmitInfoKHR();
+    void initialize(const VkPerformanceQuerySubmitInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPerformanceQuerySubmitInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPerformanceQuerySubmitInfoKHR* ptr() { return reinterpret_cast<VkPerformanceQuerySubmitInfoKHR*>(this); }
+    VkPerformanceQuerySubmitInfoKHR const* ptr() const { return reinterpret_cast<VkPerformanceQuerySubmitInfoKHR const*>(this); }
+};
+struct safe_VkPhysicalDeviceSurfaceInfo2KHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSurfaceKHR surface;
+
+    safe_VkPhysicalDeviceSurfaceInfo2KHR(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkPhysicalDeviceSurfaceInfo2KHR(const safe_VkPhysicalDeviceSurfaceInfo2KHR& copy_src);
+    safe_VkPhysicalDeviceSurfaceInfo2KHR& operator=(const safe_VkPhysicalDeviceSurfaceInfo2KHR& copy_src);
+    safe_VkPhysicalDeviceSurfaceInfo2KHR();
+    ~safe_VkPhysicalDeviceSurfaceInfo2KHR();
+    void initialize(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceSurfaceInfo2KHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSurfaceInfo2KHR* ptr() { return reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR*>(this); }
+    VkPhysicalDeviceSurfaceInfo2KHR const* ptr() const { return reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR const*>(this); }
+};
+struct safe_VkSurfaceCapabilities2KHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkSurfaceCapabilitiesKHR surfaceCapabilities;
+
+    safe_VkSurfaceCapabilities2KHR(const VkSurfaceCapabilities2KHR* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    safe_VkSurfaceCapabilities2KHR(const safe_VkSurfaceCapabilities2KHR& copy_src);
+    safe_VkSurfaceCapabilities2KHR& operator=(const safe_VkSurfaceCapabilities2KHR& copy_src);
+    safe_VkSurfaceCapabilities2KHR();
+    ~safe_VkSurfaceCapabilities2KHR();
+    void initialize(const VkSurfaceCapabilities2KHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSurfaceCapabilities2KHR* copy_src, PNextCopyState* copy_state = {});
+    VkSurfaceCapabilities2KHR* ptr() { return reinterpret_cast<VkSurfaceCapabilities2KHR*>(this); }
+    VkSurfaceCapabilities2KHR const* ptr() const { return reinterpret_cast<VkSurfaceCapabilities2KHR const*>(this); }
+};
+struct safe_VkSurfaceFormat2KHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkSurfaceFormatKHR surfaceFormat;
+
+    safe_VkSurfaceFormat2KHR(const VkSurfaceFormat2KHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSurfaceFormat2KHR(const safe_VkSurfaceFormat2KHR& copy_src);
+    safe_VkSurfaceFormat2KHR& operator=(const safe_VkSurfaceFormat2KHR& copy_src);
+    safe_VkSurfaceFormat2KHR();
+    ~safe_VkSurfaceFormat2KHR();
+    void initialize(const VkSurfaceFormat2KHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSurfaceFormat2KHR* copy_src, PNextCopyState* copy_state = {});
+    VkSurfaceFormat2KHR* ptr() { return reinterpret_cast<VkSurfaceFormat2KHR*>(this); }
+    VkSurfaceFormat2KHR const* ptr() const { return reinterpret_cast<VkSurfaceFormat2KHR const*>(this); }
+};
+struct safe_VkDisplayProperties2KHR {
+    VkStructureType sType;
+    void* pNext{};
+    safe_VkDisplayPropertiesKHR displayProperties;
+
+    safe_VkDisplayProperties2KHR(const VkDisplayProperties2KHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDisplayProperties2KHR(const safe_VkDisplayProperties2KHR& copy_src);
+    safe_VkDisplayProperties2KHR& operator=(const safe_VkDisplayProperties2KHR& copy_src);
+    safe_VkDisplayProperties2KHR();
+    ~safe_VkDisplayProperties2KHR();
+    void initialize(const VkDisplayProperties2KHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDisplayProperties2KHR* copy_src, PNextCopyState* copy_state = {});
+    VkDisplayProperties2KHR* ptr() { return reinterpret_cast<VkDisplayProperties2KHR*>(this); }
+    VkDisplayProperties2KHR const* ptr() const { return reinterpret_cast<VkDisplayProperties2KHR const*>(this); }
+};
+struct safe_VkDisplayPlaneProperties2KHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkDisplayPlanePropertiesKHR displayPlaneProperties;
+
+    safe_VkDisplayPlaneProperties2KHR(const VkDisplayPlaneProperties2KHR* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    safe_VkDisplayPlaneProperties2KHR(const safe_VkDisplayPlaneProperties2KHR& copy_src);
+    safe_VkDisplayPlaneProperties2KHR& operator=(const safe_VkDisplayPlaneProperties2KHR& copy_src);
+    safe_VkDisplayPlaneProperties2KHR();
+    ~safe_VkDisplayPlaneProperties2KHR();
+    void initialize(const VkDisplayPlaneProperties2KHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDisplayPlaneProperties2KHR* copy_src, PNextCopyState* copy_state = {});
+    VkDisplayPlaneProperties2KHR* ptr() { return reinterpret_cast<VkDisplayPlaneProperties2KHR*>(this); }
+    VkDisplayPlaneProperties2KHR const* ptr() const { return reinterpret_cast<VkDisplayPlaneProperties2KHR const*>(this); }
+};
+struct safe_VkDisplayModeProperties2KHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkDisplayModePropertiesKHR displayModeProperties;
+
+    safe_VkDisplayModeProperties2KHR(const VkDisplayModeProperties2KHR* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    safe_VkDisplayModeProperties2KHR(const safe_VkDisplayModeProperties2KHR& copy_src);
+    safe_VkDisplayModeProperties2KHR& operator=(const safe_VkDisplayModeProperties2KHR& copy_src);
+    safe_VkDisplayModeProperties2KHR();
+    ~safe_VkDisplayModeProperties2KHR();
+    void initialize(const VkDisplayModeProperties2KHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDisplayModeProperties2KHR* copy_src, PNextCopyState* copy_state = {});
+    VkDisplayModeProperties2KHR* ptr() { return reinterpret_cast<VkDisplayModeProperties2KHR*>(this); }
+    VkDisplayModeProperties2KHR const* ptr() const { return reinterpret_cast<VkDisplayModeProperties2KHR const*>(this); }
+};
+struct safe_VkDisplayPlaneInfo2KHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDisplayModeKHR mode;
+    uint32_t planeIndex;
+
+    safe_VkDisplayPlaneInfo2KHR(const VkDisplayPlaneInfo2KHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDisplayPlaneInfo2KHR(const safe_VkDisplayPlaneInfo2KHR& copy_src);
+    safe_VkDisplayPlaneInfo2KHR& operator=(const safe_VkDisplayPlaneInfo2KHR& copy_src);
+    safe_VkDisplayPlaneInfo2KHR();
+    ~safe_VkDisplayPlaneInfo2KHR();
+    void initialize(const VkDisplayPlaneInfo2KHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDisplayPlaneInfo2KHR* copy_src, PNextCopyState* copy_state = {});
+    VkDisplayPlaneInfo2KHR* ptr() { return reinterpret_cast<VkDisplayPlaneInfo2KHR*>(this); }
+    VkDisplayPlaneInfo2KHR const* ptr() const { return reinterpret_cast<VkDisplayPlaneInfo2KHR const*>(this); }
+};
+struct safe_VkDisplayPlaneCapabilities2KHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkDisplayPlaneCapabilitiesKHR capabilities;
+
+    safe_VkDisplayPlaneCapabilities2KHR(const VkDisplayPlaneCapabilities2KHR* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkDisplayPlaneCapabilities2KHR(const safe_VkDisplayPlaneCapabilities2KHR& copy_src);
+    safe_VkDisplayPlaneCapabilities2KHR& operator=(const safe_VkDisplayPlaneCapabilities2KHR& copy_src);
+    safe_VkDisplayPlaneCapabilities2KHR();
+    ~safe_VkDisplayPlaneCapabilities2KHR();
+    void initialize(const VkDisplayPlaneCapabilities2KHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDisplayPlaneCapabilities2KHR* copy_src, PNextCopyState* copy_state = {});
+    VkDisplayPlaneCapabilities2KHR* ptr() { return reinterpret_cast<VkDisplayPlaneCapabilities2KHR*>(this); }
+    VkDisplayPlaneCapabilities2KHR const* ptr() const { return reinterpret_cast<VkDisplayPlaneCapabilities2KHR const*>(this); }
+};
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+struct safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 constantAlphaColorBlendFactors;
+    VkBool32 events;
+    VkBool32 imageViewFormatReinterpretation;
+    VkBool32 imageViewFormatSwizzle;
+    VkBool32 imageView2DOn3DImage;
+    VkBool32 multisampleArrayImage;
+    VkBool32 mutableComparisonSamplers;
+    VkBool32 pointPolygons;
+    VkBool32 samplerMipLodBias;
+    VkBool32 separateStencilMaskRef;
+    VkBool32 shaderSampleRateInterpolationFunctions;
+    VkBool32 tessellationIsolines;
+    VkBool32 tessellationPointMode;
+    VkBool32 triangleFans;
+    VkBool32 vertexAttributeAccessBeyondStride;
+
+    safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR(const VkPhysicalDevicePortabilitySubsetFeaturesKHR* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR(const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR& copy_src);
+    safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR& operator=(const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR& copy_src);
+    safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR();
+    ~safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR();
+    void initialize(const VkPhysicalDevicePortabilitySubsetFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePortabilitySubsetFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(this);
+    }
+    VkPhysicalDevicePortabilitySubsetFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t minVertexInputBindingStrideAlignment;
+
+    safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR(const VkPhysicalDevicePortabilitySubsetPropertiesKHR* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR(const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR& copy_src);
+    safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR& operator=(
+        const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR& copy_src);
+    safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR();
+    ~safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR();
+    void initialize(const VkPhysicalDevicePortabilitySubsetPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePortabilitySubsetPropertiesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(this);
+    }
+    VkPhysicalDevicePortabilitySubsetPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePortabilitySubsetPropertiesKHR const*>(this);
+    }
+};
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+struct safe_VkPhysicalDeviceShaderClockFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderSubgroupClock;
+    VkBool32 shaderDeviceClock;
+
+    safe_VkPhysicalDeviceShaderClockFeaturesKHR(const VkPhysicalDeviceShaderClockFeaturesKHR* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderClockFeaturesKHR(const safe_VkPhysicalDeviceShaderClockFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceShaderClockFeaturesKHR& operator=(const safe_VkPhysicalDeviceShaderClockFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceShaderClockFeaturesKHR();
+    ~safe_VkPhysicalDeviceShaderClockFeaturesKHR();
+    void initialize(const VkPhysicalDeviceShaderClockFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderClockFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderClockFeaturesKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR*>(this); }
+    VkPhysicalDeviceShaderClockFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR const*>(this);
+    }
+};
+struct safe_VkVideoDecodeH265ProfileInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    StdVideoH265ProfileIdc stdProfileIdc;
+
+    safe_VkVideoDecodeH265ProfileInfoKHR(const VkVideoDecodeH265ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkVideoDecodeH265ProfileInfoKHR(const safe_VkVideoDecodeH265ProfileInfoKHR& copy_src);
+    safe_VkVideoDecodeH265ProfileInfoKHR& operator=(const safe_VkVideoDecodeH265ProfileInfoKHR& copy_src);
+    safe_VkVideoDecodeH265ProfileInfoKHR();
+    ~safe_VkVideoDecodeH265ProfileInfoKHR();
+    void initialize(const VkVideoDecodeH265ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoDecodeH265ProfileInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeH265ProfileInfoKHR* ptr() { return reinterpret_cast<VkVideoDecodeH265ProfileInfoKHR*>(this); }
+    VkVideoDecodeH265ProfileInfoKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeH265ProfileInfoKHR const*>(this); }
+};
+struct safe_VkVideoDecodeH265CapabilitiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    StdVideoH265LevelIdc maxLevelIdc;
+
+    safe_VkVideoDecodeH265CapabilitiesKHR(const VkVideoDecodeH265CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkVideoDecodeH265CapabilitiesKHR(const safe_VkVideoDecodeH265CapabilitiesKHR& copy_src);
+    safe_VkVideoDecodeH265CapabilitiesKHR& operator=(const safe_VkVideoDecodeH265CapabilitiesKHR& copy_src);
+    safe_VkVideoDecodeH265CapabilitiesKHR();
+    ~safe_VkVideoDecodeH265CapabilitiesKHR();
+    void initialize(const VkVideoDecodeH265CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoDecodeH265CapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeH265CapabilitiesKHR* ptr() { return reinterpret_cast<VkVideoDecodeH265CapabilitiesKHR*>(this); }
+    VkVideoDecodeH265CapabilitiesKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeH265CapabilitiesKHR const*>(this); }
+};
+struct safe_VkVideoDecodeH265SessionParametersAddInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t stdVPSCount;
+    const StdVideoH265VideoParameterSet* pStdVPSs{};
+    uint32_t stdSPSCount;
+    const StdVideoH265SequenceParameterSet* pStdSPSs{};
+    uint32_t stdPPSCount;
+    const StdVideoH265PictureParameterSet* pStdPPSs{};
+
+    safe_VkVideoDecodeH265SessionParametersAddInfoKHR(const VkVideoDecodeH265SessionParametersAddInfoKHR* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoDecodeH265SessionParametersAddInfoKHR(const safe_VkVideoDecodeH265SessionParametersAddInfoKHR& copy_src);
+    safe_VkVideoDecodeH265SessionParametersAddInfoKHR& operator=(const safe_VkVideoDecodeH265SessionParametersAddInfoKHR& copy_src);
+    safe_VkVideoDecodeH265SessionParametersAddInfoKHR();
+    ~safe_VkVideoDecodeH265SessionParametersAddInfoKHR();
+    void initialize(const VkVideoDecodeH265SessionParametersAddInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoDecodeH265SessionParametersAddInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeH265SessionParametersAddInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoDecodeH265SessionParametersAddInfoKHR*>(this);
+    }
+    VkVideoDecodeH265SessionParametersAddInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoDecodeH265SessionParametersAddInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoDecodeH265SessionParametersCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t maxStdVPSCount;
+    uint32_t maxStdSPSCount;
+    uint32_t maxStdPPSCount;
+    safe_VkVideoDecodeH265SessionParametersAddInfoKHR* pParametersAddInfo{};
+
+    safe_VkVideoDecodeH265SessionParametersCreateInfoKHR(const VkVideoDecodeH265SessionParametersCreateInfoKHR* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoDecodeH265SessionParametersCreateInfoKHR(const safe_VkVideoDecodeH265SessionParametersCreateInfoKHR& copy_src);
+    safe_VkVideoDecodeH265SessionParametersCreateInfoKHR& operator=(
+        const safe_VkVideoDecodeH265SessionParametersCreateInfoKHR& copy_src);
+    safe_VkVideoDecodeH265SessionParametersCreateInfoKHR();
+    ~safe_VkVideoDecodeH265SessionParametersCreateInfoKHR();
+    void initialize(const VkVideoDecodeH265SessionParametersCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoDecodeH265SessionParametersCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeH265SessionParametersCreateInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoDecodeH265SessionParametersCreateInfoKHR*>(this);
+    }
+    VkVideoDecodeH265SessionParametersCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoDecodeH265SessionParametersCreateInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoDecodeH265PictureInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    const StdVideoDecodeH265PictureInfo* pStdPictureInfo{};
+    uint32_t sliceSegmentCount;
+    const uint32_t* pSliceSegmentOffsets{};
+
+    safe_VkVideoDecodeH265PictureInfoKHR(const VkVideoDecodeH265PictureInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkVideoDecodeH265PictureInfoKHR(const safe_VkVideoDecodeH265PictureInfoKHR& copy_src);
+    safe_VkVideoDecodeH265PictureInfoKHR& operator=(const safe_VkVideoDecodeH265PictureInfoKHR& copy_src);
+    safe_VkVideoDecodeH265PictureInfoKHR();
+    ~safe_VkVideoDecodeH265PictureInfoKHR();
+    void initialize(const VkVideoDecodeH265PictureInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoDecodeH265PictureInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeH265PictureInfoKHR* ptr() { return reinterpret_cast<VkVideoDecodeH265PictureInfoKHR*>(this); }
+    VkVideoDecodeH265PictureInfoKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeH265PictureInfoKHR const*>(this); }
+};
+struct safe_VkVideoDecodeH265DpbSlotInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    const StdVideoDecodeH265ReferenceInfo* pStdReferenceInfo{};
+
+    safe_VkVideoDecodeH265DpbSlotInfoKHR(const VkVideoDecodeH265DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkVideoDecodeH265DpbSlotInfoKHR(const safe_VkVideoDecodeH265DpbSlotInfoKHR& copy_src);
+    safe_VkVideoDecodeH265DpbSlotInfoKHR& operator=(const safe_VkVideoDecodeH265DpbSlotInfoKHR& copy_src);
+    safe_VkVideoDecodeH265DpbSlotInfoKHR();
+    ~safe_VkVideoDecodeH265DpbSlotInfoKHR();
+    void initialize(const VkVideoDecodeH265DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoDecodeH265DpbSlotInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeH265DpbSlotInfoKHR* ptr() { return reinterpret_cast<VkVideoDecodeH265DpbSlotInfoKHR*>(this); }
+    VkVideoDecodeH265DpbSlotInfoKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeH265DpbSlotInfoKHR const*>(this); }
+};
+struct safe_VkDeviceQueueGlobalPriorityCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkQueueGlobalPriorityKHR globalPriority;
+
+    safe_VkDeviceQueueGlobalPriorityCreateInfoKHR(const VkDeviceQueueGlobalPriorityCreateInfoKHR* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDeviceQueueGlobalPriorityCreateInfoKHR(const safe_VkDeviceQueueGlobalPriorityCreateInfoKHR& copy_src);
+    safe_VkDeviceQueueGlobalPriorityCreateInfoKHR& operator=(const safe_VkDeviceQueueGlobalPriorityCreateInfoKHR& copy_src);
+    safe_VkDeviceQueueGlobalPriorityCreateInfoKHR();
+    ~safe_VkDeviceQueueGlobalPriorityCreateInfoKHR();
+    void initialize(const VkDeviceQueueGlobalPriorityCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDeviceQueueGlobalPriorityCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceQueueGlobalPriorityCreateInfoKHR* ptr() { return reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoKHR*>(this); }
+    VkDeviceQueueGlobalPriorityCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 globalPriorityQuery;
+
+    safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(const safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& operator=(
+        const safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR();
+    ~safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR();
+    void initialize(const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR const*>(this);
+    }
+};
+struct safe_VkQueueFamilyGlobalPriorityPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t priorityCount;
+    VkQueueGlobalPriorityKHR priorities[VK_MAX_GLOBAL_PRIORITY_SIZE_KHR];
+
+    safe_VkQueueFamilyGlobalPriorityPropertiesKHR(const VkQueueFamilyGlobalPriorityPropertiesKHR* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkQueueFamilyGlobalPriorityPropertiesKHR(const safe_VkQueueFamilyGlobalPriorityPropertiesKHR& copy_src);
+    safe_VkQueueFamilyGlobalPriorityPropertiesKHR& operator=(const safe_VkQueueFamilyGlobalPriorityPropertiesKHR& copy_src);
+    safe_VkQueueFamilyGlobalPriorityPropertiesKHR();
+    ~safe_VkQueueFamilyGlobalPriorityPropertiesKHR();
+    void initialize(const VkQueueFamilyGlobalPriorityPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkQueueFamilyGlobalPriorityPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkQueueFamilyGlobalPriorityPropertiesKHR* ptr() { return reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesKHR*>(this); }
+    VkQueueFamilyGlobalPriorityPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesKHR const*>(this);
+    }
+};
+struct safe_VkFragmentShadingRateAttachmentInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    safe_VkAttachmentReference2* pFragmentShadingRateAttachment{};
+    VkExtent2D shadingRateAttachmentTexelSize;
+
+    safe_VkFragmentShadingRateAttachmentInfoKHR(const VkFragmentShadingRateAttachmentInfoKHR* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkFragmentShadingRateAttachmentInfoKHR(const safe_VkFragmentShadingRateAttachmentInfoKHR& copy_src);
+    safe_VkFragmentShadingRateAttachmentInfoKHR& operator=(const safe_VkFragmentShadingRateAttachmentInfoKHR& copy_src);
+    safe_VkFragmentShadingRateAttachmentInfoKHR();
+    ~safe_VkFragmentShadingRateAttachmentInfoKHR();
+    void initialize(const VkFragmentShadingRateAttachmentInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkFragmentShadingRateAttachmentInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkFragmentShadingRateAttachmentInfoKHR* ptr() { return reinterpret_cast<VkFragmentShadingRateAttachmentInfoKHR*>(this); }
+    VkFragmentShadingRateAttachmentInfoKHR const* ptr() const {
+        return reinterpret_cast<VkFragmentShadingRateAttachmentInfoKHR const*>(this);
+    }
+};
+struct safe_VkPipelineFragmentShadingRateStateCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExtent2D fragmentSize;
+    VkFragmentShadingRateCombinerOpKHR combinerOps[2];
+
+    safe_VkPipelineFragmentShadingRateStateCreateInfoKHR(const VkPipelineFragmentShadingRateStateCreateInfoKHR* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineFragmentShadingRateStateCreateInfoKHR(const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR& copy_src);
+    safe_VkPipelineFragmentShadingRateStateCreateInfoKHR& operator=(
+        const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR& copy_src);
+    safe_VkPipelineFragmentShadingRateStateCreateInfoKHR();
+    ~safe_VkPipelineFragmentShadingRateStateCreateInfoKHR();
+    void initialize(const VkPipelineFragmentShadingRateStateCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineFragmentShadingRateStateCreateInfoKHR* ptr() {
+        return reinterpret_cast<VkPipelineFragmentShadingRateStateCreateInfoKHR*>(this);
+    }
+    VkPipelineFragmentShadingRateStateCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkPipelineFragmentShadingRateStateCreateInfoKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 pipelineFragmentShadingRate;
+    VkBool32 primitiveFragmentShadingRate;
+    VkBool32 attachmentFragmentShadingRate;
+
+    safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& operator=(
+        const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR();
+    ~safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR();
+    void initialize(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFragmentShadingRateFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceFragmentShadingRateFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkExtent2D minFragmentShadingRateAttachmentTexelSize;
+    VkExtent2D maxFragmentShadingRateAttachmentTexelSize;
+    uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
+    VkBool32 primitiveFragmentShadingRateWithMultipleViewports;
+    VkBool32 layeredShadingRateAttachments;
+    VkBool32 fragmentShadingRateNonTrivialCombinerOps;
+    VkExtent2D maxFragmentSize;
+    uint32_t maxFragmentSizeAspectRatio;
+    uint32_t maxFragmentShadingRateCoverageSamples;
+    VkSampleCountFlagBits maxFragmentShadingRateRasterizationSamples;
+    VkBool32 fragmentShadingRateWithShaderDepthStencilWrites;
+    VkBool32 fragmentShadingRateWithSampleMask;
+    VkBool32 fragmentShadingRateWithShaderSampleMask;
+    VkBool32 fragmentShadingRateWithConservativeRasterization;
+    VkBool32 fragmentShadingRateWithFragmentShaderInterlock;
+    VkBool32 fragmentShadingRateWithCustomSampleLocations;
+    VkBool32 fragmentShadingRateStrictMultiplyCombiner;
+
+    safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* in_struct,
+                                                          PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& copy_src);
+    safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& operator=(
+        const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& copy_src);
+    safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR();
+    ~safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR();
+    void initialize(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFragmentShadingRatePropertiesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceFragmentShadingRatePropertiesKHR*>(this);
+    }
+    VkPhysicalDeviceFragmentShadingRatePropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFragmentShadingRatePropertiesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceFragmentShadingRateKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkSampleCountFlags sampleCounts;
+    VkExtent2D fragmentSize;
+
+    safe_VkPhysicalDeviceFragmentShadingRateKHR(const VkPhysicalDeviceFragmentShadingRateKHR* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceFragmentShadingRateKHR(const safe_VkPhysicalDeviceFragmentShadingRateKHR& copy_src);
+    safe_VkPhysicalDeviceFragmentShadingRateKHR& operator=(const safe_VkPhysicalDeviceFragmentShadingRateKHR& copy_src);
+    safe_VkPhysicalDeviceFragmentShadingRateKHR();
+    ~safe_VkPhysicalDeviceFragmentShadingRateKHR();
+    void initialize(const VkPhysicalDeviceFragmentShadingRateKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceFragmentShadingRateKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFragmentShadingRateKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR*>(this); }
+    VkPhysicalDeviceFragmentShadingRateKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 dynamicRenderingLocalRead;
+
+    safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR(const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* in_struct,
+                                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR(
+        const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& operator=(
+        const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR();
+    ~safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR();
+    void initialize(const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR const*>(this);
+    }
+};
+struct safe_VkRenderingAttachmentLocationInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t colorAttachmentCount;
+    const uint32_t* pColorAttachmentLocations{};
+
+    safe_VkRenderingAttachmentLocationInfoKHR(const VkRenderingAttachmentLocationInfoKHR* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkRenderingAttachmentLocationInfoKHR(const safe_VkRenderingAttachmentLocationInfoKHR& copy_src);
+    safe_VkRenderingAttachmentLocationInfoKHR& operator=(const safe_VkRenderingAttachmentLocationInfoKHR& copy_src);
+    safe_VkRenderingAttachmentLocationInfoKHR();
+    ~safe_VkRenderingAttachmentLocationInfoKHR();
+    void initialize(const VkRenderingAttachmentLocationInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderingAttachmentLocationInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkRenderingAttachmentLocationInfoKHR* ptr() { return reinterpret_cast<VkRenderingAttachmentLocationInfoKHR*>(this); }
+    VkRenderingAttachmentLocationInfoKHR const* ptr() const {
+        return reinterpret_cast<VkRenderingAttachmentLocationInfoKHR const*>(this);
+    }
+};
+struct safe_VkRenderingInputAttachmentIndexInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t colorAttachmentCount;
+    const uint32_t* pColorAttachmentInputIndices{};
+    const uint32_t* pDepthInputAttachmentIndex{};
+    const uint32_t* pStencilInputAttachmentIndex{};
+
+    safe_VkRenderingInputAttachmentIndexInfoKHR(const VkRenderingInputAttachmentIndexInfoKHR* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkRenderingInputAttachmentIndexInfoKHR(const safe_VkRenderingInputAttachmentIndexInfoKHR& copy_src);
+    safe_VkRenderingInputAttachmentIndexInfoKHR& operator=(const safe_VkRenderingInputAttachmentIndexInfoKHR& copy_src);
+    safe_VkRenderingInputAttachmentIndexInfoKHR();
+    ~safe_VkRenderingInputAttachmentIndexInfoKHR();
+    void initialize(const VkRenderingInputAttachmentIndexInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderingInputAttachmentIndexInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkRenderingInputAttachmentIndexInfoKHR* ptr() { return reinterpret_cast<VkRenderingInputAttachmentIndexInfoKHR*>(this); }
+    VkRenderingInputAttachmentIndexInfoKHR const* ptr() const {
+        return reinterpret_cast<VkRenderingInputAttachmentIndexInfoKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderQuadControl;
+
+    safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR(const VkPhysicalDeviceShaderQuadControlFeaturesKHR* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR(const safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR& operator=(const safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR();
+    ~safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR();
+    void initialize(const VkPhysicalDeviceShaderQuadControlFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderQuadControlFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderQuadControlFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceShaderQuadControlFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderQuadControlFeaturesKHR const*>(this);
+    }
+};
+struct safe_VkSurfaceProtectedCapabilitiesKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 supportsProtected;
+
+    safe_VkSurfaceProtectedCapabilitiesKHR(const VkSurfaceProtectedCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {},
+                                           bool copy_pnext = true);
+    safe_VkSurfaceProtectedCapabilitiesKHR(const safe_VkSurfaceProtectedCapabilitiesKHR& copy_src);
+    safe_VkSurfaceProtectedCapabilitiesKHR& operator=(const safe_VkSurfaceProtectedCapabilitiesKHR& copy_src);
+    safe_VkSurfaceProtectedCapabilitiesKHR();
+    ~safe_VkSurfaceProtectedCapabilitiesKHR();
+    void initialize(const VkSurfaceProtectedCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSurfaceProtectedCapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkSurfaceProtectedCapabilitiesKHR* ptr() { return reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>(this); }
+    VkSurfaceProtectedCapabilitiesKHR const* ptr() const {
+        return reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDevicePresentWaitFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 presentWait;
+
+    safe_VkPhysicalDevicePresentWaitFeaturesKHR(const VkPhysicalDevicePresentWaitFeaturesKHR* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDevicePresentWaitFeaturesKHR(const safe_VkPhysicalDevicePresentWaitFeaturesKHR& copy_src);
+    safe_VkPhysicalDevicePresentWaitFeaturesKHR& operator=(const safe_VkPhysicalDevicePresentWaitFeaturesKHR& copy_src);
+    safe_VkPhysicalDevicePresentWaitFeaturesKHR();
+    ~safe_VkPhysicalDevicePresentWaitFeaturesKHR();
+    void initialize(const VkPhysicalDevicePresentWaitFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePresentWaitFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePresentWaitFeaturesKHR* ptr() { return reinterpret_cast<VkPhysicalDevicePresentWaitFeaturesKHR*>(this); }
+    VkPhysicalDevicePresentWaitFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePresentWaitFeaturesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 pipelineExecutableInfo;
+
+    safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
+        const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
+        const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& copy_src);
+    safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& operator=(
+        const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& copy_src);
+    safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR();
+    ~safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR();
+    void initialize(const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR*>(this);
+    }
+    VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const*>(this);
+    }
+};
+struct safe_VkPipelineInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipeline pipeline;
+
+    safe_VkPipelineInfoKHR(const VkPipelineInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineInfoKHR(const safe_VkPipelineInfoKHR& copy_src);
+    safe_VkPipelineInfoKHR& operator=(const safe_VkPipelineInfoKHR& copy_src);
+    safe_VkPipelineInfoKHR();
+    ~safe_VkPipelineInfoKHR();
+    void initialize(const VkPipelineInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineInfoKHR* ptr() { return reinterpret_cast<VkPipelineInfoKHR*>(this); }
+    VkPipelineInfoKHR const* ptr() const { return reinterpret_cast<VkPipelineInfoKHR const*>(this); }
+};
+struct safe_VkPipelineExecutablePropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkShaderStageFlags stages;
+    char name[VK_MAX_DESCRIPTION_SIZE];
+    char description[VK_MAX_DESCRIPTION_SIZE];
+    uint32_t subgroupSize;
+
+    safe_VkPipelineExecutablePropertiesKHR(const VkPipelineExecutablePropertiesKHR* in_struct, PNextCopyState* copy_state = {},
+                                           bool copy_pnext = true);
+    safe_VkPipelineExecutablePropertiesKHR(const safe_VkPipelineExecutablePropertiesKHR& copy_src);
+    safe_VkPipelineExecutablePropertiesKHR& operator=(const safe_VkPipelineExecutablePropertiesKHR& copy_src);
+    safe_VkPipelineExecutablePropertiesKHR();
+    ~safe_VkPipelineExecutablePropertiesKHR();
+    void initialize(const VkPipelineExecutablePropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineExecutablePropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineExecutablePropertiesKHR* ptr() { return reinterpret_cast<VkPipelineExecutablePropertiesKHR*>(this); }
+    VkPipelineExecutablePropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPipelineExecutablePropertiesKHR const*>(this);
+    }
+};
+struct safe_VkPipelineExecutableInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipeline pipeline;
+    uint32_t executableIndex;
+
+    safe_VkPipelineExecutableInfoKHR(const VkPipelineExecutableInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    safe_VkPipelineExecutableInfoKHR(const safe_VkPipelineExecutableInfoKHR& copy_src);
+    safe_VkPipelineExecutableInfoKHR& operator=(const safe_VkPipelineExecutableInfoKHR& copy_src);
+    safe_VkPipelineExecutableInfoKHR();
+    ~safe_VkPipelineExecutableInfoKHR();
+    void initialize(const VkPipelineExecutableInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineExecutableInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineExecutableInfoKHR* ptr() { return reinterpret_cast<VkPipelineExecutableInfoKHR*>(this); }
+    VkPipelineExecutableInfoKHR const* ptr() const { return reinterpret_cast<VkPipelineExecutableInfoKHR const*>(this); }
+};
+struct safe_VkPipelineExecutableStatisticKHR {
+    VkStructureType sType;
+    void* pNext{};
+    char name[VK_MAX_DESCRIPTION_SIZE];
+    char description[VK_MAX_DESCRIPTION_SIZE];
+    VkPipelineExecutableStatisticFormatKHR format;
+    VkPipelineExecutableStatisticValueKHR value;
+
+    safe_VkPipelineExecutableStatisticKHR(const VkPipelineExecutableStatisticKHR* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkPipelineExecutableStatisticKHR(const safe_VkPipelineExecutableStatisticKHR& copy_src);
+    safe_VkPipelineExecutableStatisticKHR& operator=(const safe_VkPipelineExecutableStatisticKHR& copy_src);
+    safe_VkPipelineExecutableStatisticKHR();
+    ~safe_VkPipelineExecutableStatisticKHR();
+    void initialize(const VkPipelineExecutableStatisticKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineExecutableStatisticKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineExecutableStatisticKHR* ptr() { return reinterpret_cast<VkPipelineExecutableStatisticKHR*>(this); }
+    VkPipelineExecutableStatisticKHR const* ptr() const { return reinterpret_cast<VkPipelineExecutableStatisticKHR const*>(this); }
+};
+struct safe_VkPipelineExecutableInternalRepresentationKHR {
+    VkStructureType sType;
+    void* pNext{};
+    char name[VK_MAX_DESCRIPTION_SIZE];
+    char description[VK_MAX_DESCRIPTION_SIZE];
+    VkBool32 isText;
+    size_t dataSize;
+    void* pData{};
+
+    safe_VkPipelineExecutableInternalRepresentationKHR(const VkPipelineExecutableInternalRepresentationKHR* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineExecutableInternalRepresentationKHR(const safe_VkPipelineExecutableInternalRepresentationKHR& copy_src);
+    safe_VkPipelineExecutableInternalRepresentationKHR& operator=(
+        const safe_VkPipelineExecutableInternalRepresentationKHR& copy_src);
+    safe_VkPipelineExecutableInternalRepresentationKHR();
+    ~safe_VkPipelineExecutableInternalRepresentationKHR();
+    void initialize(const VkPipelineExecutableInternalRepresentationKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineExecutableInternalRepresentationKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineExecutableInternalRepresentationKHR* ptr() {
+        return reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR*>(this);
+    }
+    VkPipelineExecutableInternalRepresentationKHR const* ptr() const {
+        return reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR const*>(this);
+    }
+};
+struct safe_VkMemoryMapInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkMemoryMapFlags flags;
+    VkDeviceMemory memory;
+    VkDeviceSize offset;
+    VkDeviceSize size;
+
+    safe_VkMemoryMapInfoKHR(const VkMemoryMapInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkMemoryMapInfoKHR(const safe_VkMemoryMapInfoKHR& copy_src);
+    safe_VkMemoryMapInfoKHR& operator=(const safe_VkMemoryMapInfoKHR& copy_src);
+    safe_VkMemoryMapInfoKHR();
+    ~safe_VkMemoryMapInfoKHR();
+    void initialize(const VkMemoryMapInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMemoryMapInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryMapInfoKHR* ptr() { return reinterpret_cast<VkMemoryMapInfoKHR*>(this); }
+    VkMemoryMapInfoKHR const* ptr() const { return reinterpret_cast<VkMemoryMapInfoKHR const*>(this); }
+};
+struct safe_VkMemoryUnmapInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkMemoryUnmapFlagsKHR flags;
+    VkDeviceMemory memory;
+
+    safe_VkMemoryUnmapInfoKHR(const VkMemoryUnmapInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkMemoryUnmapInfoKHR(const safe_VkMemoryUnmapInfoKHR& copy_src);
+    safe_VkMemoryUnmapInfoKHR& operator=(const safe_VkMemoryUnmapInfoKHR& copy_src);
+    safe_VkMemoryUnmapInfoKHR();
+    ~safe_VkMemoryUnmapInfoKHR();
+    void initialize(const VkMemoryUnmapInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMemoryUnmapInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryUnmapInfoKHR* ptr() { return reinterpret_cast<VkMemoryUnmapInfoKHR*>(this); }
+    VkMemoryUnmapInfoKHR const* ptr() const { return reinterpret_cast<VkMemoryUnmapInfoKHR const*>(this); }
+};
+struct safe_VkPipelineLibraryCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t libraryCount;
+    VkPipeline* pLibraries{};
+
+    safe_VkPipelineLibraryCreateInfoKHR(const VkPipelineLibraryCreateInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkPipelineLibraryCreateInfoKHR(const safe_VkPipelineLibraryCreateInfoKHR& copy_src);
+    safe_VkPipelineLibraryCreateInfoKHR& operator=(const safe_VkPipelineLibraryCreateInfoKHR& copy_src);
+    safe_VkPipelineLibraryCreateInfoKHR();
+    ~safe_VkPipelineLibraryCreateInfoKHR();
+    void initialize(const VkPipelineLibraryCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineLibraryCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineLibraryCreateInfoKHR* ptr() { return reinterpret_cast<VkPipelineLibraryCreateInfoKHR*>(this); }
+    VkPipelineLibraryCreateInfoKHR const* ptr() const { return reinterpret_cast<VkPipelineLibraryCreateInfoKHR const*>(this); }
+};
+struct safe_VkPresentIdKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t swapchainCount;
+    const uint64_t* pPresentIds{};
+
+    safe_VkPresentIdKHR(const VkPresentIdKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPresentIdKHR(const safe_VkPresentIdKHR& copy_src);
+    safe_VkPresentIdKHR& operator=(const safe_VkPresentIdKHR& copy_src);
+    safe_VkPresentIdKHR();
+    ~safe_VkPresentIdKHR();
+    void initialize(const VkPresentIdKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPresentIdKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPresentIdKHR* ptr() { return reinterpret_cast<VkPresentIdKHR*>(this); }
+    VkPresentIdKHR const* ptr() const { return reinterpret_cast<VkPresentIdKHR const*>(this); }
+};
+struct safe_VkPhysicalDevicePresentIdFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 presentId;
+
+    safe_VkPhysicalDevicePresentIdFeaturesKHR(const VkPhysicalDevicePresentIdFeaturesKHR* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDevicePresentIdFeaturesKHR(const safe_VkPhysicalDevicePresentIdFeaturesKHR& copy_src);
+    safe_VkPhysicalDevicePresentIdFeaturesKHR& operator=(const safe_VkPhysicalDevicePresentIdFeaturesKHR& copy_src);
+    safe_VkPhysicalDevicePresentIdFeaturesKHR();
+    ~safe_VkPhysicalDevicePresentIdFeaturesKHR();
+    void initialize(const VkPhysicalDevicePresentIdFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePresentIdFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePresentIdFeaturesKHR* ptr() { return reinterpret_cast<VkPhysicalDevicePresentIdFeaturesKHR*>(this); }
+    VkPhysicalDevicePresentIdFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePresentIdFeaturesKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkVideoEncodeFlagsKHR flags;
+    VkBuffer dstBuffer;
+    VkDeviceSize dstBufferOffset;
+    VkDeviceSize dstBufferRange;
+    safe_VkVideoPictureResourceInfoKHR srcPictureResource;
+    safe_VkVideoReferenceSlotInfoKHR* pSetupReferenceSlot{};
+    uint32_t referenceSlotCount;
+    safe_VkVideoReferenceSlotInfoKHR* pReferenceSlots{};
+    uint32_t precedingExternallyEncodedBytes;
+
+    safe_VkVideoEncodeInfoKHR(const VkVideoEncodeInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEncodeInfoKHR(const safe_VkVideoEncodeInfoKHR& copy_src);
+    safe_VkVideoEncodeInfoKHR& operator=(const safe_VkVideoEncodeInfoKHR& copy_src);
+    safe_VkVideoEncodeInfoKHR();
+    ~safe_VkVideoEncodeInfoKHR();
+    void initialize(const VkVideoEncodeInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeInfoKHR*>(this); }
+    VkVideoEncodeInfoKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeInfoKHR const*>(this); }
+};
+struct safe_VkVideoEncodeCapabilitiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkVideoEncodeCapabilityFlagsKHR flags;
+    VkVideoEncodeRateControlModeFlagsKHR rateControlModes;
+    uint32_t maxRateControlLayers;
+    uint64_t maxBitrate;
+    uint32_t maxQualityLevels;
+    VkExtent2D encodeInputPictureGranularity;
+    VkVideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags;
+
+    safe_VkVideoEncodeCapabilitiesKHR(const VkVideoEncodeCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    safe_VkVideoEncodeCapabilitiesKHR(const safe_VkVideoEncodeCapabilitiesKHR& copy_src);
+    safe_VkVideoEncodeCapabilitiesKHR& operator=(const safe_VkVideoEncodeCapabilitiesKHR& copy_src);
+    safe_VkVideoEncodeCapabilitiesKHR();
+    ~safe_VkVideoEncodeCapabilitiesKHR();
+    void initialize(const VkVideoEncodeCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeCapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeCapabilitiesKHR* ptr() { return reinterpret_cast<VkVideoEncodeCapabilitiesKHR*>(this); }
+    VkVideoEncodeCapabilitiesKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeCapabilitiesKHR const*>(this); }
+};
+struct safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkVideoEncodeFeedbackFlagsKHR encodeFeedbackFlags;
+
+    safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(const safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& copy_src);
+    safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& operator=(const safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& copy_src);
+    safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR();
+    ~safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR();
+    void initialize(const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* ptr() {
+        return reinterpret_cast<VkQueryPoolVideoEncodeFeedbackCreateInfoKHR*>(this);
+    }
+    VkQueryPoolVideoEncodeFeedbackCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkQueryPoolVideoEncodeFeedbackCreateInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeUsageInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkVideoEncodeUsageFlagsKHR videoUsageHints;
+    VkVideoEncodeContentFlagsKHR videoContentHints;
+    VkVideoEncodeTuningModeKHR tuningMode;
+
+    safe_VkVideoEncodeUsageInfoKHR(const VkVideoEncodeUsageInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    safe_VkVideoEncodeUsageInfoKHR(const safe_VkVideoEncodeUsageInfoKHR& copy_src);
+    safe_VkVideoEncodeUsageInfoKHR& operator=(const safe_VkVideoEncodeUsageInfoKHR& copy_src);
+    safe_VkVideoEncodeUsageInfoKHR();
+    ~safe_VkVideoEncodeUsageInfoKHR();
+    void initialize(const VkVideoEncodeUsageInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeUsageInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeUsageInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeUsageInfoKHR*>(this); }
+    VkVideoEncodeUsageInfoKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeUsageInfoKHR const*>(this); }
+};
+struct safe_VkVideoEncodeRateControlLayerInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint64_t averageBitrate;
+    uint64_t maxBitrate;
+    uint32_t frameRateNumerator;
+    uint32_t frameRateDenominator;
+
+    safe_VkVideoEncodeRateControlLayerInfoKHR(const VkVideoEncodeRateControlLayerInfoKHR* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEncodeRateControlLayerInfoKHR(const safe_VkVideoEncodeRateControlLayerInfoKHR& copy_src);
+    safe_VkVideoEncodeRateControlLayerInfoKHR& operator=(const safe_VkVideoEncodeRateControlLayerInfoKHR& copy_src);
+    safe_VkVideoEncodeRateControlLayerInfoKHR();
+    ~safe_VkVideoEncodeRateControlLayerInfoKHR();
+    void initialize(const VkVideoEncodeRateControlLayerInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeRateControlLayerInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeRateControlLayerInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeRateControlLayerInfoKHR*>(this); }
+    VkVideoEncodeRateControlLayerInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeRateControlLayerInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeRateControlInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkVideoEncodeRateControlFlagsKHR flags;
+    VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode;
+    uint32_t layerCount;
+    safe_VkVideoEncodeRateControlLayerInfoKHR* pLayers{};
+    uint32_t virtualBufferSizeInMs;
+    uint32_t initialVirtualBufferSizeInMs;
+
+    safe_VkVideoEncodeRateControlInfoKHR(const VkVideoEncodeRateControlInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkVideoEncodeRateControlInfoKHR(const safe_VkVideoEncodeRateControlInfoKHR& copy_src);
+    safe_VkVideoEncodeRateControlInfoKHR& operator=(const safe_VkVideoEncodeRateControlInfoKHR& copy_src);
+    safe_VkVideoEncodeRateControlInfoKHR();
+    ~safe_VkVideoEncodeRateControlInfoKHR();
+    void initialize(const VkVideoEncodeRateControlInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeRateControlInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeRateControlInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeRateControlInfoKHR*>(this); }
+    VkVideoEncodeRateControlInfoKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeRateControlInfoKHR const*>(this); }
+};
+struct safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    safe_VkVideoProfileInfoKHR* pVideoProfile{};
+    uint32_t qualityLevel;
+
+    safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR(const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR(const safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR& copy_src);
+    safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR& operator=(
+        const safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR& copy_src);
+    safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR();
+    ~safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR();
+    void initialize(const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR*>(this);
+    }
+    VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeQualityLevelPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkVideoEncodeRateControlModeFlagBitsKHR preferredRateControlMode;
+    uint32_t preferredRateControlLayerCount;
+
+    safe_VkVideoEncodeQualityLevelPropertiesKHR(const VkVideoEncodeQualityLevelPropertiesKHR* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEncodeQualityLevelPropertiesKHR(const safe_VkVideoEncodeQualityLevelPropertiesKHR& copy_src);
+    safe_VkVideoEncodeQualityLevelPropertiesKHR& operator=(const safe_VkVideoEncodeQualityLevelPropertiesKHR& copy_src);
+    safe_VkVideoEncodeQualityLevelPropertiesKHR();
+    ~safe_VkVideoEncodeQualityLevelPropertiesKHR();
+    void initialize(const VkVideoEncodeQualityLevelPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeQualityLevelPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeQualityLevelPropertiesKHR* ptr() { return reinterpret_cast<VkVideoEncodeQualityLevelPropertiesKHR*>(this); }
+    VkVideoEncodeQualityLevelPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeQualityLevelPropertiesKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeQualityLevelInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t qualityLevel;
+
+    safe_VkVideoEncodeQualityLevelInfoKHR(const VkVideoEncodeQualityLevelInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkVideoEncodeQualityLevelInfoKHR(const safe_VkVideoEncodeQualityLevelInfoKHR& copy_src);
+    safe_VkVideoEncodeQualityLevelInfoKHR& operator=(const safe_VkVideoEncodeQualityLevelInfoKHR& copy_src);
+    safe_VkVideoEncodeQualityLevelInfoKHR();
+    ~safe_VkVideoEncodeQualityLevelInfoKHR();
+    void initialize(const VkVideoEncodeQualityLevelInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeQualityLevelInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeQualityLevelInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeQualityLevelInfoKHR*>(this); }
+    VkVideoEncodeQualityLevelInfoKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeQualityLevelInfoKHR const*>(this); }
+};
+struct safe_VkVideoEncodeSessionParametersGetInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkVideoSessionParametersKHR videoSessionParameters;
+
+    safe_VkVideoEncodeSessionParametersGetInfoKHR(const VkVideoEncodeSessionParametersGetInfoKHR* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEncodeSessionParametersGetInfoKHR(const safe_VkVideoEncodeSessionParametersGetInfoKHR& copy_src);
+    safe_VkVideoEncodeSessionParametersGetInfoKHR& operator=(const safe_VkVideoEncodeSessionParametersGetInfoKHR& copy_src);
+    safe_VkVideoEncodeSessionParametersGetInfoKHR();
+    ~safe_VkVideoEncodeSessionParametersGetInfoKHR();
+    void initialize(const VkVideoEncodeSessionParametersGetInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeSessionParametersGetInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeSessionParametersGetInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeSessionParametersGetInfoKHR*>(this); }
+    VkVideoEncodeSessionParametersGetInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeSessionParametersGetInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeSessionParametersFeedbackInfoKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 hasOverrides;
+
+    safe_VkVideoEncodeSessionParametersFeedbackInfoKHR(const VkVideoEncodeSessionParametersFeedbackInfoKHR* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEncodeSessionParametersFeedbackInfoKHR(const safe_VkVideoEncodeSessionParametersFeedbackInfoKHR& copy_src);
+    safe_VkVideoEncodeSessionParametersFeedbackInfoKHR& operator=(
+        const safe_VkVideoEncodeSessionParametersFeedbackInfoKHR& copy_src);
+    safe_VkVideoEncodeSessionParametersFeedbackInfoKHR();
+    ~safe_VkVideoEncodeSessionParametersFeedbackInfoKHR();
+    void initialize(const VkVideoEncodeSessionParametersFeedbackInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeSessionParametersFeedbackInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeSessionParametersFeedbackInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR*>(this);
+    }
+    VkVideoEncodeSessionParametersFeedbackInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR const*>(this);
+    }
+};
+struct safe_VkQueueFamilyCheckpointProperties2NV {
+    VkStructureType sType;
+    void* pNext{};
+    VkPipelineStageFlags2 checkpointExecutionStageMask;
+
+    safe_VkQueueFamilyCheckpointProperties2NV(const VkQueueFamilyCheckpointProperties2NV* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkQueueFamilyCheckpointProperties2NV(const safe_VkQueueFamilyCheckpointProperties2NV& copy_src);
+    safe_VkQueueFamilyCheckpointProperties2NV& operator=(const safe_VkQueueFamilyCheckpointProperties2NV& copy_src);
+    safe_VkQueueFamilyCheckpointProperties2NV();
+    ~safe_VkQueueFamilyCheckpointProperties2NV();
+    void initialize(const VkQueueFamilyCheckpointProperties2NV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkQueueFamilyCheckpointProperties2NV* copy_src, PNextCopyState* copy_state = {});
+    VkQueueFamilyCheckpointProperties2NV* ptr() { return reinterpret_cast<VkQueueFamilyCheckpointProperties2NV*>(this); }
+    VkQueueFamilyCheckpointProperties2NV const* ptr() const {
+        return reinterpret_cast<VkQueueFamilyCheckpointProperties2NV const*>(this);
+    }
+};
+struct safe_VkCheckpointData2NV {
+    VkStructureType sType;
+    void* pNext{};
+    VkPipelineStageFlags2 stage;
+    void* pCheckpointMarker{};
+
+    safe_VkCheckpointData2NV(const VkCheckpointData2NV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkCheckpointData2NV(const safe_VkCheckpointData2NV& copy_src);
+    safe_VkCheckpointData2NV& operator=(const safe_VkCheckpointData2NV& copy_src);
+    safe_VkCheckpointData2NV();
+    ~safe_VkCheckpointData2NV();
+    void initialize(const VkCheckpointData2NV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCheckpointData2NV* copy_src, PNextCopyState* copy_state = {});
+    VkCheckpointData2NV* ptr() { return reinterpret_cast<VkCheckpointData2NV*>(this); }
+    VkCheckpointData2NV const* ptr() const { return reinterpret_cast<VkCheckpointData2NV const*>(this); }
+};
+struct safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 fragmentShaderBarycentric;
+
+    safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* in_struct,
+                                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
+        const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& operator=(
+        const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR();
+    ~safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR();
+    void initialize(const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 triStripVertexOrderIndependentOfProvokingVertex;
+
+    safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
+        const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
+        const safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& copy_src);
+    safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& operator=(
+        const safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& copy_src);
+    safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR();
+    ~safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR();
+    void initialize(const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR*>(this);
+    }
+    VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderSubgroupUniformControlFlow;
+
+    safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
+        const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
+        const safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& operator=(
+        const safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR();
+    ~safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR();
+    void initialize(const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* copy_src,
+                    PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 workgroupMemoryExplicitLayout;
+    VkBool32 workgroupMemoryExplicitLayoutScalarBlockLayout;
+    VkBool32 workgroupMemoryExplicitLayout8BitAccess;
+    VkBool32 workgroupMemoryExplicitLayout16BitAccess;
+
+    safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
+        const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
+        const safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& operator=(
+        const safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR();
+    ~safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR();
+    void initialize(const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 rayTracingMaintenance1;
+    VkBool32 rayTracingPipelineTraceRaysIndirect2;
+
+    safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* in_struct,
+                                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(const safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& operator=(
+        const safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR();
+    ~safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR();
+    void initialize(const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderSubgroupRotate;
+    VkBool32 shaderSubgroupRotateClustered;
+
+    safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR(const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR(const safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR& operator=(
+        const safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR();
+    ~safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR();
+    void initialize(const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderMaximalReconvergence;
+
+    safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(
+        const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(
+        const safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& operator=(
+        const safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR();
+    ~safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR();
+    void initialize(const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceMaintenance5FeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 maintenance5;
+
+    safe_VkPhysicalDeviceMaintenance5FeaturesKHR(const VkPhysicalDeviceMaintenance5FeaturesKHR* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceMaintenance5FeaturesKHR(const safe_VkPhysicalDeviceMaintenance5FeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceMaintenance5FeaturesKHR& operator=(const safe_VkPhysicalDeviceMaintenance5FeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceMaintenance5FeaturesKHR();
+    ~safe_VkPhysicalDeviceMaintenance5FeaturesKHR();
+    void initialize(const VkPhysicalDeviceMaintenance5FeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMaintenance5FeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMaintenance5FeaturesKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceMaintenance5FeaturesKHR*>(this); }
+    VkPhysicalDeviceMaintenance5FeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMaintenance5FeaturesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceMaintenance5PropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 earlyFragmentMultisampleCoverageAfterSampleCounting;
+    VkBool32 earlyFragmentSampleMaskTestBeforeSampleCounting;
+    VkBool32 depthStencilSwizzleOneSupport;
+    VkBool32 polygonModePointSize;
+    VkBool32 nonStrictSinglePixelWideLinesUseParallelogram;
+    VkBool32 nonStrictWideLinesUseParallelogram;
+
+    safe_VkPhysicalDeviceMaintenance5PropertiesKHR(const VkPhysicalDeviceMaintenance5PropertiesKHR* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceMaintenance5PropertiesKHR(const safe_VkPhysicalDeviceMaintenance5PropertiesKHR& copy_src);
+    safe_VkPhysicalDeviceMaintenance5PropertiesKHR& operator=(const safe_VkPhysicalDeviceMaintenance5PropertiesKHR& copy_src);
+    safe_VkPhysicalDeviceMaintenance5PropertiesKHR();
+    ~safe_VkPhysicalDeviceMaintenance5PropertiesKHR();
+    void initialize(const VkPhysicalDeviceMaintenance5PropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMaintenance5PropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMaintenance5PropertiesKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceMaintenance5PropertiesKHR*>(this); }
+    VkPhysicalDeviceMaintenance5PropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMaintenance5PropertiesKHR const*>(this);
+    }
+};
+struct safe_VkRenderingAreaInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t viewMask;
+    uint32_t colorAttachmentCount;
+    const VkFormat* pColorAttachmentFormats{};
+    VkFormat depthAttachmentFormat;
+    VkFormat stencilAttachmentFormat;
+
+    safe_VkRenderingAreaInfoKHR(const VkRenderingAreaInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkRenderingAreaInfoKHR(const safe_VkRenderingAreaInfoKHR& copy_src);
+    safe_VkRenderingAreaInfoKHR& operator=(const safe_VkRenderingAreaInfoKHR& copy_src);
+    safe_VkRenderingAreaInfoKHR();
+    ~safe_VkRenderingAreaInfoKHR();
+    void initialize(const VkRenderingAreaInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderingAreaInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkRenderingAreaInfoKHR* ptr() { return reinterpret_cast<VkRenderingAreaInfoKHR*>(this); }
+    VkRenderingAreaInfoKHR const* ptr() const { return reinterpret_cast<VkRenderingAreaInfoKHR const*>(this); }
+};
+struct safe_VkImageSubresource2KHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkImageSubresource imageSubresource;
+
+    safe_VkImageSubresource2KHR(const VkImageSubresource2KHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkImageSubresource2KHR(const safe_VkImageSubresource2KHR& copy_src);
+    safe_VkImageSubresource2KHR& operator=(const safe_VkImageSubresource2KHR& copy_src);
+    safe_VkImageSubresource2KHR();
+    ~safe_VkImageSubresource2KHR();
+    void initialize(const VkImageSubresource2KHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageSubresource2KHR* copy_src, PNextCopyState* copy_state = {});
+    VkImageSubresource2KHR* ptr() { return reinterpret_cast<VkImageSubresource2KHR*>(this); }
+    VkImageSubresource2KHR const* ptr() const { return reinterpret_cast<VkImageSubresource2KHR const*>(this); }
+};
+struct safe_VkDeviceImageSubresourceInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    safe_VkImageCreateInfo* pCreateInfo{};
+    safe_VkImageSubresource2KHR* pSubresource{};
+
+    safe_VkDeviceImageSubresourceInfoKHR(const VkDeviceImageSubresourceInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkDeviceImageSubresourceInfoKHR(const safe_VkDeviceImageSubresourceInfoKHR& copy_src);
+    safe_VkDeviceImageSubresourceInfoKHR& operator=(const safe_VkDeviceImageSubresourceInfoKHR& copy_src);
+    safe_VkDeviceImageSubresourceInfoKHR();
+    ~safe_VkDeviceImageSubresourceInfoKHR();
+    void initialize(const VkDeviceImageSubresourceInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDeviceImageSubresourceInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceImageSubresourceInfoKHR* ptr() { return reinterpret_cast<VkDeviceImageSubresourceInfoKHR*>(this); }
+    VkDeviceImageSubresourceInfoKHR const* ptr() const { return reinterpret_cast<VkDeviceImageSubresourceInfoKHR const*>(this); }
+};
+struct safe_VkSubresourceLayout2KHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkSubresourceLayout subresourceLayout;
+
+    safe_VkSubresourceLayout2KHR(const VkSubresourceLayout2KHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSubresourceLayout2KHR(const safe_VkSubresourceLayout2KHR& copy_src);
+    safe_VkSubresourceLayout2KHR& operator=(const safe_VkSubresourceLayout2KHR& copy_src);
+    safe_VkSubresourceLayout2KHR();
+    ~safe_VkSubresourceLayout2KHR();
+    void initialize(const VkSubresourceLayout2KHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSubresourceLayout2KHR* copy_src, PNextCopyState* copy_state = {});
+    VkSubresourceLayout2KHR* ptr() { return reinterpret_cast<VkSubresourceLayout2KHR*>(this); }
+    VkSubresourceLayout2KHR const* ptr() const { return reinterpret_cast<VkSubresourceLayout2KHR const*>(this); }
+};
+struct safe_VkPipelineCreateFlags2CreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineCreateFlags2KHR flags;
+
+    safe_VkPipelineCreateFlags2CreateInfoKHR(const VkPipelineCreateFlags2CreateInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkPipelineCreateFlags2CreateInfoKHR(const safe_VkPipelineCreateFlags2CreateInfoKHR& copy_src);
+    safe_VkPipelineCreateFlags2CreateInfoKHR& operator=(const safe_VkPipelineCreateFlags2CreateInfoKHR& copy_src);
+    safe_VkPipelineCreateFlags2CreateInfoKHR();
+    ~safe_VkPipelineCreateFlags2CreateInfoKHR();
+    void initialize(const VkPipelineCreateFlags2CreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineCreateFlags2CreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineCreateFlags2CreateInfoKHR* ptr() { return reinterpret_cast<VkPipelineCreateFlags2CreateInfoKHR*>(this); }
+    VkPipelineCreateFlags2CreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkPipelineCreateFlags2CreateInfoKHR const*>(this);
+    }
+};
+struct safe_VkBufferUsageFlags2CreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBufferUsageFlags2KHR usage;
+
+    safe_VkBufferUsageFlags2CreateInfoKHR(const VkBufferUsageFlags2CreateInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkBufferUsageFlags2CreateInfoKHR(const safe_VkBufferUsageFlags2CreateInfoKHR& copy_src);
+    safe_VkBufferUsageFlags2CreateInfoKHR& operator=(const safe_VkBufferUsageFlags2CreateInfoKHR& copy_src);
+    safe_VkBufferUsageFlags2CreateInfoKHR();
+    ~safe_VkBufferUsageFlags2CreateInfoKHR();
+    void initialize(const VkBufferUsageFlags2CreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBufferUsageFlags2CreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkBufferUsageFlags2CreateInfoKHR* ptr() { return reinterpret_cast<VkBufferUsageFlags2CreateInfoKHR*>(this); }
+    VkBufferUsageFlags2CreateInfoKHR const* ptr() const { return reinterpret_cast<VkBufferUsageFlags2CreateInfoKHR const*>(this); }
+};
+struct safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 rayTracingPositionFetch;
+
+    safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* in_struct,
+                                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
+        const safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& operator=(
+        const safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR();
+    ~safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR();
+    void initialize(const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR const*>(this);
+    }
+};
+struct safe_VkCooperativeMatrixPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t MSize;
+    uint32_t NSize;
+    uint32_t KSize;
+    VkComponentTypeKHR AType;
+    VkComponentTypeKHR BType;
+    VkComponentTypeKHR CType;
+    VkComponentTypeKHR ResultType;
+    VkBool32 saturatingAccumulation;
+    VkScopeKHR scope;
+
+    safe_VkCooperativeMatrixPropertiesKHR(const VkCooperativeMatrixPropertiesKHR* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkCooperativeMatrixPropertiesKHR(const safe_VkCooperativeMatrixPropertiesKHR& copy_src);
+    safe_VkCooperativeMatrixPropertiesKHR& operator=(const safe_VkCooperativeMatrixPropertiesKHR& copy_src);
+    safe_VkCooperativeMatrixPropertiesKHR();
+    ~safe_VkCooperativeMatrixPropertiesKHR();
+    void initialize(const VkCooperativeMatrixPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCooperativeMatrixPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkCooperativeMatrixPropertiesKHR* ptr() { return reinterpret_cast<VkCooperativeMatrixPropertiesKHR*>(this); }
+    VkCooperativeMatrixPropertiesKHR const* ptr() const { return reinterpret_cast<VkCooperativeMatrixPropertiesKHR const*>(this); }
+};
+struct safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 cooperativeMatrix;
+    VkBool32 cooperativeMatrixRobustBufferAccess;
+
+    safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR(const VkPhysicalDeviceCooperativeMatrixFeaturesKHR* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR(const safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& operator=(const safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR();
+    ~safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR();
+    void initialize(const VkPhysicalDeviceCooperativeMatrixFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCooperativeMatrixFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceCooperativeMatrixFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkShaderStageFlags cooperativeMatrixSupportedStages;
+
+    safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR(const VkPhysicalDeviceCooperativeMatrixPropertiesKHR* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR(const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& copy_src);
+    safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& operator=(
+        const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& copy_src);
+    safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR();
+    ~safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR();
+    void initialize(const VkPhysicalDeviceCooperativeMatrixPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCooperativeMatrixPropertiesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesKHR*>(this);
+    }
+    VkPhysicalDeviceCooperativeMatrixPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesKHR const*>(this);
+    }
+};
+struct safe_VkVideoDecodeAV1ProfileInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    StdVideoAV1Profile stdProfile;
+    VkBool32 filmGrainSupport;
+
+    safe_VkVideoDecodeAV1ProfileInfoKHR(const VkVideoDecodeAV1ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkVideoDecodeAV1ProfileInfoKHR(const safe_VkVideoDecodeAV1ProfileInfoKHR& copy_src);
+    safe_VkVideoDecodeAV1ProfileInfoKHR& operator=(const safe_VkVideoDecodeAV1ProfileInfoKHR& copy_src);
+    safe_VkVideoDecodeAV1ProfileInfoKHR();
+    ~safe_VkVideoDecodeAV1ProfileInfoKHR();
+    void initialize(const VkVideoDecodeAV1ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoDecodeAV1ProfileInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeAV1ProfileInfoKHR* ptr() { return reinterpret_cast<VkVideoDecodeAV1ProfileInfoKHR*>(this); }
+    VkVideoDecodeAV1ProfileInfoKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeAV1ProfileInfoKHR const*>(this); }
+};
+struct safe_VkVideoDecodeAV1CapabilitiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    StdVideoAV1Level maxLevel;
+
+    safe_VkVideoDecodeAV1CapabilitiesKHR(const VkVideoDecodeAV1CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkVideoDecodeAV1CapabilitiesKHR(const safe_VkVideoDecodeAV1CapabilitiesKHR& copy_src);
+    safe_VkVideoDecodeAV1CapabilitiesKHR& operator=(const safe_VkVideoDecodeAV1CapabilitiesKHR& copy_src);
+    safe_VkVideoDecodeAV1CapabilitiesKHR();
+    ~safe_VkVideoDecodeAV1CapabilitiesKHR();
+    void initialize(const VkVideoDecodeAV1CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoDecodeAV1CapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeAV1CapabilitiesKHR* ptr() { return reinterpret_cast<VkVideoDecodeAV1CapabilitiesKHR*>(this); }
+    VkVideoDecodeAV1CapabilitiesKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeAV1CapabilitiesKHR const*>(this); }
+};
+struct safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    const StdVideoAV1SequenceHeader* pStdSequenceHeader{};
+
+    safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR(const VkVideoDecodeAV1SessionParametersCreateInfoKHR* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR(const safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR& copy_src);
+    safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR& operator=(
+        const safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR& copy_src);
+    safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR();
+    ~safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR();
+    void initialize(const VkVideoDecodeAV1SessionParametersCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeAV1SessionParametersCreateInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoDecodeAV1SessionParametersCreateInfoKHR*>(this);
+    }
+    VkVideoDecodeAV1SessionParametersCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoDecodeAV1SessionParametersCreateInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoDecodeAV1PictureInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    const StdVideoDecodeAV1PictureInfo* pStdPictureInfo{};
+    int32_t referenceNameSlotIndices[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR];
+    uint32_t frameHeaderOffset;
+    uint32_t tileCount;
+    const uint32_t* pTileOffsets{};
+    const uint32_t* pTileSizes{};
+
+    safe_VkVideoDecodeAV1PictureInfoKHR(const VkVideoDecodeAV1PictureInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkVideoDecodeAV1PictureInfoKHR(const safe_VkVideoDecodeAV1PictureInfoKHR& copy_src);
+    safe_VkVideoDecodeAV1PictureInfoKHR& operator=(const safe_VkVideoDecodeAV1PictureInfoKHR& copy_src);
+    safe_VkVideoDecodeAV1PictureInfoKHR();
+    ~safe_VkVideoDecodeAV1PictureInfoKHR();
+    void initialize(const VkVideoDecodeAV1PictureInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoDecodeAV1PictureInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeAV1PictureInfoKHR* ptr() { return reinterpret_cast<VkVideoDecodeAV1PictureInfoKHR*>(this); }
+    VkVideoDecodeAV1PictureInfoKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeAV1PictureInfoKHR const*>(this); }
+};
+struct safe_VkVideoDecodeAV1DpbSlotInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    const StdVideoDecodeAV1ReferenceInfo* pStdReferenceInfo{};
+
+    safe_VkVideoDecodeAV1DpbSlotInfoKHR(const VkVideoDecodeAV1DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkVideoDecodeAV1DpbSlotInfoKHR(const safe_VkVideoDecodeAV1DpbSlotInfoKHR& copy_src);
+    safe_VkVideoDecodeAV1DpbSlotInfoKHR& operator=(const safe_VkVideoDecodeAV1DpbSlotInfoKHR& copy_src);
+    safe_VkVideoDecodeAV1DpbSlotInfoKHR();
+    ~safe_VkVideoDecodeAV1DpbSlotInfoKHR();
+    void initialize(const VkVideoDecodeAV1DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoDecodeAV1DpbSlotInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeAV1DpbSlotInfoKHR* ptr() { return reinterpret_cast<VkVideoDecodeAV1DpbSlotInfoKHR*>(this); }
+    VkVideoDecodeAV1DpbSlotInfoKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeAV1DpbSlotInfoKHR const*>(this); }
+};
+struct safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 videoMaintenance1;
+
+    safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(const VkPhysicalDeviceVideoMaintenance1FeaturesKHR* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(const safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR& operator=(const safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR();
+    ~safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR();
+    void initialize(const VkPhysicalDeviceVideoMaintenance1FeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVideoMaintenance1FeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceVideoMaintenance1FeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceVideoMaintenance1FeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceVideoMaintenance1FeaturesKHR const*>(this);
+    }
+};
+struct safe_VkVideoInlineQueryInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkQueryPool queryPool;
+    uint32_t firstQuery;
+    uint32_t queryCount;
+
+    safe_VkVideoInlineQueryInfoKHR(const VkVideoInlineQueryInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    safe_VkVideoInlineQueryInfoKHR(const safe_VkVideoInlineQueryInfoKHR& copy_src);
+    safe_VkVideoInlineQueryInfoKHR& operator=(const safe_VkVideoInlineQueryInfoKHR& copy_src);
+    safe_VkVideoInlineQueryInfoKHR();
+    ~safe_VkVideoInlineQueryInfoKHR();
+    void initialize(const VkVideoInlineQueryInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoInlineQueryInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoInlineQueryInfoKHR* ptr() { return reinterpret_cast<VkVideoInlineQueryInfoKHR*>(this); }
+    VkVideoInlineQueryInfoKHR const* ptr() const { return reinterpret_cast<VkVideoInlineQueryInfoKHR const*>(this); }
+};
+struct safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxVertexAttribDivisor;
+    VkBool32 supportsNonZeroFirstInstance;
+
+    safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR(const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* in_struct,
+                                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR(
+        const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& copy_src);
+    safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& operator=(
+        const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& copy_src);
+    safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR();
+    ~safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR();
+    void initialize(const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR*>(this);
+    }
+    VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR const*>(this);
+    }
+};
+struct safe_VkPipelineVertexInputDivisorStateCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t vertexBindingDivisorCount;
+    const VkVertexInputBindingDivisorDescriptionKHR* pVertexBindingDivisors{};
+
+    safe_VkPipelineVertexInputDivisorStateCreateInfoKHR(const VkPipelineVertexInputDivisorStateCreateInfoKHR* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineVertexInputDivisorStateCreateInfoKHR(const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR& copy_src);
+    safe_VkPipelineVertexInputDivisorStateCreateInfoKHR& operator=(
+        const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR& copy_src);
+    safe_VkPipelineVertexInputDivisorStateCreateInfoKHR();
+    ~safe_VkPipelineVertexInputDivisorStateCreateInfoKHR();
+    void initialize(const VkPipelineVertexInputDivisorStateCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineVertexInputDivisorStateCreateInfoKHR* ptr() {
+        return reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoKHR*>(this);
+    }
+    VkPipelineVertexInputDivisorStateCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 vertexAttributeInstanceRateDivisor;
+    VkBool32 vertexAttributeInstanceRateZeroDivisor;
+
+    safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR(const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* in_struct,
+                                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR(const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& operator=(
+        const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR();
+    ~safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR();
+    void initialize(const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderFloatControls2;
+
+    safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR(const VkPhysicalDeviceShaderFloatControls2FeaturesKHR* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR(const safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR& operator=(
+        const safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR();
+    ~safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR();
+    void initialize(const VkPhysicalDeviceShaderFloatControls2FeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderFloatControls2FeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderFloatControls2FeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceShaderFloatControls2FeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderFloatControls2FeaturesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 indexTypeUint8;
+
+    safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR(const VkPhysicalDeviceIndexTypeUint8FeaturesKHR* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR& operator=(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR();
+    ~safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR();
+    void initialize(const VkPhysicalDeviceIndexTypeUint8FeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceIndexTypeUint8FeaturesKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesKHR*>(this); }
+    VkPhysicalDeviceIndexTypeUint8FeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceLineRasterizationFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 rectangularLines;
+    VkBool32 bresenhamLines;
+    VkBool32 smoothLines;
+    VkBool32 stippledRectangularLines;
+    VkBool32 stippledBresenhamLines;
+    VkBool32 stippledSmoothLines;
+
+    safe_VkPhysicalDeviceLineRasterizationFeaturesKHR(const VkPhysicalDeviceLineRasterizationFeaturesKHR* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceLineRasterizationFeaturesKHR(const safe_VkPhysicalDeviceLineRasterizationFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceLineRasterizationFeaturesKHR& operator=(const safe_VkPhysicalDeviceLineRasterizationFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceLineRasterizationFeaturesKHR();
+    ~safe_VkPhysicalDeviceLineRasterizationFeaturesKHR();
+    void initialize(const VkPhysicalDeviceLineRasterizationFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceLineRasterizationFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceLineRasterizationFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceLineRasterizationFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceLineRasterizationPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t lineSubPixelPrecisionBits;
+
+    safe_VkPhysicalDeviceLineRasterizationPropertiesKHR(const VkPhysicalDeviceLineRasterizationPropertiesKHR* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceLineRasterizationPropertiesKHR(const safe_VkPhysicalDeviceLineRasterizationPropertiesKHR& copy_src);
+    safe_VkPhysicalDeviceLineRasterizationPropertiesKHR& operator=(
+        const safe_VkPhysicalDeviceLineRasterizationPropertiesKHR& copy_src);
+    safe_VkPhysicalDeviceLineRasterizationPropertiesKHR();
+    ~safe_VkPhysicalDeviceLineRasterizationPropertiesKHR();
+    void initialize(const VkPhysicalDeviceLineRasterizationPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceLineRasterizationPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceLineRasterizationPropertiesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesKHR*>(this);
+    }
+    VkPhysicalDeviceLineRasterizationPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesKHR const*>(this);
+    }
+};
+struct safe_VkPipelineRasterizationLineStateCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkLineRasterizationModeKHR lineRasterizationMode;
+    VkBool32 stippledLineEnable;
+    uint32_t lineStippleFactor;
+    uint16_t lineStipplePattern;
+
+    safe_VkPipelineRasterizationLineStateCreateInfoKHR(const VkPipelineRasterizationLineStateCreateInfoKHR* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineRasterizationLineStateCreateInfoKHR(const safe_VkPipelineRasterizationLineStateCreateInfoKHR& copy_src);
+    safe_VkPipelineRasterizationLineStateCreateInfoKHR& operator=(
+        const safe_VkPipelineRasterizationLineStateCreateInfoKHR& copy_src);
+    safe_VkPipelineRasterizationLineStateCreateInfoKHR();
+    ~safe_VkPipelineRasterizationLineStateCreateInfoKHR();
+    void initialize(const VkPipelineRasterizationLineStateCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineRasterizationLineStateCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineRasterizationLineStateCreateInfoKHR* ptr() {
+        return reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoKHR*>(this);
+    }
+    VkPipelineRasterizationLineStateCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoKHR const*>(this);
+    }
+};
+struct safe_VkCalibratedTimestampInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkTimeDomainKHR timeDomain;
+
+    safe_VkCalibratedTimestampInfoKHR(const VkCalibratedTimestampInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    safe_VkCalibratedTimestampInfoKHR(const safe_VkCalibratedTimestampInfoKHR& copy_src);
+    safe_VkCalibratedTimestampInfoKHR& operator=(const safe_VkCalibratedTimestampInfoKHR& copy_src);
+    safe_VkCalibratedTimestampInfoKHR();
+    ~safe_VkCalibratedTimestampInfoKHR();
+    void initialize(const VkCalibratedTimestampInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCalibratedTimestampInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkCalibratedTimestampInfoKHR* ptr() { return reinterpret_cast<VkCalibratedTimestampInfoKHR*>(this); }
+    VkCalibratedTimestampInfoKHR const* ptr() const { return reinterpret_cast<VkCalibratedTimestampInfoKHR const*>(this); }
+};
+struct safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderExpectAssume;
+
+    safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR(const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR(const safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR& operator=(
+        const safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR();
+    ~safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR();
+    void initialize(const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderExpectAssumeFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceShaderExpectAssumeFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderExpectAssumeFeaturesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceMaintenance6FeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 maintenance6;
+
+    safe_VkPhysicalDeviceMaintenance6FeaturesKHR(const VkPhysicalDeviceMaintenance6FeaturesKHR* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceMaintenance6FeaturesKHR(const safe_VkPhysicalDeviceMaintenance6FeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceMaintenance6FeaturesKHR& operator=(const safe_VkPhysicalDeviceMaintenance6FeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceMaintenance6FeaturesKHR();
+    ~safe_VkPhysicalDeviceMaintenance6FeaturesKHR();
+    void initialize(const VkPhysicalDeviceMaintenance6FeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMaintenance6FeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMaintenance6FeaturesKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceMaintenance6FeaturesKHR*>(this); }
+    VkPhysicalDeviceMaintenance6FeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMaintenance6FeaturesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceMaintenance6PropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 blockTexelViewCompatibleMultipleLayers;
+    uint32_t maxCombinedImageSamplerDescriptorCount;
+    VkBool32 fragmentShadingRateClampCombinerInputs;
+
+    safe_VkPhysicalDeviceMaintenance6PropertiesKHR(const VkPhysicalDeviceMaintenance6PropertiesKHR* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceMaintenance6PropertiesKHR(const safe_VkPhysicalDeviceMaintenance6PropertiesKHR& copy_src);
+    safe_VkPhysicalDeviceMaintenance6PropertiesKHR& operator=(const safe_VkPhysicalDeviceMaintenance6PropertiesKHR& copy_src);
+    safe_VkPhysicalDeviceMaintenance6PropertiesKHR();
+    ~safe_VkPhysicalDeviceMaintenance6PropertiesKHR();
+    void initialize(const VkPhysicalDeviceMaintenance6PropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMaintenance6PropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMaintenance6PropertiesKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceMaintenance6PropertiesKHR*>(this); }
+    VkPhysicalDeviceMaintenance6PropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMaintenance6PropertiesKHR const*>(this);
+    }
+};
+struct safe_VkBindMemoryStatusKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkResult* pResult{};
+
+    safe_VkBindMemoryStatusKHR(const VkBindMemoryStatusKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkBindMemoryStatusKHR(const safe_VkBindMemoryStatusKHR& copy_src);
+    safe_VkBindMemoryStatusKHR& operator=(const safe_VkBindMemoryStatusKHR& copy_src);
+    safe_VkBindMemoryStatusKHR();
+    ~safe_VkBindMemoryStatusKHR();
+    void initialize(const VkBindMemoryStatusKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBindMemoryStatusKHR* copy_src, PNextCopyState* copy_state = {});
+    VkBindMemoryStatusKHR* ptr() { return reinterpret_cast<VkBindMemoryStatusKHR*>(this); }
+    VkBindMemoryStatusKHR const* ptr() const { return reinterpret_cast<VkBindMemoryStatusKHR const*>(this); }
+};
+struct safe_VkBindDescriptorSetsInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkShaderStageFlags stageFlags;
+    VkPipelineLayout layout;
+    uint32_t firstSet;
+    uint32_t descriptorSetCount;
+    VkDescriptorSet* pDescriptorSets{};
+    uint32_t dynamicOffsetCount;
+    const uint32_t* pDynamicOffsets{};
+
+    safe_VkBindDescriptorSetsInfoKHR(const VkBindDescriptorSetsInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    safe_VkBindDescriptorSetsInfoKHR(const safe_VkBindDescriptorSetsInfoKHR& copy_src);
+    safe_VkBindDescriptorSetsInfoKHR& operator=(const safe_VkBindDescriptorSetsInfoKHR& copy_src);
+    safe_VkBindDescriptorSetsInfoKHR();
+    ~safe_VkBindDescriptorSetsInfoKHR();
+    void initialize(const VkBindDescriptorSetsInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBindDescriptorSetsInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkBindDescriptorSetsInfoKHR* ptr() { return reinterpret_cast<VkBindDescriptorSetsInfoKHR*>(this); }
+    VkBindDescriptorSetsInfoKHR const* ptr() const { return reinterpret_cast<VkBindDescriptorSetsInfoKHR const*>(this); }
+};
+struct safe_VkPushConstantsInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineLayout layout;
+    VkShaderStageFlags stageFlags;
+    uint32_t offset;
+    uint32_t size;
+    const void* pValues{};
+
+    safe_VkPushConstantsInfoKHR(const VkPushConstantsInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPushConstantsInfoKHR(const safe_VkPushConstantsInfoKHR& copy_src);
+    safe_VkPushConstantsInfoKHR& operator=(const safe_VkPushConstantsInfoKHR& copy_src);
+    safe_VkPushConstantsInfoKHR();
+    ~safe_VkPushConstantsInfoKHR();
+    void initialize(const VkPushConstantsInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPushConstantsInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPushConstantsInfoKHR* ptr() { return reinterpret_cast<VkPushConstantsInfoKHR*>(this); }
+    VkPushConstantsInfoKHR const* ptr() const { return reinterpret_cast<VkPushConstantsInfoKHR const*>(this); }
+};
+struct safe_VkPushDescriptorSetInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkShaderStageFlags stageFlags;
+    VkPipelineLayout layout;
+    uint32_t set;
+    uint32_t descriptorWriteCount;
+    safe_VkWriteDescriptorSet* pDescriptorWrites{};
+
+    safe_VkPushDescriptorSetInfoKHR(const VkPushDescriptorSetInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    safe_VkPushDescriptorSetInfoKHR(const safe_VkPushDescriptorSetInfoKHR& copy_src);
+    safe_VkPushDescriptorSetInfoKHR& operator=(const safe_VkPushDescriptorSetInfoKHR& copy_src);
+    safe_VkPushDescriptorSetInfoKHR();
+    ~safe_VkPushDescriptorSetInfoKHR();
+    void initialize(const VkPushDescriptorSetInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPushDescriptorSetInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPushDescriptorSetInfoKHR* ptr() { return reinterpret_cast<VkPushDescriptorSetInfoKHR*>(this); }
+    VkPushDescriptorSetInfoKHR const* ptr() const { return reinterpret_cast<VkPushDescriptorSetInfoKHR const*>(this); }
+};
+struct safe_VkPushDescriptorSetWithTemplateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDescriptorUpdateTemplate descriptorUpdateTemplate;
+    VkPipelineLayout layout;
+    uint32_t set;
+    const void* pData{};
+
+    safe_VkPushDescriptorSetWithTemplateInfoKHR(const VkPushDescriptorSetWithTemplateInfoKHR* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPushDescriptorSetWithTemplateInfoKHR(const safe_VkPushDescriptorSetWithTemplateInfoKHR& copy_src);
+    safe_VkPushDescriptorSetWithTemplateInfoKHR& operator=(const safe_VkPushDescriptorSetWithTemplateInfoKHR& copy_src);
+    safe_VkPushDescriptorSetWithTemplateInfoKHR();
+    ~safe_VkPushDescriptorSetWithTemplateInfoKHR();
+    void initialize(const VkPushDescriptorSetWithTemplateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPushDescriptorSetWithTemplateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPushDescriptorSetWithTemplateInfoKHR* ptr() { return reinterpret_cast<VkPushDescriptorSetWithTemplateInfoKHR*>(this); }
+    VkPushDescriptorSetWithTemplateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkPushDescriptorSetWithTemplateInfoKHR const*>(this);
+    }
+};
+struct safe_VkSetDescriptorBufferOffsetsInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkShaderStageFlags stageFlags;
+    VkPipelineLayout layout;
+    uint32_t firstSet;
+    uint32_t setCount;
+    const uint32_t* pBufferIndices{};
+    const VkDeviceSize* pOffsets{};
+
+    safe_VkSetDescriptorBufferOffsetsInfoEXT(const VkSetDescriptorBufferOffsetsInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkSetDescriptorBufferOffsetsInfoEXT(const safe_VkSetDescriptorBufferOffsetsInfoEXT& copy_src);
+    safe_VkSetDescriptorBufferOffsetsInfoEXT& operator=(const safe_VkSetDescriptorBufferOffsetsInfoEXT& copy_src);
+    safe_VkSetDescriptorBufferOffsetsInfoEXT();
+    ~safe_VkSetDescriptorBufferOffsetsInfoEXT();
+    void initialize(const VkSetDescriptorBufferOffsetsInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSetDescriptorBufferOffsetsInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSetDescriptorBufferOffsetsInfoEXT* ptr() { return reinterpret_cast<VkSetDescriptorBufferOffsetsInfoEXT*>(this); }
+    VkSetDescriptorBufferOffsetsInfoEXT const* ptr() const {
+        return reinterpret_cast<VkSetDescriptorBufferOffsetsInfoEXT const*>(this);
+    }
+};
+struct safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkShaderStageFlags stageFlags;
+    VkPipelineLayout layout;
+    uint32_t set;
+
+    safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT(const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT(const safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT& copy_src);
+    safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT& operator=(
+        const safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT& copy_src);
+    safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT();
+    ~safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT();
+    void initialize(const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkBindDescriptorBufferEmbeddedSamplersInfoEXT* ptr() {
+        return reinterpret_cast<VkBindDescriptorBufferEmbeddedSamplersInfoEXT*>(this);
+    }
+    VkBindDescriptorBufferEmbeddedSamplersInfoEXT const* ptr() const {
+        return reinterpret_cast<VkBindDescriptorBufferEmbeddedSamplersInfoEXT const*>(this);
+    }
+};
+struct safe_VkDebugReportCallbackCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDebugReportFlagsEXT flags;
+    PFN_vkDebugReportCallbackEXT pfnCallback;
+    void* pUserData{};
+
+    safe_VkDebugReportCallbackCreateInfoEXT(const VkDebugReportCallbackCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                            bool copy_pnext = true);
+    safe_VkDebugReportCallbackCreateInfoEXT(const safe_VkDebugReportCallbackCreateInfoEXT& copy_src);
+    safe_VkDebugReportCallbackCreateInfoEXT& operator=(const safe_VkDebugReportCallbackCreateInfoEXT& copy_src);
+    safe_VkDebugReportCallbackCreateInfoEXT();
+    ~safe_VkDebugReportCallbackCreateInfoEXT();
+    void initialize(const VkDebugReportCallbackCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDebugReportCallbackCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDebugReportCallbackCreateInfoEXT* ptr() { return reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(this); }
+    VkDebugReportCallbackCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkDebugReportCallbackCreateInfoEXT const*>(this);
+    }
+};
+struct safe_VkPipelineRasterizationStateRasterizationOrderAMD {
+    VkStructureType sType;
+    const void* pNext{};
+    VkRasterizationOrderAMD rasterizationOrder;
+
+    safe_VkPipelineRasterizationStateRasterizationOrderAMD(const VkPipelineRasterizationStateRasterizationOrderAMD* in_struct,
+                                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineRasterizationStateRasterizationOrderAMD(const safe_VkPipelineRasterizationStateRasterizationOrderAMD& copy_src);
+    safe_VkPipelineRasterizationStateRasterizationOrderAMD& operator=(
+        const safe_VkPipelineRasterizationStateRasterizationOrderAMD& copy_src);
+    safe_VkPipelineRasterizationStateRasterizationOrderAMD();
+    ~safe_VkPipelineRasterizationStateRasterizationOrderAMD();
+    void initialize(const VkPipelineRasterizationStateRasterizationOrderAMD* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineRasterizationStateRasterizationOrderAMD* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineRasterizationStateRasterizationOrderAMD* ptr() {
+        return reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(this);
+    }
+    VkPipelineRasterizationStateRasterizationOrderAMD const* ptr() const {
+        return reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD const*>(this);
+    }
+};
+struct safe_VkDebugMarkerObjectNameInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDebugReportObjectTypeEXT objectType;
+    uint64_t object;
+    const char* pObjectName{};
+
+    safe_VkDebugMarkerObjectNameInfoEXT(const VkDebugMarkerObjectNameInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkDebugMarkerObjectNameInfoEXT(const safe_VkDebugMarkerObjectNameInfoEXT& copy_src);
+    safe_VkDebugMarkerObjectNameInfoEXT& operator=(const safe_VkDebugMarkerObjectNameInfoEXT& copy_src);
+    safe_VkDebugMarkerObjectNameInfoEXT();
+    ~safe_VkDebugMarkerObjectNameInfoEXT();
+    void initialize(const VkDebugMarkerObjectNameInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDebugMarkerObjectNameInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDebugMarkerObjectNameInfoEXT* ptr() { return reinterpret_cast<VkDebugMarkerObjectNameInfoEXT*>(this); }
+    VkDebugMarkerObjectNameInfoEXT const* ptr() const { return reinterpret_cast<VkDebugMarkerObjectNameInfoEXT const*>(this); }
+};
+struct safe_VkDebugMarkerObjectTagInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDebugReportObjectTypeEXT objectType;
+    uint64_t object;
+    uint64_t tagName;
+    size_t tagSize;
+    const void* pTag{};
+
+    safe_VkDebugMarkerObjectTagInfoEXT(const VkDebugMarkerObjectTagInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    safe_VkDebugMarkerObjectTagInfoEXT(const safe_VkDebugMarkerObjectTagInfoEXT& copy_src);
+    safe_VkDebugMarkerObjectTagInfoEXT& operator=(const safe_VkDebugMarkerObjectTagInfoEXT& copy_src);
+    safe_VkDebugMarkerObjectTagInfoEXT();
+    ~safe_VkDebugMarkerObjectTagInfoEXT();
+    void initialize(const VkDebugMarkerObjectTagInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDebugMarkerObjectTagInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDebugMarkerObjectTagInfoEXT* ptr() { return reinterpret_cast<VkDebugMarkerObjectTagInfoEXT*>(this); }
+    VkDebugMarkerObjectTagInfoEXT const* ptr() const { return reinterpret_cast<VkDebugMarkerObjectTagInfoEXT const*>(this); }
+};
+struct safe_VkDebugMarkerMarkerInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    const char* pMarkerName{};
+    float color[4];
+
+    safe_VkDebugMarkerMarkerInfoEXT(const VkDebugMarkerMarkerInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    safe_VkDebugMarkerMarkerInfoEXT(const safe_VkDebugMarkerMarkerInfoEXT& copy_src);
+    safe_VkDebugMarkerMarkerInfoEXT& operator=(const safe_VkDebugMarkerMarkerInfoEXT& copy_src);
+    safe_VkDebugMarkerMarkerInfoEXT();
+    ~safe_VkDebugMarkerMarkerInfoEXT();
+    void initialize(const VkDebugMarkerMarkerInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDebugMarkerMarkerInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDebugMarkerMarkerInfoEXT* ptr() { return reinterpret_cast<VkDebugMarkerMarkerInfoEXT*>(this); }
+    VkDebugMarkerMarkerInfoEXT const* ptr() const { return reinterpret_cast<VkDebugMarkerMarkerInfoEXT const*>(this); }
+};
+struct safe_VkDedicatedAllocationImageCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 dedicatedAllocation;
+
+    safe_VkDedicatedAllocationImageCreateInfoNV(const VkDedicatedAllocationImageCreateInfoNV* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDedicatedAllocationImageCreateInfoNV(const safe_VkDedicatedAllocationImageCreateInfoNV& copy_src);
+    safe_VkDedicatedAllocationImageCreateInfoNV& operator=(const safe_VkDedicatedAllocationImageCreateInfoNV& copy_src);
+    safe_VkDedicatedAllocationImageCreateInfoNV();
+    ~safe_VkDedicatedAllocationImageCreateInfoNV();
+    void initialize(const VkDedicatedAllocationImageCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDedicatedAllocationImageCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkDedicatedAllocationImageCreateInfoNV* ptr() { return reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(this); }
+    VkDedicatedAllocationImageCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV const*>(this);
+    }
+};
+struct safe_VkDedicatedAllocationBufferCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 dedicatedAllocation;
+
+    safe_VkDedicatedAllocationBufferCreateInfoNV(const VkDedicatedAllocationBufferCreateInfoNV* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDedicatedAllocationBufferCreateInfoNV(const safe_VkDedicatedAllocationBufferCreateInfoNV& copy_src);
+    safe_VkDedicatedAllocationBufferCreateInfoNV& operator=(const safe_VkDedicatedAllocationBufferCreateInfoNV& copy_src);
+    safe_VkDedicatedAllocationBufferCreateInfoNV();
+    ~safe_VkDedicatedAllocationBufferCreateInfoNV();
+    void initialize(const VkDedicatedAllocationBufferCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDedicatedAllocationBufferCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkDedicatedAllocationBufferCreateInfoNV* ptr() { return reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(this); }
+    VkDedicatedAllocationBufferCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV const*>(this);
+    }
+};
+struct safe_VkDedicatedAllocationMemoryAllocateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImage image;
+    VkBuffer buffer;
+
+    safe_VkDedicatedAllocationMemoryAllocateInfoNV(const VkDedicatedAllocationMemoryAllocateInfoNV* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDedicatedAllocationMemoryAllocateInfoNV(const safe_VkDedicatedAllocationMemoryAllocateInfoNV& copy_src);
+    safe_VkDedicatedAllocationMemoryAllocateInfoNV& operator=(const safe_VkDedicatedAllocationMemoryAllocateInfoNV& copy_src);
+    safe_VkDedicatedAllocationMemoryAllocateInfoNV();
+    ~safe_VkDedicatedAllocationMemoryAllocateInfoNV();
+    void initialize(const VkDedicatedAllocationMemoryAllocateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDedicatedAllocationMemoryAllocateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkDedicatedAllocationMemoryAllocateInfoNV* ptr() { return reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(this); }
+    VkDedicatedAllocationMemoryAllocateInfoNV const* ptr() const {
+        return reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 transformFeedback;
+    VkBool32 geometryStreams;
+
+    safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT(const VkPhysicalDeviceTransformFeedbackFeaturesEXT* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT(const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT& operator=(const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT();
+    ~safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT();
+    void initialize(const VkPhysicalDeviceTransformFeedbackFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceTransformFeedbackFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceTransformFeedbackFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxTransformFeedbackStreams;
+    uint32_t maxTransformFeedbackBuffers;
+    VkDeviceSize maxTransformFeedbackBufferSize;
+    uint32_t maxTransformFeedbackStreamDataSize;
+    uint32_t maxTransformFeedbackBufferDataSize;
+    uint32_t maxTransformFeedbackBufferDataStride;
+    VkBool32 transformFeedbackQueries;
+    VkBool32 transformFeedbackStreamsLinesTriangles;
+    VkBool32 transformFeedbackRasterizationStreamSelect;
+    VkBool32 transformFeedbackDraw;
+
+    safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT(const VkPhysicalDeviceTransformFeedbackPropertiesEXT* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT(const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT& operator=(
+        const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT();
+    ~safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT();
+    void initialize(const VkPhysicalDeviceTransformFeedbackPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceTransformFeedbackPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceTransformFeedbackPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT const*>(this);
+    }
+};
+struct safe_VkPipelineRasterizationStateStreamCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineRasterizationStateStreamCreateFlagsEXT flags;
+    uint32_t rasterizationStream;
+
+    safe_VkPipelineRasterizationStateStreamCreateInfoEXT(const VkPipelineRasterizationStateStreamCreateInfoEXT* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineRasterizationStateStreamCreateInfoEXT(const safe_VkPipelineRasterizationStateStreamCreateInfoEXT& copy_src);
+    safe_VkPipelineRasterizationStateStreamCreateInfoEXT& operator=(
+        const safe_VkPipelineRasterizationStateStreamCreateInfoEXT& copy_src);
+    safe_VkPipelineRasterizationStateStreamCreateInfoEXT();
+    ~safe_VkPipelineRasterizationStateStreamCreateInfoEXT();
+    void initialize(const VkPipelineRasterizationStateStreamCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineRasterizationStateStreamCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineRasterizationStateStreamCreateInfoEXT* ptr() {
+        return reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>(this);
+    }
+    VkPipelineRasterizationStateStreamCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT const*>(this);
+    }
+};
+struct safe_VkCuModuleCreateInfoNVX {
+    VkStructureType sType;
+    const void* pNext{};
+    size_t dataSize;
+    const void* pData{};
+
+    safe_VkCuModuleCreateInfoNVX(const VkCuModuleCreateInfoNVX* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkCuModuleCreateInfoNVX(const safe_VkCuModuleCreateInfoNVX& copy_src);
+    safe_VkCuModuleCreateInfoNVX& operator=(const safe_VkCuModuleCreateInfoNVX& copy_src);
+    safe_VkCuModuleCreateInfoNVX();
+    ~safe_VkCuModuleCreateInfoNVX();
+    void initialize(const VkCuModuleCreateInfoNVX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCuModuleCreateInfoNVX* copy_src, PNextCopyState* copy_state = {});
+    VkCuModuleCreateInfoNVX* ptr() { return reinterpret_cast<VkCuModuleCreateInfoNVX*>(this); }
+    VkCuModuleCreateInfoNVX const* ptr() const { return reinterpret_cast<VkCuModuleCreateInfoNVX const*>(this); }
+};
+struct safe_VkCuFunctionCreateInfoNVX {
+    VkStructureType sType;
+    const void* pNext{};
+    VkCuModuleNVX module;
+    const char* pName{};
+
+    safe_VkCuFunctionCreateInfoNVX(const VkCuFunctionCreateInfoNVX* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    safe_VkCuFunctionCreateInfoNVX(const safe_VkCuFunctionCreateInfoNVX& copy_src);
+    safe_VkCuFunctionCreateInfoNVX& operator=(const safe_VkCuFunctionCreateInfoNVX& copy_src);
+    safe_VkCuFunctionCreateInfoNVX();
+    ~safe_VkCuFunctionCreateInfoNVX();
+    void initialize(const VkCuFunctionCreateInfoNVX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCuFunctionCreateInfoNVX* copy_src, PNextCopyState* copy_state = {});
+    VkCuFunctionCreateInfoNVX* ptr() { return reinterpret_cast<VkCuFunctionCreateInfoNVX*>(this); }
+    VkCuFunctionCreateInfoNVX const* ptr() const { return reinterpret_cast<VkCuFunctionCreateInfoNVX const*>(this); }
+};
+struct safe_VkCuLaunchInfoNVX {
+    VkStructureType sType;
+    const void* pNext{};
+    VkCuFunctionNVX function;
+    uint32_t gridDimX;
+    uint32_t gridDimY;
+    uint32_t gridDimZ;
+    uint32_t blockDimX;
+    uint32_t blockDimY;
+    uint32_t blockDimZ;
+    uint32_t sharedMemBytes;
+    size_t paramCount;
+    const void* const* pParams{};
+    size_t extraCount;
+    const void* const* pExtras{};
+
+    safe_VkCuLaunchInfoNVX(const VkCuLaunchInfoNVX* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkCuLaunchInfoNVX(const safe_VkCuLaunchInfoNVX& copy_src);
+    safe_VkCuLaunchInfoNVX& operator=(const safe_VkCuLaunchInfoNVX& copy_src);
+    safe_VkCuLaunchInfoNVX();
+    ~safe_VkCuLaunchInfoNVX();
+    void initialize(const VkCuLaunchInfoNVX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCuLaunchInfoNVX* copy_src, PNextCopyState* copy_state = {});
+    VkCuLaunchInfoNVX* ptr() { return reinterpret_cast<VkCuLaunchInfoNVX*>(this); }
+    VkCuLaunchInfoNVX const* ptr() const { return reinterpret_cast<VkCuLaunchInfoNVX const*>(this); }
+};
+struct safe_VkImageViewHandleInfoNVX {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageView imageView;
+    VkDescriptorType descriptorType;
+    VkSampler sampler;
+
+    safe_VkImageViewHandleInfoNVX(const VkImageViewHandleInfoNVX* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    safe_VkImageViewHandleInfoNVX(const safe_VkImageViewHandleInfoNVX& copy_src);
+    safe_VkImageViewHandleInfoNVX& operator=(const safe_VkImageViewHandleInfoNVX& copy_src);
+    safe_VkImageViewHandleInfoNVX();
+    ~safe_VkImageViewHandleInfoNVX();
+    void initialize(const VkImageViewHandleInfoNVX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageViewHandleInfoNVX* copy_src, PNextCopyState* copy_state = {});
+    VkImageViewHandleInfoNVX* ptr() { return reinterpret_cast<VkImageViewHandleInfoNVX*>(this); }
+    VkImageViewHandleInfoNVX const* ptr() const { return reinterpret_cast<VkImageViewHandleInfoNVX const*>(this); }
+};
+struct safe_VkImageViewAddressPropertiesNVX {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceAddress deviceAddress;
+    VkDeviceSize size;
+
+    safe_VkImageViewAddressPropertiesNVX(const VkImageViewAddressPropertiesNVX* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkImageViewAddressPropertiesNVX(const safe_VkImageViewAddressPropertiesNVX& copy_src);
+    safe_VkImageViewAddressPropertiesNVX& operator=(const safe_VkImageViewAddressPropertiesNVX& copy_src);
+    safe_VkImageViewAddressPropertiesNVX();
+    ~safe_VkImageViewAddressPropertiesNVX();
+    void initialize(const VkImageViewAddressPropertiesNVX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageViewAddressPropertiesNVX* copy_src, PNextCopyState* copy_state = {});
+    VkImageViewAddressPropertiesNVX* ptr() { return reinterpret_cast<VkImageViewAddressPropertiesNVX*>(this); }
+    VkImageViewAddressPropertiesNVX const* ptr() const { return reinterpret_cast<VkImageViewAddressPropertiesNVX const*>(this); }
+};
+struct safe_VkTextureLODGatherFormatPropertiesAMD {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 supportsTextureGatherLODBiasAMD;
+
+    safe_VkTextureLODGatherFormatPropertiesAMD(const VkTextureLODGatherFormatPropertiesAMD* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkTextureLODGatherFormatPropertiesAMD(const safe_VkTextureLODGatherFormatPropertiesAMD& copy_src);
+    safe_VkTextureLODGatherFormatPropertiesAMD& operator=(const safe_VkTextureLODGatherFormatPropertiesAMD& copy_src);
+    safe_VkTextureLODGatherFormatPropertiesAMD();
+    ~safe_VkTextureLODGatherFormatPropertiesAMD();
+    void initialize(const VkTextureLODGatherFormatPropertiesAMD* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkTextureLODGatherFormatPropertiesAMD* copy_src, PNextCopyState* copy_state = {});
+    VkTextureLODGatherFormatPropertiesAMD* ptr() { return reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>(this); }
+    VkTextureLODGatherFormatPropertiesAMD const* ptr() const {
+        return reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD const*>(this);
+    }
+};
+#ifdef VK_USE_PLATFORM_GGP
+struct safe_VkStreamDescriptorSurfaceCreateInfoGGP {
+    VkStructureType sType;
+    const void* pNext{};
+    VkStreamDescriptorSurfaceCreateFlagsGGP flags;
+    GgpStreamDescriptor streamDescriptor;
+
+    safe_VkStreamDescriptorSurfaceCreateInfoGGP(const VkStreamDescriptorSurfaceCreateInfoGGP* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkStreamDescriptorSurfaceCreateInfoGGP(const safe_VkStreamDescriptorSurfaceCreateInfoGGP& copy_src);
+    safe_VkStreamDescriptorSurfaceCreateInfoGGP& operator=(const safe_VkStreamDescriptorSurfaceCreateInfoGGP& copy_src);
+    safe_VkStreamDescriptorSurfaceCreateInfoGGP();
+    ~safe_VkStreamDescriptorSurfaceCreateInfoGGP();
+    void initialize(const VkStreamDescriptorSurfaceCreateInfoGGP* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkStreamDescriptorSurfaceCreateInfoGGP* copy_src, PNextCopyState* copy_state = {});
+    VkStreamDescriptorSurfaceCreateInfoGGP* ptr() { return reinterpret_cast<VkStreamDescriptorSurfaceCreateInfoGGP*>(this); }
+    VkStreamDescriptorSurfaceCreateInfoGGP const* ptr() const {
+        return reinterpret_cast<VkStreamDescriptorSurfaceCreateInfoGGP const*>(this);
+    }
+};
+#endif  // VK_USE_PLATFORM_GGP
+struct safe_VkPhysicalDeviceCornerSampledImageFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 cornerSampledImage;
+
+    safe_VkPhysicalDeviceCornerSampledImageFeaturesNV(const VkPhysicalDeviceCornerSampledImageFeaturesNV* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceCornerSampledImageFeaturesNV(const safe_VkPhysicalDeviceCornerSampledImageFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceCornerSampledImageFeaturesNV& operator=(const safe_VkPhysicalDeviceCornerSampledImageFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceCornerSampledImageFeaturesNV();
+    ~safe_VkPhysicalDeviceCornerSampledImageFeaturesNV();
+    void initialize(const VkPhysicalDeviceCornerSampledImageFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceCornerSampledImageFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCornerSampledImageFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceCornerSampledImageFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV const*>(this);
+    }
+};
+struct safe_VkExternalMemoryImageCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalMemoryHandleTypeFlagsNV handleTypes;
+
+    safe_VkExternalMemoryImageCreateInfoNV(const VkExternalMemoryImageCreateInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                           bool copy_pnext = true);
+    safe_VkExternalMemoryImageCreateInfoNV(const safe_VkExternalMemoryImageCreateInfoNV& copy_src);
+    safe_VkExternalMemoryImageCreateInfoNV& operator=(const safe_VkExternalMemoryImageCreateInfoNV& copy_src);
+    safe_VkExternalMemoryImageCreateInfoNV();
+    ~safe_VkExternalMemoryImageCreateInfoNV();
+    void initialize(const VkExternalMemoryImageCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExternalMemoryImageCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkExternalMemoryImageCreateInfoNV* ptr() { return reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(this); }
+    VkExternalMemoryImageCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkExternalMemoryImageCreateInfoNV const*>(this);
+    }
+};
+struct safe_VkExportMemoryAllocateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalMemoryHandleTypeFlagsNV handleTypes;
+
+    safe_VkExportMemoryAllocateInfoNV(const VkExportMemoryAllocateInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    safe_VkExportMemoryAllocateInfoNV(const safe_VkExportMemoryAllocateInfoNV& copy_src);
+    safe_VkExportMemoryAllocateInfoNV& operator=(const safe_VkExportMemoryAllocateInfoNV& copy_src);
+    safe_VkExportMemoryAllocateInfoNV();
+    ~safe_VkExportMemoryAllocateInfoNV();
+    void initialize(const VkExportMemoryAllocateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExportMemoryAllocateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkExportMemoryAllocateInfoNV* ptr() { return reinterpret_cast<VkExportMemoryAllocateInfoNV*>(this); }
+    VkExportMemoryAllocateInfoNV const* ptr() const { return reinterpret_cast<VkExportMemoryAllocateInfoNV const*>(this); }
+};
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+struct safe_VkImportMemoryWin32HandleInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalMemoryHandleTypeFlagsNV handleType;
+    HANDLE handle;
+
+    safe_VkImportMemoryWin32HandleInfoNV(const VkImportMemoryWin32HandleInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkImportMemoryWin32HandleInfoNV(const safe_VkImportMemoryWin32HandleInfoNV& copy_src);
+    safe_VkImportMemoryWin32HandleInfoNV& operator=(const safe_VkImportMemoryWin32HandleInfoNV& copy_src);
+    safe_VkImportMemoryWin32HandleInfoNV();
+    ~safe_VkImportMemoryWin32HandleInfoNV();
+    void initialize(const VkImportMemoryWin32HandleInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImportMemoryWin32HandleInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkImportMemoryWin32HandleInfoNV* ptr() { return reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(this); }
+    VkImportMemoryWin32HandleInfoNV const* ptr() const { return reinterpret_cast<VkImportMemoryWin32HandleInfoNV const*>(this); }
+};
+struct safe_VkExportMemoryWin32HandleInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    const SECURITY_ATTRIBUTES* pAttributes{};
+    DWORD dwAccess;
+
+    safe_VkExportMemoryWin32HandleInfoNV(const VkExportMemoryWin32HandleInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkExportMemoryWin32HandleInfoNV(const safe_VkExportMemoryWin32HandleInfoNV& copy_src);
+    safe_VkExportMemoryWin32HandleInfoNV& operator=(const safe_VkExportMemoryWin32HandleInfoNV& copy_src);
+    safe_VkExportMemoryWin32HandleInfoNV();
+    ~safe_VkExportMemoryWin32HandleInfoNV();
+    void initialize(const VkExportMemoryWin32HandleInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExportMemoryWin32HandleInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkExportMemoryWin32HandleInfoNV* ptr() { return reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(this); }
+    VkExportMemoryWin32HandleInfoNV const* ptr() const { return reinterpret_cast<VkExportMemoryWin32HandleInfoNV const*>(this); }
+};
+struct safe_VkWin32KeyedMutexAcquireReleaseInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t acquireCount;
+    VkDeviceMemory* pAcquireSyncs{};
+    const uint64_t* pAcquireKeys{};
+    const uint32_t* pAcquireTimeoutMilliseconds{};
+    uint32_t releaseCount;
+    VkDeviceMemory* pReleaseSyncs{};
+    const uint64_t* pReleaseKeys{};
+
+    safe_VkWin32KeyedMutexAcquireReleaseInfoNV(const VkWin32KeyedMutexAcquireReleaseInfoNV* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkWin32KeyedMutexAcquireReleaseInfoNV(const safe_VkWin32KeyedMutexAcquireReleaseInfoNV& copy_src);
+    safe_VkWin32KeyedMutexAcquireReleaseInfoNV& operator=(const safe_VkWin32KeyedMutexAcquireReleaseInfoNV& copy_src);
+    safe_VkWin32KeyedMutexAcquireReleaseInfoNV();
+    ~safe_VkWin32KeyedMutexAcquireReleaseInfoNV();
+    void initialize(const VkWin32KeyedMutexAcquireReleaseInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkWin32KeyedMutexAcquireReleaseInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkWin32KeyedMutexAcquireReleaseInfoNV* ptr() { return reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(this); }
+    VkWin32KeyedMutexAcquireReleaseInfoNV const* ptr() const {
+        return reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV const*>(this);
+    }
+};
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+struct safe_VkValidationFlagsEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t disabledValidationCheckCount;
+    const VkValidationCheckEXT* pDisabledValidationChecks{};
+
+    safe_VkValidationFlagsEXT(const VkValidationFlagsEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkValidationFlagsEXT(const safe_VkValidationFlagsEXT& copy_src);
+    safe_VkValidationFlagsEXT& operator=(const safe_VkValidationFlagsEXT& copy_src);
+    safe_VkValidationFlagsEXT();
+    ~safe_VkValidationFlagsEXT();
+    void initialize(const VkValidationFlagsEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkValidationFlagsEXT* copy_src, PNextCopyState* copy_state = {});
+    VkValidationFlagsEXT* ptr() { return reinterpret_cast<VkValidationFlagsEXT*>(this); }
+    VkValidationFlagsEXT const* ptr() const { return reinterpret_cast<VkValidationFlagsEXT const*>(this); }
+};
+#ifdef VK_USE_PLATFORM_VI_NN
+struct safe_VkViSurfaceCreateInfoNN {
+    VkStructureType sType;
+    const void* pNext{};
+    VkViSurfaceCreateFlagsNN flags;
+    void* window{};
+
+    safe_VkViSurfaceCreateInfoNN(const VkViSurfaceCreateInfoNN* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkViSurfaceCreateInfoNN(const safe_VkViSurfaceCreateInfoNN& copy_src);
+    safe_VkViSurfaceCreateInfoNN& operator=(const safe_VkViSurfaceCreateInfoNN& copy_src);
+    safe_VkViSurfaceCreateInfoNN();
+    ~safe_VkViSurfaceCreateInfoNN();
+    void initialize(const VkViSurfaceCreateInfoNN* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkViSurfaceCreateInfoNN* copy_src, PNextCopyState* copy_state = {});
+    VkViSurfaceCreateInfoNN* ptr() { return reinterpret_cast<VkViSurfaceCreateInfoNN*>(this); }
+    VkViSurfaceCreateInfoNN const* ptr() const { return reinterpret_cast<VkViSurfaceCreateInfoNN const*>(this); }
+};
+#endif  // VK_USE_PLATFORM_VI_NN
+struct safe_VkImageViewASTCDecodeModeEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkFormat decodeMode;
+
+    safe_VkImageViewASTCDecodeModeEXT(const VkImageViewASTCDecodeModeEXT* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    safe_VkImageViewASTCDecodeModeEXT(const safe_VkImageViewASTCDecodeModeEXT& copy_src);
+    safe_VkImageViewASTCDecodeModeEXT& operator=(const safe_VkImageViewASTCDecodeModeEXT& copy_src);
+    safe_VkImageViewASTCDecodeModeEXT();
+    ~safe_VkImageViewASTCDecodeModeEXT();
+    void initialize(const VkImageViewASTCDecodeModeEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageViewASTCDecodeModeEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImageViewASTCDecodeModeEXT* ptr() { return reinterpret_cast<VkImageViewASTCDecodeModeEXT*>(this); }
+    VkImageViewASTCDecodeModeEXT const* ptr() const { return reinterpret_cast<VkImageViewASTCDecodeModeEXT const*>(this); }
+};
+struct safe_VkPhysicalDeviceASTCDecodeFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 decodeModeSharedExponent;
+
+    safe_VkPhysicalDeviceASTCDecodeFeaturesEXT(const VkPhysicalDeviceASTCDecodeFeaturesEXT* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceASTCDecodeFeaturesEXT(const safe_VkPhysicalDeviceASTCDecodeFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceASTCDecodeFeaturesEXT& operator=(const safe_VkPhysicalDeviceASTCDecodeFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceASTCDecodeFeaturesEXT();
+    ~safe_VkPhysicalDeviceASTCDecodeFeaturesEXT();
+    void initialize(const VkPhysicalDeviceASTCDecodeFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceASTCDecodeFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceASTCDecodeFeaturesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>(this); }
+    VkPhysicalDeviceASTCDecodeFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 pipelineRobustness;
+
+    safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT(const VkPhysicalDevicePipelineRobustnessFeaturesEXT* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT(const safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT& copy_src);
+    safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT& operator=(
+        const safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT& copy_src);
+    safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT();
+    ~safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT();
+    void initialize(const VkPhysicalDevicePipelineRobustnessFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePipelineRobustnessFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePipelineRobustnessFeaturesEXT*>(this);
+    }
+    VkPhysicalDevicePipelineRobustnessFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePipelineRobustnessFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessStorageBuffers;
+    VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessUniformBuffers;
+    VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessVertexInputs;
+    VkPipelineRobustnessImageBehaviorEXT defaultRobustnessImages;
+
+    safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT(const VkPhysicalDevicePipelineRobustnessPropertiesEXT* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT(const safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT& copy_src);
+    safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT& operator=(
+        const safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT& copy_src);
+    safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT();
+    ~safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT();
+    void initialize(const VkPhysicalDevicePipelineRobustnessPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePipelineRobustnessPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePipelineRobustnessPropertiesEXT*>(this);
+    }
+    VkPhysicalDevicePipelineRobustnessPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePipelineRobustnessPropertiesEXT const*>(this);
+    }
+};
+struct safe_VkPipelineRobustnessCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineRobustnessBufferBehaviorEXT storageBuffers;
+    VkPipelineRobustnessBufferBehaviorEXT uniformBuffers;
+    VkPipelineRobustnessBufferBehaviorEXT vertexInputs;
+    VkPipelineRobustnessImageBehaviorEXT images;
+
+    safe_VkPipelineRobustnessCreateInfoEXT(const VkPipelineRobustnessCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                           bool copy_pnext = true);
+    safe_VkPipelineRobustnessCreateInfoEXT(const safe_VkPipelineRobustnessCreateInfoEXT& copy_src);
+    safe_VkPipelineRobustnessCreateInfoEXT& operator=(const safe_VkPipelineRobustnessCreateInfoEXT& copy_src);
+    safe_VkPipelineRobustnessCreateInfoEXT();
+    ~safe_VkPipelineRobustnessCreateInfoEXT();
+    void initialize(const VkPipelineRobustnessCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineRobustnessCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineRobustnessCreateInfoEXT* ptr() { return reinterpret_cast<VkPipelineRobustnessCreateInfoEXT*>(this); }
+    VkPipelineRobustnessCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkPipelineRobustnessCreateInfoEXT const*>(this);
+    }
+};
+struct safe_VkConditionalRenderingBeginInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBuffer buffer;
+    VkDeviceSize offset;
+    VkConditionalRenderingFlagsEXT flags;
+
+    safe_VkConditionalRenderingBeginInfoEXT(const VkConditionalRenderingBeginInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                            bool copy_pnext = true);
+    safe_VkConditionalRenderingBeginInfoEXT(const safe_VkConditionalRenderingBeginInfoEXT& copy_src);
+    safe_VkConditionalRenderingBeginInfoEXT& operator=(const safe_VkConditionalRenderingBeginInfoEXT& copy_src);
+    safe_VkConditionalRenderingBeginInfoEXT();
+    ~safe_VkConditionalRenderingBeginInfoEXT();
+    void initialize(const VkConditionalRenderingBeginInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkConditionalRenderingBeginInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkConditionalRenderingBeginInfoEXT* ptr() { return reinterpret_cast<VkConditionalRenderingBeginInfoEXT*>(this); }
+    VkConditionalRenderingBeginInfoEXT const* ptr() const {
+        return reinterpret_cast<VkConditionalRenderingBeginInfoEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 conditionalRendering;
+    VkBool32 inheritedConditionalRendering;
+
+    safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT(const VkPhysicalDeviceConditionalRenderingFeaturesEXT* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT(const safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT();
+    ~safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT();
+    void initialize(const VkPhysicalDeviceConditionalRenderingFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceConditionalRenderingFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceConditionalRenderingFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 conditionalRenderingEnable;
+
+    safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
+        const VkCommandBufferInheritanceConditionalRenderingInfoEXT* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
+        const safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT& copy_src);
+    safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT& operator=(
+        const safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT& copy_src);
+    safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT();
+    ~safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT();
+    void initialize(const VkCommandBufferInheritanceConditionalRenderingInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkCommandBufferInheritanceConditionalRenderingInfoEXT* ptr() {
+        return reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(this);
+    }
+    VkCommandBufferInheritanceConditionalRenderingInfoEXT const* ptr() const {
+        return reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT const*>(this);
+    }
+};
+struct safe_VkPipelineViewportWScalingStateCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 viewportWScalingEnable;
+    uint32_t viewportCount;
+    const VkViewportWScalingNV* pViewportWScalings{};
+
+    safe_VkPipelineViewportWScalingStateCreateInfoNV(const VkPipelineViewportWScalingStateCreateInfoNV* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineViewportWScalingStateCreateInfoNV(const safe_VkPipelineViewportWScalingStateCreateInfoNV& copy_src);
+    safe_VkPipelineViewportWScalingStateCreateInfoNV& operator=(const safe_VkPipelineViewportWScalingStateCreateInfoNV& copy_src);
+    safe_VkPipelineViewportWScalingStateCreateInfoNV();
+    ~safe_VkPipelineViewportWScalingStateCreateInfoNV();
+    void initialize(const VkPipelineViewportWScalingStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineViewportWScalingStateCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineViewportWScalingStateCreateInfoNV* ptr() {
+        return reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(this);
+    }
+    VkPipelineViewportWScalingStateCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV const*>(this);
+    }
+};
+struct safe_VkSurfaceCapabilities2EXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t minImageCount;
+    uint32_t maxImageCount;
+    VkExtent2D currentExtent;
+    VkExtent2D minImageExtent;
+    VkExtent2D maxImageExtent;
+    uint32_t maxImageArrayLayers;
+    VkSurfaceTransformFlagsKHR supportedTransforms;
+    VkSurfaceTransformFlagBitsKHR currentTransform;
+    VkCompositeAlphaFlagsKHR supportedCompositeAlpha;
+    VkImageUsageFlags supportedUsageFlags;
+    VkSurfaceCounterFlagsEXT supportedSurfaceCounters;
+
+    safe_VkSurfaceCapabilities2EXT(const VkSurfaceCapabilities2EXT* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    safe_VkSurfaceCapabilities2EXT(const safe_VkSurfaceCapabilities2EXT& copy_src);
+    safe_VkSurfaceCapabilities2EXT& operator=(const safe_VkSurfaceCapabilities2EXT& copy_src);
+    safe_VkSurfaceCapabilities2EXT();
+    ~safe_VkSurfaceCapabilities2EXT();
+    void initialize(const VkSurfaceCapabilities2EXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSurfaceCapabilities2EXT* copy_src, PNextCopyState* copy_state = {});
+    VkSurfaceCapabilities2EXT* ptr() { return reinterpret_cast<VkSurfaceCapabilities2EXT*>(this); }
+    VkSurfaceCapabilities2EXT const* ptr() const { return reinterpret_cast<VkSurfaceCapabilities2EXT const*>(this); }
+};
+struct safe_VkDisplayPowerInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDisplayPowerStateEXT powerState;
+
+    safe_VkDisplayPowerInfoEXT(const VkDisplayPowerInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDisplayPowerInfoEXT(const safe_VkDisplayPowerInfoEXT& copy_src);
+    safe_VkDisplayPowerInfoEXT& operator=(const safe_VkDisplayPowerInfoEXT& copy_src);
+    safe_VkDisplayPowerInfoEXT();
+    ~safe_VkDisplayPowerInfoEXT();
+    void initialize(const VkDisplayPowerInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDisplayPowerInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDisplayPowerInfoEXT* ptr() { return reinterpret_cast<VkDisplayPowerInfoEXT*>(this); }
+    VkDisplayPowerInfoEXT const* ptr() const { return reinterpret_cast<VkDisplayPowerInfoEXT const*>(this); }
+};
+struct safe_VkDeviceEventInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceEventTypeEXT deviceEvent;
+
+    safe_VkDeviceEventInfoEXT(const VkDeviceEventInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDeviceEventInfoEXT(const safe_VkDeviceEventInfoEXT& copy_src);
+    safe_VkDeviceEventInfoEXT& operator=(const safe_VkDeviceEventInfoEXT& copy_src);
+    safe_VkDeviceEventInfoEXT();
+    ~safe_VkDeviceEventInfoEXT();
+    void initialize(const VkDeviceEventInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDeviceEventInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceEventInfoEXT* ptr() { return reinterpret_cast<VkDeviceEventInfoEXT*>(this); }
+    VkDeviceEventInfoEXT const* ptr() const { return reinterpret_cast<VkDeviceEventInfoEXT const*>(this); }
+};
+struct safe_VkDisplayEventInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDisplayEventTypeEXT displayEvent;
+
+    safe_VkDisplayEventInfoEXT(const VkDisplayEventInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDisplayEventInfoEXT(const safe_VkDisplayEventInfoEXT& copy_src);
+    safe_VkDisplayEventInfoEXT& operator=(const safe_VkDisplayEventInfoEXT& copy_src);
+    safe_VkDisplayEventInfoEXT();
+    ~safe_VkDisplayEventInfoEXT();
+    void initialize(const VkDisplayEventInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDisplayEventInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDisplayEventInfoEXT* ptr() { return reinterpret_cast<VkDisplayEventInfoEXT*>(this); }
+    VkDisplayEventInfoEXT const* ptr() const { return reinterpret_cast<VkDisplayEventInfoEXT const*>(this); }
+};
+struct safe_VkSwapchainCounterCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSurfaceCounterFlagsEXT surfaceCounters;
+
+    safe_VkSwapchainCounterCreateInfoEXT(const VkSwapchainCounterCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkSwapchainCounterCreateInfoEXT(const safe_VkSwapchainCounterCreateInfoEXT& copy_src);
+    safe_VkSwapchainCounterCreateInfoEXT& operator=(const safe_VkSwapchainCounterCreateInfoEXT& copy_src);
+    safe_VkSwapchainCounterCreateInfoEXT();
+    ~safe_VkSwapchainCounterCreateInfoEXT();
+    void initialize(const VkSwapchainCounterCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSwapchainCounterCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSwapchainCounterCreateInfoEXT* ptr() { return reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(this); }
+    VkSwapchainCounterCreateInfoEXT const* ptr() const { return reinterpret_cast<VkSwapchainCounterCreateInfoEXT const*>(this); }
+};
+struct safe_VkPresentTimesInfoGOOGLE {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t swapchainCount;
+    const VkPresentTimeGOOGLE* pTimes{};
+
+    safe_VkPresentTimesInfoGOOGLE(const VkPresentTimesInfoGOOGLE* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    safe_VkPresentTimesInfoGOOGLE(const safe_VkPresentTimesInfoGOOGLE& copy_src);
+    safe_VkPresentTimesInfoGOOGLE& operator=(const safe_VkPresentTimesInfoGOOGLE& copy_src);
+    safe_VkPresentTimesInfoGOOGLE();
+    ~safe_VkPresentTimesInfoGOOGLE();
+    void initialize(const VkPresentTimesInfoGOOGLE* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPresentTimesInfoGOOGLE* copy_src, PNextCopyState* copy_state = {});
+    VkPresentTimesInfoGOOGLE* ptr() { return reinterpret_cast<VkPresentTimesInfoGOOGLE*>(this); }
+    VkPresentTimesInfoGOOGLE const* ptr() const { return reinterpret_cast<VkPresentTimesInfoGOOGLE const*>(this); }
+};
+struct safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 perViewPositionAllComponents;
+
+    safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
+        const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
+        const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& copy_src);
+    safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& operator=(
+        const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& copy_src);
+    safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX();
+    ~safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX();
+    void initialize(const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(this);
+    }
+    VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const*>(this);
+    }
+};
+struct safe_VkPipelineViewportSwizzleStateCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineViewportSwizzleStateCreateFlagsNV flags;
+    uint32_t viewportCount;
+    const VkViewportSwizzleNV* pViewportSwizzles{};
+
+    safe_VkPipelineViewportSwizzleStateCreateInfoNV(const VkPipelineViewportSwizzleStateCreateInfoNV* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineViewportSwizzleStateCreateInfoNV(const safe_VkPipelineViewportSwizzleStateCreateInfoNV& copy_src);
+    safe_VkPipelineViewportSwizzleStateCreateInfoNV& operator=(const safe_VkPipelineViewportSwizzleStateCreateInfoNV& copy_src);
+    safe_VkPipelineViewportSwizzleStateCreateInfoNV();
+    ~safe_VkPipelineViewportSwizzleStateCreateInfoNV();
+    void initialize(const VkPipelineViewportSwizzleStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineViewportSwizzleStateCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineViewportSwizzleStateCreateInfoNV* ptr() {
+        return reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(this);
+    }
+    VkPipelineViewportSwizzleStateCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxDiscardRectangles;
+
+    safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT(const VkPhysicalDeviceDiscardRectanglePropertiesEXT* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT(const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT& operator=(
+        const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT();
+    ~safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT();
+    void initialize(const VkPhysicalDeviceDiscardRectanglePropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDiscardRectanglePropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceDiscardRectanglePropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT const*>(this);
+    }
+};
+struct safe_VkPipelineDiscardRectangleStateCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineDiscardRectangleStateCreateFlagsEXT flags;
+    VkDiscardRectangleModeEXT discardRectangleMode;
+    uint32_t discardRectangleCount;
+    const VkRect2D* pDiscardRectangles{};
+
+    safe_VkPipelineDiscardRectangleStateCreateInfoEXT(const VkPipelineDiscardRectangleStateCreateInfoEXT* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineDiscardRectangleStateCreateInfoEXT(const safe_VkPipelineDiscardRectangleStateCreateInfoEXT& copy_src);
+    safe_VkPipelineDiscardRectangleStateCreateInfoEXT& operator=(const safe_VkPipelineDiscardRectangleStateCreateInfoEXT& copy_src);
+    safe_VkPipelineDiscardRectangleStateCreateInfoEXT();
+    ~safe_VkPipelineDiscardRectangleStateCreateInfoEXT();
+    void initialize(const VkPipelineDiscardRectangleStateCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineDiscardRectangleStateCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineDiscardRectangleStateCreateInfoEXT* ptr() {
+        return reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(this);
+    }
+    VkPipelineDiscardRectangleStateCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    float primitiveOverestimationSize;
+    float maxExtraPrimitiveOverestimationSize;
+    float extraPrimitiveOverestimationSizeGranularity;
+    VkBool32 primitiveUnderestimation;
+    VkBool32 conservativePointAndLineRasterization;
+    VkBool32 degenerateTrianglesRasterized;
+    VkBool32 degenerateLinesRasterized;
+    VkBool32 fullyCoveredFragmentShaderInputVariable;
+    VkBool32 conservativeRasterizationPostDepthCoverage;
+
+    safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
+        const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
+        const safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT& operator=(
+        const safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT();
+    ~safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT();
+    void initialize(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceConservativeRasterizationPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceConservativeRasterizationPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT const*>(this);
+    }
+};
+struct safe_VkPipelineRasterizationConservativeStateCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineRasterizationConservativeStateCreateFlagsEXT flags;
+    VkConservativeRasterizationModeEXT conservativeRasterizationMode;
+    float extraPrimitiveOverestimationSize;
+
+    safe_VkPipelineRasterizationConservativeStateCreateInfoEXT(
+        const VkPipelineRasterizationConservativeStateCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPipelineRasterizationConservativeStateCreateInfoEXT(
+        const safe_VkPipelineRasterizationConservativeStateCreateInfoEXT& copy_src);
+    safe_VkPipelineRasterizationConservativeStateCreateInfoEXT& operator=(
+        const safe_VkPipelineRasterizationConservativeStateCreateInfoEXT& copy_src);
+    safe_VkPipelineRasterizationConservativeStateCreateInfoEXT();
+    ~safe_VkPipelineRasterizationConservativeStateCreateInfoEXT();
+    void initialize(const VkPipelineRasterizationConservativeStateCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineRasterizationConservativeStateCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineRasterizationConservativeStateCreateInfoEXT* ptr() {
+        return reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(this);
+    }
+    VkPipelineRasterizationConservativeStateCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 depthClipEnable;
+
+    safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT(const VkPhysicalDeviceDepthClipEnableFeaturesEXT* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT(const safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT& operator=(const safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT();
+    ~safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT();
+    void initialize(const VkPhysicalDeviceDepthClipEnableFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDepthClipEnableFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceDepthClipEnableFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags;
+    VkBool32 depthClipEnable;
+
+    safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT(const VkPipelineRasterizationDepthClipStateCreateInfoEXT* in_struct,
+                                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+        const safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT& copy_src);
+    safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT& operator=(
+        const safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT& copy_src);
+    safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT();
+    ~safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT();
+    void initialize(const VkPipelineRasterizationDepthClipStateCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineRasterizationDepthClipStateCreateInfoEXT* ptr() {
+        return reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(this);
+    }
+    VkPipelineRasterizationDepthClipStateCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT const*>(this);
+    }
+};
+struct safe_VkHdrMetadataEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkXYColorEXT displayPrimaryRed;
+    VkXYColorEXT displayPrimaryGreen;
+    VkXYColorEXT displayPrimaryBlue;
+    VkXYColorEXT whitePoint;
+    float maxLuminance;
+    float minLuminance;
+    float maxContentLightLevel;
+    float maxFrameAverageLightLevel;
+
+    safe_VkHdrMetadataEXT(const VkHdrMetadataEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkHdrMetadataEXT(const safe_VkHdrMetadataEXT& copy_src);
+    safe_VkHdrMetadataEXT& operator=(const safe_VkHdrMetadataEXT& copy_src);
+    safe_VkHdrMetadataEXT();
+    ~safe_VkHdrMetadataEXT();
+    void initialize(const VkHdrMetadataEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkHdrMetadataEXT* copy_src, PNextCopyState* copy_state = {});
+    VkHdrMetadataEXT* ptr() { return reinterpret_cast<VkHdrMetadataEXT*>(this); }
+    VkHdrMetadataEXT const* ptr() const { return reinterpret_cast<VkHdrMetadataEXT const*>(this); }
+};
+struct safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 relaxedLineRasterization;
+
+    safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG(const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* in_struct,
+                                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG(
+        const safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG& copy_src);
+    safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG& operator=(
+        const safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG& copy_src);
+    safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG();
+    ~safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG();
+    void initialize(const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG*>(this);
+    }
+    VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG const*>(this);
+    }
+};
+struct safe_VkDebugUtilsLabelEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    const char* pLabelName{};
+    float color[4];
+
+    safe_VkDebugUtilsLabelEXT(const VkDebugUtilsLabelEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDebugUtilsLabelEXT(const safe_VkDebugUtilsLabelEXT& copy_src);
+    safe_VkDebugUtilsLabelEXT& operator=(const safe_VkDebugUtilsLabelEXT& copy_src);
+    safe_VkDebugUtilsLabelEXT();
+    ~safe_VkDebugUtilsLabelEXT();
+    void initialize(const VkDebugUtilsLabelEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDebugUtilsLabelEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDebugUtilsLabelEXT* ptr() { return reinterpret_cast<VkDebugUtilsLabelEXT*>(this); }
+    VkDebugUtilsLabelEXT const* ptr() const { return reinterpret_cast<VkDebugUtilsLabelEXT const*>(this); }
+};
+struct safe_VkDebugUtilsObjectNameInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkObjectType objectType;
+    uint64_t objectHandle;
+    const char* pObjectName{};
+
+    safe_VkDebugUtilsObjectNameInfoEXT(const VkDebugUtilsObjectNameInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    safe_VkDebugUtilsObjectNameInfoEXT(const safe_VkDebugUtilsObjectNameInfoEXT& copy_src);
+    safe_VkDebugUtilsObjectNameInfoEXT& operator=(const safe_VkDebugUtilsObjectNameInfoEXT& copy_src);
+    safe_VkDebugUtilsObjectNameInfoEXT();
+    ~safe_VkDebugUtilsObjectNameInfoEXT();
+    void initialize(const VkDebugUtilsObjectNameInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDebugUtilsObjectNameInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDebugUtilsObjectNameInfoEXT* ptr() { return reinterpret_cast<VkDebugUtilsObjectNameInfoEXT*>(this); }
+    VkDebugUtilsObjectNameInfoEXT const* ptr() const { return reinterpret_cast<VkDebugUtilsObjectNameInfoEXT const*>(this); }
+};
+struct safe_VkDebugUtilsMessengerCallbackDataEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDebugUtilsMessengerCallbackDataFlagsEXT flags;
+    const char* pMessageIdName{};
+    int32_t messageIdNumber;
+    const char* pMessage{};
+    uint32_t queueLabelCount;
+    safe_VkDebugUtilsLabelEXT* pQueueLabels{};
+    uint32_t cmdBufLabelCount;
+    safe_VkDebugUtilsLabelEXT* pCmdBufLabels{};
+    uint32_t objectCount;
+    safe_VkDebugUtilsObjectNameInfoEXT* pObjects{};
+
+    safe_VkDebugUtilsMessengerCallbackDataEXT(const VkDebugUtilsMessengerCallbackDataEXT* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDebugUtilsMessengerCallbackDataEXT(const safe_VkDebugUtilsMessengerCallbackDataEXT& copy_src);
+    safe_VkDebugUtilsMessengerCallbackDataEXT& operator=(const safe_VkDebugUtilsMessengerCallbackDataEXT& copy_src);
+    safe_VkDebugUtilsMessengerCallbackDataEXT();
+    ~safe_VkDebugUtilsMessengerCallbackDataEXT();
+    void initialize(const VkDebugUtilsMessengerCallbackDataEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDebugUtilsMessengerCallbackDataEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDebugUtilsMessengerCallbackDataEXT* ptr() { return reinterpret_cast<VkDebugUtilsMessengerCallbackDataEXT*>(this); }
+    VkDebugUtilsMessengerCallbackDataEXT const* ptr() const {
+        return reinterpret_cast<VkDebugUtilsMessengerCallbackDataEXT const*>(this);
+    }
+};
+struct safe_VkDebugUtilsMessengerCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDebugUtilsMessengerCreateFlagsEXT flags;
+    VkDebugUtilsMessageSeverityFlagsEXT messageSeverity;
+    VkDebugUtilsMessageTypeFlagsEXT messageType;
+    PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback;
+    void* pUserData{};
+
+    safe_VkDebugUtilsMessengerCreateInfoEXT(const VkDebugUtilsMessengerCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                            bool copy_pnext = true);
+    safe_VkDebugUtilsMessengerCreateInfoEXT(const safe_VkDebugUtilsMessengerCreateInfoEXT& copy_src);
+    safe_VkDebugUtilsMessengerCreateInfoEXT& operator=(const safe_VkDebugUtilsMessengerCreateInfoEXT& copy_src);
+    safe_VkDebugUtilsMessengerCreateInfoEXT();
+    ~safe_VkDebugUtilsMessengerCreateInfoEXT();
+    void initialize(const VkDebugUtilsMessengerCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDebugUtilsMessengerCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDebugUtilsMessengerCreateInfoEXT* ptr() { return reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(this); }
+    VkDebugUtilsMessengerCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT const*>(this);
+    }
+};
+struct safe_VkDebugUtilsObjectTagInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkObjectType objectType;
+    uint64_t objectHandle;
+    uint64_t tagName;
+    size_t tagSize;
+    const void* pTag{};
+
+    safe_VkDebugUtilsObjectTagInfoEXT(const VkDebugUtilsObjectTagInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    safe_VkDebugUtilsObjectTagInfoEXT(const safe_VkDebugUtilsObjectTagInfoEXT& copy_src);
+    safe_VkDebugUtilsObjectTagInfoEXT& operator=(const safe_VkDebugUtilsObjectTagInfoEXT& copy_src);
+    safe_VkDebugUtilsObjectTagInfoEXT();
+    ~safe_VkDebugUtilsObjectTagInfoEXT();
+    void initialize(const VkDebugUtilsObjectTagInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDebugUtilsObjectTagInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDebugUtilsObjectTagInfoEXT* ptr() { return reinterpret_cast<VkDebugUtilsObjectTagInfoEXT*>(this); }
+    VkDebugUtilsObjectTagInfoEXT const* ptr() const { return reinterpret_cast<VkDebugUtilsObjectTagInfoEXT const*>(this); }
+};
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+struct safe_VkAndroidHardwareBufferUsageANDROID {
+    VkStructureType sType;
+    void* pNext{};
+    uint64_t androidHardwareBufferUsage;
+
+    safe_VkAndroidHardwareBufferUsageANDROID(const VkAndroidHardwareBufferUsageANDROID* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkAndroidHardwareBufferUsageANDROID(const safe_VkAndroidHardwareBufferUsageANDROID& copy_src);
+    safe_VkAndroidHardwareBufferUsageANDROID& operator=(const safe_VkAndroidHardwareBufferUsageANDROID& copy_src);
+    safe_VkAndroidHardwareBufferUsageANDROID();
+    ~safe_VkAndroidHardwareBufferUsageANDROID();
+    void initialize(const VkAndroidHardwareBufferUsageANDROID* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAndroidHardwareBufferUsageANDROID* copy_src, PNextCopyState* copy_state = {});
+    VkAndroidHardwareBufferUsageANDROID* ptr() { return reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(this); }
+    VkAndroidHardwareBufferUsageANDROID const* ptr() const {
+        return reinterpret_cast<VkAndroidHardwareBufferUsageANDROID const*>(this);
+    }
+};
+struct safe_VkAndroidHardwareBufferPropertiesANDROID {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceSize allocationSize;
+    uint32_t memoryTypeBits;
+
+    safe_VkAndroidHardwareBufferPropertiesANDROID(const VkAndroidHardwareBufferPropertiesANDROID* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkAndroidHardwareBufferPropertiesANDROID(const safe_VkAndroidHardwareBufferPropertiesANDROID& copy_src);
+    safe_VkAndroidHardwareBufferPropertiesANDROID& operator=(const safe_VkAndroidHardwareBufferPropertiesANDROID& copy_src);
+    safe_VkAndroidHardwareBufferPropertiesANDROID();
+    ~safe_VkAndroidHardwareBufferPropertiesANDROID();
+    void initialize(const VkAndroidHardwareBufferPropertiesANDROID* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAndroidHardwareBufferPropertiesANDROID* copy_src, PNextCopyState* copy_state = {});
+    VkAndroidHardwareBufferPropertiesANDROID* ptr() { return reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>(this); }
+    VkAndroidHardwareBufferPropertiesANDROID const* ptr() const {
+        return reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID const*>(this);
+    }
+};
+struct safe_VkAndroidHardwareBufferFormatPropertiesANDROID {
+    VkStructureType sType;
+    void* pNext{};
+    VkFormat format;
+    uint64_t externalFormat;
+    VkFormatFeatureFlags formatFeatures;
+    VkComponentMapping samplerYcbcrConversionComponents;
+    VkSamplerYcbcrModelConversion suggestedYcbcrModel;
+    VkSamplerYcbcrRange suggestedYcbcrRange;
+    VkChromaLocation suggestedXChromaOffset;
+    VkChromaLocation suggestedYChromaOffset;
+
+    safe_VkAndroidHardwareBufferFormatPropertiesANDROID(const VkAndroidHardwareBufferFormatPropertiesANDROID* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkAndroidHardwareBufferFormatPropertiesANDROID(const safe_VkAndroidHardwareBufferFormatPropertiesANDROID& copy_src);
+    safe_VkAndroidHardwareBufferFormatPropertiesANDROID& operator=(
+        const safe_VkAndroidHardwareBufferFormatPropertiesANDROID& copy_src);
+    safe_VkAndroidHardwareBufferFormatPropertiesANDROID();
+    ~safe_VkAndroidHardwareBufferFormatPropertiesANDROID();
+    void initialize(const VkAndroidHardwareBufferFormatPropertiesANDROID* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAndroidHardwareBufferFormatPropertiesANDROID* copy_src, PNextCopyState* copy_state = {});
+    VkAndroidHardwareBufferFormatPropertiesANDROID* ptr() {
+        return reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(this);
+    }
+    VkAndroidHardwareBufferFormatPropertiesANDROID const* ptr() const {
+        return reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID const*>(this);
+    }
+};
+struct safe_VkImportAndroidHardwareBufferInfoANDROID {
+    VkStructureType sType;
+    const void* pNext{};
+    struct AHardwareBuffer* buffer{};
+
+    safe_VkImportAndroidHardwareBufferInfoANDROID(const VkImportAndroidHardwareBufferInfoANDROID* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkImportAndroidHardwareBufferInfoANDROID(const safe_VkImportAndroidHardwareBufferInfoANDROID& copy_src);
+    safe_VkImportAndroidHardwareBufferInfoANDROID& operator=(const safe_VkImportAndroidHardwareBufferInfoANDROID& copy_src);
+    safe_VkImportAndroidHardwareBufferInfoANDROID();
+    ~safe_VkImportAndroidHardwareBufferInfoANDROID();
+    void initialize(const VkImportAndroidHardwareBufferInfoANDROID* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImportAndroidHardwareBufferInfoANDROID* copy_src, PNextCopyState* copy_state = {});
+    VkImportAndroidHardwareBufferInfoANDROID* ptr() { return reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(this); }
+    VkImportAndroidHardwareBufferInfoANDROID const* ptr() const {
+        return reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID const*>(this);
+    }
+};
+struct safe_VkMemoryGetAndroidHardwareBufferInfoANDROID {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceMemory memory;
+
+    safe_VkMemoryGetAndroidHardwareBufferInfoANDROID(const VkMemoryGetAndroidHardwareBufferInfoANDROID* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkMemoryGetAndroidHardwareBufferInfoANDROID(const safe_VkMemoryGetAndroidHardwareBufferInfoANDROID& copy_src);
+    safe_VkMemoryGetAndroidHardwareBufferInfoANDROID& operator=(const safe_VkMemoryGetAndroidHardwareBufferInfoANDROID& copy_src);
+    safe_VkMemoryGetAndroidHardwareBufferInfoANDROID();
+    ~safe_VkMemoryGetAndroidHardwareBufferInfoANDROID();
+    void initialize(const VkMemoryGetAndroidHardwareBufferInfoANDROID* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMemoryGetAndroidHardwareBufferInfoANDROID* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryGetAndroidHardwareBufferInfoANDROID* ptr() {
+        return reinterpret_cast<VkMemoryGetAndroidHardwareBufferInfoANDROID*>(this);
+    }
+    VkMemoryGetAndroidHardwareBufferInfoANDROID const* ptr() const {
+        return reinterpret_cast<VkMemoryGetAndroidHardwareBufferInfoANDROID const*>(this);
+    }
+};
+struct safe_VkExternalFormatANDROID {
+    VkStructureType sType;
+    void* pNext{};
+    uint64_t externalFormat;
+
+    safe_VkExternalFormatANDROID(const VkExternalFormatANDROID* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkExternalFormatANDROID(const safe_VkExternalFormatANDROID& copy_src);
+    safe_VkExternalFormatANDROID& operator=(const safe_VkExternalFormatANDROID& copy_src);
+    safe_VkExternalFormatANDROID();
+    ~safe_VkExternalFormatANDROID();
+    void initialize(const VkExternalFormatANDROID* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExternalFormatANDROID* copy_src, PNextCopyState* copy_state = {});
+    VkExternalFormatANDROID* ptr() { return reinterpret_cast<VkExternalFormatANDROID*>(this); }
+    VkExternalFormatANDROID const* ptr() const { return reinterpret_cast<VkExternalFormatANDROID const*>(this); }
+};
+struct safe_VkAndroidHardwareBufferFormatProperties2ANDROID {
+    VkStructureType sType;
+    void* pNext{};
+    VkFormat format;
+    uint64_t externalFormat;
+    VkFormatFeatureFlags2 formatFeatures;
+    VkComponentMapping samplerYcbcrConversionComponents;
+    VkSamplerYcbcrModelConversion suggestedYcbcrModel;
+    VkSamplerYcbcrRange suggestedYcbcrRange;
+    VkChromaLocation suggestedXChromaOffset;
+    VkChromaLocation suggestedYChromaOffset;
+
+    safe_VkAndroidHardwareBufferFormatProperties2ANDROID(const VkAndroidHardwareBufferFormatProperties2ANDROID* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkAndroidHardwareBufferFormatProperties2ANDROID(const safe_VkAndroidHardwareBufferFormatProperties2ANDROID& copy_src);
+    safe_VkAndroidHardwareBufferFormatProperties2ANDROID& operator=(
+        const safe_VkAndroidHardwareBufferFormatProperties2ANDROID& copy_src);
+    safe_VkAndroidHardwareBufferFormatProperties2ANDROID();
+    ~safe_VkAndroidHardwareBufferFormatProperties2ANDROID();
+    void initialize(const VkAndroidHardwareBufferFormatProperties2ANDROID* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAndroidHardwareBufferFormatProperties2ANDROID* copy_src, PNextCopyState* copy_state = {});
+    VkAndroidHardwareBufferFormatProperties2ANDROID* ptr() {
+        return reinterpret_cast<VkAndroidHardwareBufferFormatProperties2ANDROID*>(this);
+    }
+    VkAndroidHardwareBufferFormatProperties2ANDROID const* ptr() const {
+        return reinterpret_cast<VkAndroidHardwareBufferFormatProperties2ANDROID const*>(this);
+    }
+};
+#endif  // VK_USE_PLATFORM_ANDROID_KHR
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+struct safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderEnqueue;
+
+    safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX(const VkPhysicalDeviceShaderEnqueueFeaturesAMDX* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX(const safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX& copy_src);
+    safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX& operator=(const safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX& copy_src);
+    safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX();
+    ~safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX();
+    void initialize(const VkPhysicalDeviceShaderEnqueueFeaturesAMDX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderEnqueueFeaturesAMDX* ptr() { return reinterpret_cast<VkPhysicalDeviceShaderEnqueueFeaturesAMDX*>(this); }
+    VkPhysicalDeviceShaderEnqueueFeaturesAMDX const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderEnqueueFeaturesAMDX const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxExecutionGraphDepth;
+    uint32_t maxExecutionGraphShaderOutputNodes;
+    uint32_t maxExecutionGraphShaderPayloadSize;
+    uint32_t maxExecutionGraphShaderPayloadCount;
+    uint32_t executionGraphDispatchAddressAlignment;
+
+    safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX(const VkPhysicalDeviceShaderEnqueuePropertiesAMDX* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX(const safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX& copy_src);
+    safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX& operator=(const safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX& copy_src);
+    safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX();
+    ~safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX();
+    void initialize(const VkPhysicalDeviceShaderEnqueuePropertiesAMDX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderEnqueuePropertiesAMDX* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderEnqueuePropertiesAMDX*>(this);
+    }
+    VkPhysicalDeviceShaderEnqueuePropertiesAMDX const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderEnqueuePropertiesAMDX const*>(this);
+    }
+};
+struct safe_VkExecutionGraphPipelineScratchSizeAMDX {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceSize size;
+
+    safe_VkExecutionGraphPipelineScratchSizeAMDX(const VkExecutionGraphPipelineScratchSizeAMDX* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkExecutionGraphPipelineScratchSizeAMDX(const safe_VkExecutionGraphPipelineScratchSizeAMDX& copy_src);
+    safe_VkExecutionGraphPipelineScratchSizeAMDX& operator=(const safe_VkExecutionGraphPipelineScratchSizeAMDX& copy_src);
+    safe_VkExecutionGraphPipelineScratchSizeAMDX();
+    ~safe_VkExecutionGraphPipelineScratchSizeAMDX();
+    void initialize(const VkExecutionGraphPipelineScratchSizeAMDX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExecutionGraphPipelineScratchSizeAMDX* copy_src, PNextCopyState* copy_state = {});
+    VkExecutionGraphPipelineScratchSizeAMDX* ptr() { return reinterpret_cast<VkExecutionGraphPipelineScratchSizeAMDX*>(this); }
+    VkExecutionGraphPipelineScratchSizeAMDX const* ptr() const {
+        return reinterpret_cast<VkExecutionGraphPipelineScratchSizeAMDX const*>(this);
+    }
+};
+struct safe_VkExecutionGraphPipelineCreateInfoAMDX {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineCreateFlags flags;
+    uint32_t stageCount;
+    safe_VkPipelineShaderStageCreateInfo* pStages{};
+    safe_VkPipelineLibraryCreateInfoKHR* pLibraryInfo{};
+    VkPipelineLayout layout;
+    VkPipeline basePipelineHandle;
+    int32_t basePipelineIndex;
+
+    safe_VkExecutionGraphPipelineCreateInfoAMDX(const VkExecutionGraphPipelineCreateInfoAMDX* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkExecutionGraphPipelineCreateInfoAMDX(const safe_VkExecutionGraphPipelineCreateInfoAMDX& copy_src);
+    safe_VkExecutionGraphPipelineCreateInfoAMDX& operator=(const safe_VkExecutionGraphPipelineCreateInfoAMDX& copy_src);
+    safe_VkExecutionGraphPipelineCreateInfoAMDX();
+    ~safe_VkExecutionGraphPipelineCreateInfoAMDX();
+    void initialize(const VkExecutionGraphPipelineCreateInfoAMDX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExecutionGraphPipelineCreateInfoAMDX* copy_src, PNextCopyState* copy_state = {});
+    VkExecutionGraphPipelineCreateInfoAMDX* ptr() { return reinterpret_cast<VkExecutionGraphPipelineCreateInfoAMDX*>(this); }
+    VkExecutionGraphPipelineCreateInfoAMDX const* ptr() const {
+        return reinterpret_cast<VkExecutionGraphPipelineCreateInfoAMDX const*>(this);
+    }
+};
+union safe_VkDeviceOrHostAddressConstAMDX {
+    VkDeviceAddress deviceAddress;
+    const void* hostAddress{};
+
+    safe_VkDeviceOrHostAddressConstAMDX(const VkDeviceOrHostAddressConstAMDX* in_struct, PNextCopyState* copy_state = {});
+    safe_VkDeviceOrHostAddressConstAMDX(const safe_VkDeviceOrHostAddressConstAMDX& copy_src);
+    safe_VkDeviceOrHostAddressConstAMDX& operator=(const safe_VkDeviceOrHostAddressConstAMDX& copy_src);
+    safe_VkDeviceOrHostAddressConstAMDX();
+    ~safe_VkDeviceOrHostAddressConstAMDX();
+    void initialize(const VkDeviceOrHostAddressConstAMDX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDeviceOrHostAddressConstAMDX* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceOrHostAddressConstAMDX* ptr() { return reinterpret_cast<VkDeviceOrHostAddressConstAMDX*>(this); }
+    VkDeviceOrHostAddressConstAMDX const* ptr() const { return reinterpret_cast<VkDeviceOrHostAddressConstAMDX const*>(this); }
+};
+struct safe_VkPipelineShaderStageNodeCreateInfoAMDX {
+    VkStructureType sType;
+    const void* pNext{};
+    const char* pName{};
+    uint32_t index;
+
+    safe_VkPipelineShaderStageNodeCreateInfoAMDX(const VkPipelineShaderStageNodeCreateInfoAMDX* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineShaderStageNodeCreateInfoAMDX(const safe_VkPipelineShaderStageNodeCreateInfoAMDX& copy_src);
+    safe_VkPipelineShaderStageNodeCreateInfoAMDX& operator=(const safe_VkPipelineShaderStageNodeCreateInfoAMDX& copy_src);
+    safe_VkPipelineShaderStageNodeCreateInfoAMDX();
+    ~safe_VkPipelineShaderStageNodeCreateInfoAMDX();
+    void initialize(const VkPipelineShaderStageNodeCreateInfoAMDX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineShaderStageNodeCreateInfoAMDX* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineShaderStageNodeCreateInfoAMDX* ptr() { return reinterpret_cast<VkPipelineShaderStageNodeCreateInfoAMDX*>(this); }
+    VkPipelineShaderStageNodeCreateInfoAMDX const* ptr() const {
+        return reinterpret_cast<VkPipelineShaderStageNodeCreateInfoAMDX const*>(this);
+    }
+};
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+struct safe_VkSampleLocationsInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSampleCountFlagBits sampleLocationsPerPixel;
+    VkExtent2D sampleLocationGridSize;
+    uint32_t sampleLocationsCount;
+    const VkSampleLocationEXT* pSampleLocations{};
+
+    safe_VkSampleLocationsInfoEXT(const VkSampleLocationsInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    safe_VkSampleLocationsInfoEXT(const safe_VkSampleLocationsInfoEXT& copy_src);
+    safe_VkSampleLocationsInfoEXT& operator=(const safe_VkSampleLocationsInfoEXT& copy_src);
+    safe_VkSampleLocationsInfoEXT();
+    ~safe_VkSampleLocationsInfoEXT();
+    void initialize(const VkSampleLocationsInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSampleLocationsInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSampleLocationsInfoEXT* ptr() { return reinterpret_cast<VkSampleLocationsInfoEXT*>(this); }
+    VkSampleLocationsInfoEXT const* ptr() const { return reinterpret_cast<VkSampleLocationsInfoEXT const*>(this); }
+};
+struct safe_VkRenderPassSampleLocationsBeginInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t attachmentInitialSampleLocationsCount;
+    const VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations{};
+    uint32_t postSubpassSampleLocationsCount;
+    const VkSubpassSampleLocationsEXT* pPostSubpassSampleLocations{};
+
+    safe_VkRenderPassSampleLocationsBeginInfoEXT(const VkRenderPassSampleLocationsBeginInfoEXT* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkRenderPassSampleLocationsBeginInfoEXT(const safe_VkRenderPassSampleLocationsBeginInfoEXT& copy_src);
+    safe_VkRenderPassSampleLocationsBeginInfoEXT& operator=(const safe_VkRenderPassSampleLocationsBeginInfoEXT& copy_src);
+    safe_VkRenderPassSampleLocationsBeginInfoEXT();
+    ~safe_VkRenderPassSampleLocationsBeginInfoEXT();
+    void initialize(const VkRenderPassSampleLocationsBeginInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderPassSampleLocationsBeginInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassSampleLocationsBeginInfoEXT* ptr() { return reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(this); }
+    VkRenderPassSampleLocationsBeginInfoEXT const* ptr() const {
+        return reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT const*>(this);
+    }
+};
+struct safe_VkPipelineSampleLocationsStateCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 sampleLocationsEnable;
+    safe_VkSampleLocationsInfoEXT sampleLocationsInfo;
+
+    safe_VkPipelineSampleLocationsStateCreateInfoEXT(const VkPipelineSampleLocationsStateCreateInfoEXT* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineSampleLocationsStateCreateInfoEXT(const safe_VkPipelineSampleLocationsStateCreateInfoEXT& copy_src);
+    safe_VkPipelineSampleLocationsStateCreateInfoEXT& operator=(const safe_VkPipelineSampleLocationsStateCreateInfoEXT& copy_src);
+    safe_VkPipelineSampleLocationsStateCreateInfoEXT();
+    ~safe_VkPipelineSampleLocationsStateCreateInfoEXT();
+    void initialize(const VkPipelineSampleLocationsStateCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineSampleLocationsStateCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineSampleLocationsStateCreateInfoEXT* ptr() {
+        return reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(this);
+    }
+    VkPipelineSampleLocationsStateCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceSampleLocationsPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkSampleCountFlags sampleLocationSampleCounts;
+    VkExtent2D maxSampleLocationGridSize;
+    float sampleLocationCoordinateRange[2];
+    uint32_t sampleLocationSubPixelBits;
+    VkBool32 variableSampleLocations;
+
+    safe_VkPhysicalDeviceSampleLocationsPropertiesEXT(const VkPhysicalDeviceSampleLocationsPropertiesEXT* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceSampleLocationsPropertiesEXT(const safe_VkPhysicalDeviceSampleLocationsPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceSampleLocationsPropertiesEXT& operator=(const safe_VkPhysicalDeviceSampleLocationsPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceSampleLocationsPropertiesEXT();
+    ~safe_VkPhysicalDeviceSampleLocationsPropertiesEXT();
+    void initialize(const VkPhysicalDeviceSampleLocationsPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceSampleLocationsPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSampleLocationsPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceSampleLocationsPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT const*>(this);
+    }
+};
+struct safe_VkMultisamplePropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkExtent2D maxSampleLocationGridSize;
+
+    safe_VkMultisamplePropertiesEXT(const VkMultisamplePropertiesEXT* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    safe_VkMultisamplePropertiesEXT(const safe_VkMultisamplePropertiesEXT& copy_src);
+    safe_VkMultisamplePropertiesEXT& operator=(const safe_VkMultisamplePropertiesEXT& copy_src);
+    safe_VkMultisamplePropertiesEXT();
+    ~safe_VkMultisamplePropertiesEXT();
+    void initialize(const VkMultisamplePropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMultisamplePropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkMultisamplePropertiesEXT* ptr() { return reinterpret_cast<VkMultisamplePropertiesEXT*>(this); }
+    VkMultisamplePropertiesEXT const* ptr() const { return reinterpret_cast<VkMultisamplePropertiesEXT const*>(this); }
+};
+struct safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 advancedBlendCoherentOperations;
+
+    safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* in_struct,
+                                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT();
+    ~safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT();
+    void initialize(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t advancedBlendMaxColorAttachments;
+    VkBool32 advancedBlendIndependentBlend;
+    VkBool32 advancedBlendNonPremultipliedSrcColor;
+    VkBool32 advancedBlendNonPremultipliedDstColor;
+    VkBool32 advancedBlendCorrelatedOverlap;
+    VkBool32 advancedBlendAllOperations;
+
+    safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* in_struct,
+                                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
+        const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& operator=(
+        const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT();
+    ~safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT();
+    void initialize(const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const*>(this);
+    }
+};
+struct safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 srcPremultiplied;
+    VkBool32 dstPremultiplied;
+    VkBlendOverlapEXT blendOverlap;
+
+    safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT(const VkPipelineColorBlendAdvancedStateCreateInfoEXT* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT(const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT& copy_src);
+    safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT& operator=(
+        const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT& copy_src);
+    safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT();
+    ~safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT();
+    void initialize(const VkPipelineColorBlendAdvancedStateCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineColorBlendAdvancedStateCreateInfoEXT* ptr() {
+        return reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(this);
+    }
+    VkPipelineColorBlendAdvancedStateCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT const*>(this);
+    }
+};
+struct safe_VkPipelineCoverageToColorStateCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineCoverageToColorStateCreateFlagsNV flags;
+    VkBool32 coverageToColorEnable;
+    uint32_t coverageToColorLocation;
+
+    safe_VkPipelineCoverageToColorStateCreateInfoNV(const VkPipelineCoverageToColorStateCreateInfoNV* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineCoverageToColorStateCreateInfoNV(const safe_VkPipelineCoverageToColorStateCreateInfoNV& copy_src);
+    safe_VkPipelineCoverageToColorStateCreateInfoNV& operator=(const safe_VkPipelineCoverageToColorStateCreateInfoNV& copy_src);
+    safe_VkPipelineCoverageToColorStateCreateInfoNV();
+    ~safe_VkPipelineCoverageToColorStateCreateInfoNV();
+    void initialize(const VkPipelineCoverageToColorStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineCoverageToColorStateCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineCoverageToColorStateCreateInfoNV* ptr() {
+        return reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(this);
+    }
+    VkPipelineCoverageToColorStateCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV const*>(this);
+    }
+};
+struct safe_VkPipelineCoverageModulationStateCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineCoverageModulationStateCreateFlagsNV flags;
+    VkCoverageModulationModeNV coverageModulationMode;
+    VkBool32 coverageModulationTableEnable;
+    uint32_t coverageModulationTableCount;
+    const float* pCoverageModulationTable{};
+
+    safe_VkPipelineCoverageModulationStateCreateInfoNV(const VkPipelineCoverageModulationStateCreateInfoNV* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineCoverageModulationStateCreateInfoNV(const safe_VkPipelineCoverageModulationStateCreateInfoNV& copy_src);
+    safe_VkPipelineCoverageModulationStateCreateInfoNV& operator=(
+        const safe_VkPipelineCoverageModulationStateCreateInfoNV& copy_src);
+    safe_VkPipelineCoverageModulationStateCreateInfoNV();
+    ~safe_VkPipelineCoverageModulationStateCreateInfoNV();
+    void initialize(const VkPipelineCoverageModulationStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineCoverageModulationStateCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineCoverageModulationStateCreateInfoNV* ptr() {
+        return reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(this);
+    }
+    VkPipelineCoverageModulationStateCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t shaderSMCount;
+    uint32_t shaderWarpsPerSM;
+
+    safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(const safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& copy_src);
+    safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& operator=(const safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& copy_src);
+    safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV();
+    ~safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV();
+    void initialize(const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV*>(this);
+    }
+    VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderSMBuiltins;
+
+    safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(const safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& operator=(const safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV();
+    ~safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV();
+    void initialize(const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const*>(this);
+    }
+};
+struct safe_VkDrmFormatModifierPropertiesListEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t drmFormatModifierCount;
+    VkDrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties{};
+
+    safe_VkDrmFormatModifierPropertiesListEXT(const VkDrmFormatModifierPropertiesListEXT* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDrmFormatModifierPropertiesListEXT(const safe_VkDrmFormatModifierPropertiesListEXT& copy_src);
+    safe_VkDrmFormatModifierPropertiesListEXT& operator=(const safe_VkDrmFormatModifierPropertiesListEXT& copy_src);
+    safe_VkDrmFormatModifierPropertiesListEXT();
+    ~safe_VkDrmFormatModifierPropertiesListEXT();
+    void initialize(const VkDrmFormatModifierPropertiesListEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDrmFormatModifierPropertiesListEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDrmFormatModifierPropertiesListEXT* ptr() { return reinterpret_cast<VkDrmFormatModifierPropertiesListEXT*>(this); }
+    VkDrmFormatModifierPropertiesListEXT const* ptr() const {
+        return reinterpret_cast<VkDrmFormatModifierPropertiesListEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint64_t drmFormatModifier;
+    VkSharingMode sharingMode;
+    uint32_t queueFamilyIndexCount;
+    const uint32_t* pQueueFamilyIndices{};
+
+    safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT& copy_src);
+    safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT& operator=(
+        const safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT& copy_src);
+    safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT();
+    ~safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT();
+    void initialize(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceImageDrmFormatModifierInfoEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(this);
+    }
+    VkPhysicalDeviceImageDrmFormatModifierInfoEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT const*>(this);
+    }
+};
+struct safe_VkImageDrmFormatModifierListCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t drmFormatModifierCount;
+    const uint64_t* pDrmFormatModifiers{};
+
+    safe_VkImageDrmFormatModifierListCreateInfoEXT(const VkImageDrmFormatModifierListCreateInfoEXT* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkImageDrmFormatModifierListCreateInfoEXT(const safe_VkImageDrmFormatModifierListCreateInfoEXT& copy_src);
+    safe_VkImageDrmFormatModifierListCreateInfoEXT& operator=(const safe_VkImageDrmFormatModifierListCreateInfoEXT& copy_src);
+    safe_VkImageDrmFormatModifierListCreateInfoEXT();
+    ~safe_VkImageDrmFormatModifierListCreateInfoEXT();
+    void initialize(const VkImageDrmFormatModifierListCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageDrmFormatModifierListCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImageDrmFormatModifierListCreateInfoEXT* ptr() { return reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT*>(this); }
+    VkImageDrmFormatModifierListCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT const*>(this);
+    }
+};
+struct safe_VkImageDrmFormatModifierExplicitCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint64_t drmFormatModifier;
+    uint32_t drmFormatModifierPlaneCount;
+    const VkSubresourceLayout* pPlaneLayouts{};
+
+    safe_VkImageDrmFormatModifierExplicitCreateInfoEXT(const VkImageDrmFormatModifierExplicitCreateInfoEXT* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkImageDrmFormatModifierExplicitCreateInfoEXT(const safe_VkImageDrmFormatModifierExplicitCreateInfoEXT& copy_src);
+    safe_VkImageDrmFormatModifierExplicitCreateInfoEXT& operator=(
+        const safe_VkImageDrmFormatModifierExplicitCreateInfoEXT& copy_src);
+    safe_VkImageDrmFormatModifierExplicitCreateInfoEXT();
+    ~safe_VkImageDrmFormatModifierExplicitCreateInfoEXT();
+    void initialize(const VkImageDrmFormatModifierExplicitCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageDrmFormatModifierExplicitCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImageDrmFormatModifierExplicitCreateInfoEXT* ptr() {
+        return reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>(this);
+    }
+    VkImageDrmFormatModifierExplicitCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT const*>(this);
+    }
+};
+struct safe_VkImageDrmFormatModifierPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint64_t drmFormatModifier;
+
+    safe_VkImageDrmFormatModifierPropertiesEXT(const VkImageDrmFormatModifierPropertiesEXT* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkImageDrmFormatModifierPropertiesEXT(const safe_VkImageDrmFormatModifierPropertiesEXT& copy_src);
+    safe_VkImageDrmFormatModifierPropertiesEXT& operator=(const safe_VkImageDrmFormatModifierPropertiesEXT& copy_src);
+    safe_VkImageDrmFormatModifierPropertiesEXT();
+    ~safe_VkImageDrmFormatModifierPropertiesEXT();
+    void initialize(const VkImageDrmFormatModifierPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageDrmFormatModifierPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImageDrmFormatModifierPropertiesEXT* ptr() { return reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT*>(this); }
+    VkImageDrmFormatModifierPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT const*>(this);
+    }
+};
+struct safe_VkDrmFormatModifierPropertiesList2EXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t drmFormatModifierCount;
+    VkDrmFormatModifierProperties2EXT* pDrmFormatModifierProperties{};
+
+    safe_VkDrmFormatModifierPropertiesList2EXT(const VkDrmFormatModifierPropertiesList2EXT* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDrmFormatModifierPropertiesList2EXT(const safe_VkDrmFormatModifierPropertiesList2EXT& copy_src);
+    safe_VkDrmFormatModifierPropertiesList2EXT& operator=(const safe_VkDrmFormatModifierPropertiesList2EXT& copy_src);
+    safe_VkDrmFormatModifierPropertiesList2EXT();
+    ~safe_VkDrmFormatModifierPropertiesList2EXT();
+    void initialize(const VkDrmFormatModifierPropertiesList2EXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDrmFormatModifierPropertiesList2EXT* copy_src, PNextCopyState* copy_state = {});
+    VkDrmFormatModifierPropertiesList2EXT* ptr() { return reinterpret_cast<VkDrmFormatModifierPropertiesList2EXT*>(this); }
+    VkDrmFormatModifierPropertiesList2EXT const* ptr() const {
+        return reinterpret_cast<VkDrmFormatModifierPropertiesList2EXT const*>(this);
+    }
+};
+struct safe_VkValidationCacheCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkValidationCacheCreateFlagsEXT flags;
+    size_t initialDataSize;
+    const void* pInitialData{};
+
+    safe_VkValidationCacheCreateInfoEXT(const VkValidationCacheCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkValidationCacheCreateInfoEXT(const safe_VkValidationCacheCreateInfoEXT& copy_src);
+    safe_VkValidationCacheCreateInfoEXT& operator=(const safe_VkValidationCacheCreateInfoEXT& copy_src);
+    safe_VkValidationCacheCreateInfoEXT();
+    ~safe_VkValidationCacheCreateInfoEXT();
+    void initialize(const VkValidationCacheCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkValidationCacheCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkValidationCacheCreateInfoEXT* ptr() { return reinterpret_cast<VkValidationCacheCreateInfoEXT*>(this); }
+    VkValidationCacheCreateInfoEXT const* ptr() const { return reinterpret_cast<VkValidationCacheCreateInfoEXT const*>(this); }
+};
+struct safe_VkShaderModuleValidationCacheCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkValidationCacheEXT validationCache;
+
+    safe_VkShaderModuleValidationCacheCreateInfoEXT(const VkShaderModuleValidationCacheCreateInfoEXT* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkShaderModuleValidationCacheCreateInfoEXT(const safe_VkShaderModuleValidationCacheCreateInfoEXT& copy_src);
+    safe_VkShaderModuleValidationCacheCreateInfoEXT& operator=(const safe_VkShaderModuleValidationCacheCreateInfoEXT& copy_src);
+    safe_VkShaderModuleValidationCacheCreateInfoEXT();
+    ~safe_VkShaderModuleValidationCacheCreateInfoEXT();
+    void initialize(const VkShaderModuleValidationCacheCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkShaderModuleValidationCacheCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkShaderModuleValidationCacheCreateInfoEXT* ptr() {
+        return reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(this);
+    }
+    VkShaderModuleValidationCacheCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT const*>(this);
+    }
+};
+struct safe_VkShadingRatePaletteNV {
+    uint32_t shadingRatePaletteEntryCount;
+    const VkShadingRatePaletteEntryNV* pShadingRatePaletteEntries{};
+
+    safe_VkShadingRatePaletteNV(const VkShadingRatePaletteNV* in_struct, PNextCopyState* copy_state = {});
+    safe_VkShadingRatePaletteNV(const safe_VkShadingRatePaletteNV& copy_src);
+    safe_VkShadingRatePaletteNV& operator=(const safe_VkShadingRatePaletteNV& copy_src);
+    safe_VkShadingRatePaletteNV();
+    ~safe_VkShadingRatePaletteNV();
+    void initialize(const VkShadingRatePaletteNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkShadingRatePaletteNV* copy_src, PNextCopyState* copy_state = {});
+    VkShadingRatePaletteNV* ptr() { return reinterpret_cast<VkShadingRatePaletteNV*>(this); }
+    VkShadingRatePaletteNV const* ptr() const { return reinterpret_cast<VkShadingRatePaletteNV const*>(this); }
+};
+struct safe_VkPipelineViewportShadingRateImageStateCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 shadingRateImageEnable;
+    uint32_t viewportCount;
+    safe_VkShadingRatePaletteNV* pShadingRatePalettes{};
+
+    safe_VkPipelineViewportShadingRateImageStateCreateInfoNV(const VkPipelineViewportShadingRateImageStateCreateInfoNV* in_struct,
+                                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineViewportShadingRateImageStateCreateInfoNV(
+        const safe_VkPipelineViewportShadingRateImageStateCreateInfoNV& copy_src);
+    safe_VkPipelineViewportShadingRateImageStateCreateInfoNV& operator=(
+        const safe_VkPipelineViewportShadingRateImageStateCreateInfoNV& copy_src);
+    safe_VkPipelineViewportShadingRateImageStateCreateInfoNV();
+    ~safe_VkPipelineViewportShadingRateImageStateCreateInfoNV();
+    void initialize(const VkPipelineViewportShadingRateImageStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineViewportShadingRateImageStateCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineViewportShadingRateImageStateCreateInfoNV* ptr() {
+        return reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>(this);
+    }
+    VkPipelineViewportShadingRateImageStateCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceShadingRateImageFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shadingRateImage;
+    VkBool32 shadingRateCoarseSampleOrder;
+
+    safe_VkPhysicalDeviceShadingRateImageFeaturesNV(const VkPhysicalDeviceShadingRateImageFeaturesNV* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShadingRateImageFeaturesNV(const safe_VkPhysicalDeviceShadingRateImageFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceShadingRateImageFeaturesNV& operator=(const safe_VkPhysicalDeviceShadingRateImageFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceShadingRateImageFeaturesNV();
+    ~safe_VkPhysicalDeviceShadingRateImageFeaturesNV();
+    void initialize(const VkPhysicalDeviceShadingRateImageFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShadingRateImageFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShadingRateImageFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceShadingRateImageFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceShadingRateImagePropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkExtent2D shadingRateTexelSize;
+    uint32_t shadingRatePaletteSize;
+    uint32_t shadingRateMaxCoarseSamples;
+
+    safe_VkPhysicalDeviceShadingRateImagePropertiesNV(const VkPhysicalDeviceShadingRateImagePropertiesNV* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShadingRateImagePropertiesNV(const safe_VkPhysicalDeviceShadingRateImagePropertiesNV& copy_src);
+    safe_VkPhysicalDeviceShadingRateImagePropertiesNV& operator=(const safe_VkPhysicalDeviceShadingRateImagePropertiesNV& copy_src);
+    safe_VkPhysicalDeviceShadingRateImagePropertiesNV();
+    ~safe_VkPhysicalDeviceShadingRateImagePropertiesNV();
+    void initialize(const VkPhysicalDeviceShadingRateImagePropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShadingRateImagePropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShadingRateImagePropertiesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV*>(this);
+    }
+    VkPhysicalDeviceShadingRateImagePropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV const*>(this);
+    }
+};
+struct safe_VkCoarseSampleOrderCustomNV {
+    VkShadingRatePaletteEntryNV shadingRate;
+    uint32_t sampleCount;
+    uint32_t sampleLocationCount;
+    const VkCoarseSampleLocationNV* pSampleLocations{};
+
+    safe_VkCoarseSampleOrderCustomNV(const VkCoarseSampleOrderCustomNV* in_struct, PNextCopyState* copy_state = {});
+    safe_VkCoarseSampleOrderCustomNV(const safe_VkCoarseSampleOrderCustomNV& copy_src);
+    safe_VkCoarseSampleOrderCustomNV& operator=(const safe_VkCoarseSampleOrderCustomNV& copy_src);
+    safe_VkCoarseSampleOrderCustomNV();
+    ~safe_VkCoarseSampleOrderCustomNV();
+    void initialize(const VkCoarseSampleOrderCustomNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCoarseSampleOrderCustomNV* copy_src, PNextCopyState* copy_state = {});
+    VkCoarseSampleOrderCustomNV* ptr() { return reinterpret_cast<VkCoarseSampleOrderCustomNV*>(this); }
+    VkCoarseSampleOrderCustomNV const* ptr() const { return reinterpret_cast<VkCoarseSampleOrderCustomNV const*>(this); }
+};
+struct safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkCoarseSampleOrderTypeNV sampleOrderType;
+    uint32_t customSampleOrderCount;
+    safe_VkCoarseSampleOrderCustomNV* pCustomSampleOrders{};
+
+    safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* in_struct,
+                                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
+        const safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& copy_src);
+    safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& operator=(
+        const safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& copy_src);
+    safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV();
+    ~safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV();
+    void initialize(const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* ptr() {
+        return reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(this);
+    }
+    VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const*>(this);
+    }
+};
+struct safe_VkRayTracingShaderGroupCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkRayTracingShaderGroupTypeKHR type;
+    uint32_t generalShader;
+    uint32_t closestHitShader;
+    uint32_t anyHitShader;
+    uint32_t intersectionShader;
+
+    safe_VkRayTracingShaderGroupCreateInfoNV(const VkRayTracingShaderGroupCreateInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkRayTracingShaderGroupCreateInfoNV(const safe_VkRayTracingShaderGroupCreateInfoNV& copy_src);
+    safe_VkRayTracingShaderGroupCreateInfoNV& operator=(const safe_VkRayTracingShaderGroupCreateInfoNV& copy_src);
+    safe_VkRayTracingShaderGroupCreateInfoNV();
+    ~safe_VkRayTracingShaderGroupCreateInfoNV();
+    void initialize(const VkRayTracingShaderGroupCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRayTracingShaderGroupCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkRayTracingShaderGroupCreateInfoNV* ptr() { return reinterpret_cast<VkRayTracingShaderGroupCreateInfoNV*>(this); }
+    VkRayTracingShaderGroupCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkRayTracingShaderGroupCreateInfoNV const*>(this);
+    }
+};
+struct safe_VkRayTracingPipelineCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineCreateFlags flags;
+    uint32_t stageCount;
+    safe_VkPipelineShaderStageCreateInfo* pStages{};
+    uint32_t groupCount;
+    safe_VkRayTracingShaderGroupCreateInfoNV* pGroups{};
+    uint32_t maxRecursionDepth;
+    VkPipelineLayout layout;
+    VkPipeline basePipelineHandle;
+    int32_t basePipelineIndex;
+
+    safe_VkRayTracingPipelineCreateInfoNV(const VkRayTracingPipelineCreateInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkRayTracingPipelineCreateInfoNV(const safe_VkRayTracingPipelineCreateInfoNV& copy_src);
+    safe_VkRayTracingPipelineCreateInfoNV& operator=(const safe_VkRayTracingPipelineCreateInfoNV& copy_src);
+    safe_VkRayTracingPipelineCreateInfoNV();
+    ~safe_VkRayTracingPipelineCreateInfoNV();
+    void initialize(const VkRayTracingPipelineCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRayTracingPipelineCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkRayTracingPipelineCreateInfoNV* ptr() { return reinterpret_cast<VkRayTracingPipelineCreateInfoNV*>(this); }
+    VkRayTracingPipelineCreateInfoNV const* ptr() const { return reinterpret_cast<VkRayTracingPipelineCreateInfoNV const*>(this); }
+};
+struct safe_VkGeometryTrianglesNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBuffer vertexData;
+    VkDeviceSize vertexOffset;
+    uint32_t vertexCount;
+    VkDeviceSize vertexStride;
+    VkFormat vertexFormat;
+    VkBuffer indexData;
+    VkDeviceSize indexOffset;
+    uint32_t indexCount;
+    VkIndexType indexType;
+    VkBuffer transformData;
+    VkDeviceSize transformOffset;
+
+    safe_VkGeometryTrianglesNV(const VkGeometryTrianglesNV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkGeometryTrianglesNV(const safe_VkGeometryTrianglesNV& copy_src);
+    safe_VkGeometryTrianglesNV& operator=(const safe_VkGeometryTrianglesNV& copy_src);
+    safe_VkGeometryTrianglesNV();
+    ~safe_VkGeometryTrianglesNV();
+    void initialize(const VkGeometryTrianglesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkGeometryTrianglesNV* copy_src, PNextCopyState* copy_state = {});
+    VkGeometryTrianglesNV* ptr() { return reinterpret_cast<VkGeometryTrianglesNV*>(this); }
+    VkGeometryTrianglesNV const* ptr() const { return reinterpret_cast<VkGeometryTrianglesNV const*>(this); }
+};
+struct safe_VkGeometryAABBNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBuffer aabbData;
+    uint32_t numAABBs;
+    uint32_t stride;
+    VkDeviceSize offset;
+
+    safe_VkGeometryAABBNV(const VkGeometryAABBNV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkGeometryAABBNV(const safe_VkGeometryAABBNV& copy_src);
+    safe_VkGeometryAABBNV& operator=(const safe_VkGeometryAABBNV& copy_src);
+    safe_VkGeometryAABBNV();
+    ~safe_VkGeometryAABBNV();
+    void initialize(const VkGeometryAABBNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkGeometryAABBNV* copy_src, PNextCopyState* copy_state = {});
+    VkGeometryAABBNV* ptr() { return reinterpret_cast<VkGeometryAABBNV*>(this); }
+    VkGeometryAABBNV const* ptr() const { return reinterpret_cast<VkGeometryAABBNV const*>(this); }
+};
+struct safe_VkGeometryNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkGeometryTypeKHR geometryType;
+    VkGeometryDataNV geometry;
+    VkGeometryFlagsKHR flags;
+
+    safe_VkGeometryNV(const VkGeometryNV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkGeometryNV(const safe_VkGeometryNV& copy_src);
+    safe_VkGeometryNV& operator=(const safe_VkGeometryNV& copy_src);
+    safe_VkGeometryNV();
+    ~safe_VkGeometryNV();
+    void initialize(const VkGeometryNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkGeometryNV* copy_src, PNextCopyState* copy_state = {});
+    VkGeometryNV* ptr() { return reinterpret_cast<VkGeometryNV*>(this); }
+    VkGeometryNV const* ptr() const { return reinterpret_cast<VkGeometryNV const*>(this); }
+};
+struct safe_VkAccelerationStructureInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAccelerationStructureTypeNV type;
+    VkBuildAccelerationStructureFlagsNV flags;
+    uint32_t instanceCount;
+    uint32_t geometryCount;
+    safe_VkGeometryNV* pGeometries{};
+
+    safe_VkAccelerationStructureInfoNV(const VkAccelerationStructureInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    safe_VkAccelerationStructureInfoNV(const safe_VkAccelerationStructureInfoNV& copy_src);
+    safe_VkAccelerationStructureInfoNV& operator=(const safe_VkAccelerationStructureInfoNV& copy_src);
+    safe_VkAccelerationStructureInfoNV();
+    ~safe_VkAccelerationStructureInfoNV();
+    void initialize(const VkAccelerationStructureInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAccelerationStructureInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureInfoNV* ptr() { return reinterpret_cast<VkAccelerationStructureInfoNV*>(this); }
+    VkAccelerationStructureInfoNV const* ptr() const { return reinterpret_cast<VkAccelerationStructureInfoNV const*>(this); }
+};
+struct safe_VkAccelerationStructureCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceSize compactedSize;
+    safe_VkAccelerationStructureInfoNV info;
+
+    safe_VkAccelerationStructureCreateInfoNV(const VkAccelerationStructureCreateInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkAccelerationStructureCreateInfoNV(const safe_VkAccelerationStructureCreateInfoNV& copy_src);
+    safe_VkAccelerationStructureCreateInfoNV& operator=(const safe_VkAccelerationStructureCreateInfoNV& copy_src);
+    safe_VkAccelerationStructureCreateInfoNV();
+    ~safe_VkAccelerationStructureCreateInfoNV();
+    void initialize(const VkAccelerationStructureCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAccelerationStructureCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureCreateInfoNV* ptr() { return reinterpret_cast<VkAccelerationStructureCreateInfoNV*>(this); }
+    VkAccelerationStructureCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureCreateInfoNV const*>(this);
+    }
+};
+struct safe_VkBindAccelerationStructureMemoryInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAccelerationStructureNV accelerationStructure;
+    VkDeviceMemory memory;
+    VkDeviceSize memoryOffset;
+    uint32_t deviceIndexCount;
+    const uint32_t* pDeviceIndices{};
+
+    safe_VkBindAccelerationStructureMemoryInfoNV(const VkBindAccelerationStructureMemoryInfoNV* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkBindAccelerationStructureMemoryInfoNV(const safe_VkBindAccelerationStructureMemoryInfoNV& copy_src);
+    safe_VkBindAccelerationStructureMemoryInfoNV& operator=(const safe_VkBindAccelerationStructureMemoryInfoNV& copy_src);
+    safe_VkBindAccelerationStructureMemoryInfoNV();
+    ~safe_VkBindAccelerationStructureMemoryInfoNV();
+    void initialize(const VkBindAccelerationStructureMemoryInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBindAccelerationStructureMemoryInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkBindAccelerationStructureMemoryInfoNV* ptr() { return reinterpret_cast<VkBindAccelerationStructureMemoryInfoNV*>(this); }
+    VkBindAccelerationStructureMemoryInfoNV const* ptr() const {
+        return reinterpret_cast<VkBindAccelerationStructureMemoryInfoNV const*>(this);
+    }
+};
+struct safe_VkWriteDescriptorSetAccelerationStructureNV {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t accelerationStructureCount;
+    VkAccelerationStructureNV* pAccelerationStructures{};
+
+    safe_VkWriteDescriptorSetAccelerationStructureNV(const VkWriteDescriptorSetAccelerationStructureNV* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkWriteDescriptorSetAccelerationStructureNV(const safe_VkWriteDescriptorSetAccelerationStructureNV& copy_src);
+    safe_VkWriteDescriptorSetAccelerationStructureNV& operator=(const safe_VkWriteDescriptorSetAccelerationStructureNV& copy_src);
+    safe_VkWriteDescriptorSetAccelerationStructureNV();
+    ~safe_VkWriteDescriptorSetAccelerationStructureNV();
+    void initialize(const VkWriteDescriptorSetAccelerationStructureNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkWriteDescriptorSetAccelerationStructureNV* copy_src, PNextCopyState* copy_state = {});
+    VkWriteDescriptorSetAccelerationStructureNV* ptr() {
+        return reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV*>(this);
+    }
+    VkWriteDescriptorSetAccelerationStructureNV const* ptr() const {
+        return reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV const*>(this);
+    }
+};
+struct safe_VkAccelerationStructureMemoryRequirementsInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAccelerationStructureMemoryRequirementsTypeNV type;
+    VkAccelerationStructureNV accelerationStructure;
+
+    safe_VkAccelerationStructureMemoryRequirementsInfoNV(const VkAccelerationStructureMemoryRequirementsInfoNV* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkAccelerationStructureMemoryRequirementsInfoNV(const safe_VkAccelerationStructureMemoryRequirementsInfoNV& copy_src);
+    safe_VkAccelerationStructureMemoryRequirementsInfoNV& operator=(
+        const safe_VkAccelerationStructureMemoryRequirementsInfoNV& copy_src);
+    safe_VkAccelerationStructureMemoryRequirementsInfoNV();
+    ~safe_VkAccelerationStructureMemoryRequirementsInfoNV();
+    void initialize(const VkAccelerationStructureMemoryRequirementsInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAccelerationStructureMemoryRequirementsInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureMemoryRequirementsInfoNV* ptr() {
+        return reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoNV*>(this);
+    }
+    VkAccelerationStructureMemoryRequirementsInfoNV const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceRayTracingPropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t shaderGroupHandleSize;
+    uint32_t maxRecursionDepth;
+    uint32_t maxShaderGroupStride;
+    uint32_t shaderGroupBaseAlignment;
+    uint64_t maxGeometryCount;
+    uint64_t maxInstanceCount;
+    uint64_t maxTriangleCount;
+    uint32_t maxDescriptorSetAccelerationStructures;
+
+    safe_VkPhysicalDeviceRayTracingPropertiesNV(const VkPhysicalDeviceRayTracingPropertiesNV* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceRayTracingPropertiesNV(const safe_VkPhysicalDeviceRayTracingPropertiesNV& copy_src);
+    safe_VkPhysicalDeviceRayTracingPropertiesNV& operator=(const safe_VkPhysicalDeviceRayTracingPropertiesNV& copy_src);
+    safe_VkPhysicalDeviceRayTracingPropertiesNV();
+    ~safe_VkPhysicalDeviceRayTracingPropertiesNV();
+    void initialize(const VkPhysicalDeviceRayTracingPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceRayTracingPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRayTracingPropertiesNV* ptr() { return reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV*>(this); }
+    VkPhysicalDeviceRayTracingPropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 representativeFragmentTest;
+
+    safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* in_struct,
+                                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
+        const safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& operator=(
+        const safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV();
+    ~safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV();
+    void initialize(const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const*>(this);
+    }
+};
+struct safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 representativeFragmentTestEnable;
+
+    safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
+        const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
+        const safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV& copy_src);
+    safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV& operator=(
+        const safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV& copy_src);
+    safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV();
+    ~safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV();
+    void initialize(const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineRepresentativeFragmentTestStateCreateInfoNV* ptr() {
+        return reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(this);
+    }
+    VkPipelineRepresentativeFragmentTestStateCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceImageViewImageFormatInfoEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkImageViewType imageViewType;
+
+    safe_VkPhysicalDeviceImageViewImageFormatInfoEXT(const VkPhysicalDeviceImageViewImageFormatInfoEXT* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceImageViewImageFormatInfoEXT(const safe_VkPhysicalDeviceImageViewImageFormatInfoEXT& copy_src);
+    safe_VkPhysicalDeviceImageViewImageFormatInfoEXT& operator=(const safe_VkPhysicalDeviceImageViewImageFormatInfoEXT& copy_src);
+    safe_VkPhysicalDeviceImageViewImageFormatInfoEXT();
+    ~safe_VkPhysicalDeviceImageViewImageFormatInfoEXT();
+    void initialize(const VkPhysicalDeviceImageViewImageFormatInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceImageViewImageFormatInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceImageViewImageFormatInfoEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT*>(this);
+    }
+    VkPhysicalDeviceImageViewImageFormatInfoEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT const*>(this);
+    }
+};
+struct safe_VkFilterCubicImageViewImageFormatPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 filterCubic;
+    VkBool32 filterCubicMinmax;
+
+    safe_VkFilterCubicImageViewImageFormatPropertiesEXT(const VkFilterCubicImageViewImageFormatPropertiesEXT* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkFilterCubicImageViewImageFormatPropertiesEXT(const safe_VkFilterCubicImageViewImageFormatPropertiesEXT& copy_src);
+    safe_VkFilterCubicImageViewImageFormatPropertiesEXT& operator=(
+        const safe_VkFilterCubicImageViewImageFormatPropertiesEXT& copy_src);
+    safe_VkFilterCubicImageViewImageFormatPropertiesEXT();
+    ~safe_VkFilterCubicImageViewImageFormatPropertiesEXT();
+    void initialize(const VkFilterCubicImageViewImageFormatPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkFilterCubicImageViewImageFormatPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkFilterCubicImageViewImageFormatPropertiesEXT* ptr() {
+        return reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT*>(this);
+    }
+    VkFilterCubicImageViewImageFormatPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT const*>(this);
+    }
+};
+struct safe_VkImportMemoryHostPointerInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalMemoryHandleTypeFlagBits handleType;
+    void* pHostPointer{};
+
+    safe_VkImportMemoryHostPointerInfoEXT(const VkImportMemoryHostPointerInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkImportMemoryHostPointerInfoEXT(const safe_VkImportMemoryHostPointerInfoEXT& copy_src);
+    safe_VkImportMemoryHostPointerInfoEXT& operator=(const safe_VkImportMemoryHostPointerInfoEXT& copy_src);
+    safe_VkImportMemoryHostPointerInfoEXT();
+    ~safe_VkImportMemoryHostPointerInfoEXT();
+    void initialize(const VkImportMemoryHostPointerInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImportMemoryHostPointerInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImportMemoryHostPointerInfoEXT* ptr() { return reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(this); }
+    VkImportMemoryHostPointerInfoEXT const* ptr() const { return reinterpret_cast<VkImportMemoryHostPointerInfoEXT const*>(this); }
+};
+struct safe_VkMemoryHostPointerPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t memoryTypeBits;
+
+    safe_VkMemoryHostPointerPropertiesEXT(const VkMemoryHostPointerPropertiesEXT* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkMemoryHostPointerPropertiesEXT(const safe_VkMemoryHostPointerPropertiesEXT& copy_src);
+    safe_VkMemoryHostPointerPropertiesEXT& operator=(const safe_VkMemoryHostPointerPropertiesEXT& copy_src);
+    safe_VkMemoryHostPointerPropertiesEXT();
+    ~safe_VkMemoryHostPointerPropertiesEXT();
+    void initialize(const VkMemoryHostPointerPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMemoryHostPointerPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryHostPointerPropertiesEXT* ptr() { return reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>(this); }
+    VkMemoryHostPointerPropertiesEXT const* ptr() const { return reinterpret_cast<VkMemoryHostPointerPropertiesEXT const*>(this); }
+};
+struct safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceSize minImportedHostPointerAlignment;
+
+    safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(const safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT& operator=(
+        const safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT();
+    ~safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT();
+    void initialize(const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExternalMemoryHostPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceExternalMemoryHostPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT const*>(this);
+    }
+};
+struct safe_VkPipelineCompilerControlCreateInfoAMD {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineCompilerControlFlagsAMD compilerControlFlags;
+
+    safe_VkPipelineCompilerControlCreateInfoAMD(const VkPipelineCompilerControlCreateInfoAMD* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineCompilerControlCreateInfoAMD(const safe_VkPipelineCompilerControlCreateInfoAMD& copy_src);
+    safe_VkPipelineCompilerControlCreateInfoAMD& operator=(const safe_VkPipelineCompilerControlCreateInfoAMD& copy_src);
+    safe_VkPipelineCompilerControlCreateInfoAMD();
+    ~safe_VkPipelineCompilerControlCreateInfoAMD();
+    void initialize(const VkPipelineCompilerControlCreateInfoAMD* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineCompilerControlCreateInfoAMD* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineCompilerControlCreateInfoAMD* ptr() { return reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD*>(this); }
+    VkPipelineCompilerControlCreateInfoAMD const* ptr() const {
+        return reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceShaderCorePropertiesAMD {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t shaderEngineCount;
+    uint32_t shaderArraysPerEngineCount;
+    uint32_t computeUnitsPerShaderArray;
+    uint32_t simdPerComputeUnit;
+    uint32_t wavefrontsPerSimd;
+    uint32_t wavefrontSize;
+    uint32_t sgprsPerSimd;
+    uint32_t minSgprAllocation;
+    uint32_t maxSgprAllocation;
+    uint32_t sgprAllocationGranularity;
+    uint32_t vgprsPerSimd;
+    uint32_t minVgprAllocation;
+    uint32_t maxVgprAllocation;
+    uint32_t vgprAllocationGranularity;
+
+    safe_VkPhysicalDeviceShaderCorePropertiesAMD(const VkPhysicalDeviceShaderCorePropertiesAMD* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderCorePropertiesAMD(const safe_VkPhysicalDeviceShaderCorePropertiesAMD& copy_src);
+    safe_VkPhysicalDeviceShaderCorePropertiesAMD& operator=(const safe_VkPhysicalDeviceShaderCorePropertiesAMD& copy_src);
+    safe_VkPhysicalDeviceShaderCorePropertiesAMD();
+    ~safe_VkPhysicalDeviceShaderCorePropertiesAMD();
+    void initialize(const VkPhysicalDeviceShaderCorePropertiesAMD* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderCorePropertiesAMD* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderCorePropertiesAMD* ptr() { return reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(this); }
+    VkPhysicalDeviceShaderCorePropertiesAMD const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD const*>(this);
+    }
+};
+struct safe_VkDeviceMemoryOverallocationCreateInfoAMD {
+    VkStructureType sType;
+    const void* pNext{};
+    VkMemoryOverallocationBehaviorAMD overallocationBehavior;
+
+    safe_VkDeviceMemoryOverallocationCreateInfoAMD(const VkDeviceMemoryOverallocationCreateInfoAMD* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDeviceMemoryOverallocationCreateInfoAMD(const safe_VkDeviceMemoryOverallocationCreateInfoAMD& copy_src);
+    safe_VkDeviceMemoryOverallocationCreateInfoAMD& operator=(const safe_VkDeviceMemoryOverallocationCreateInfoAMD& copy_src);
+    safe_VkDeviceMemoryOverallocationCreateInfoAMD();
+    ~safe_VkDeviceMemoryOverallocationCreateInfoAMD();
+    void initialize(const VkDeviceMemoryOverallocationCreateInfoAMD* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDeviceMemoryOverallocationCreateInfoAMD* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceMemoryOverallocationCreateInfoAMD* ptr() { return reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD*>(this); }
+    VkDeviceMemoryOverallocationCreateInfoAMD const* ptr() const {
+        return reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxVertexAttribDivisor;
+
+    safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* in_struct,
+                                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
+        const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& operator=(
+        const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT();
+    ~safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT();
+    void initialize(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const*>(this);
+    }
+};
+#ifdef VK_USE_PLATFORM_GGP
+struct safe_VkPresentFrameTokenGGP {
+    VkStructureType sType;
+    const void* pNext{};
+    GgpFrameToken frameToken;
+
+    safe_VkPresentFrameTokenGGP(const VkPresentFrameTokenGGP* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPresentFrameTokenGGP(const safe_VkPresentFrameTokenGGP& copy_src);
+    safe_VkPresentFrameTokenGGP& operator=(const safe_VkPresentFrameTokenGGP& copy_src);
+    safe_VkPresentFrameTokenGGP();
+    ~safe_VkPresentFrameTokenGGP();
+    void initialize(const VkPresentFrameTokenGGP* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPresentFrameTokenGGP* copy_src, PNextCopyState* copy_state = {});
+    VkPresentFrameTokenGGP* ptr() { return reinterpret_cast<VkPresentFrameTokenGGP*>(this); }
+    VkPresentFrameTokenGGP const* ptr() const { return reinterpret_cast<VkPresentFrameTokenGGP const*>(this); }
+};
+#endif  // VK_USE_PLATFORM_GGP
+struct safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 computeDerivativeGroupQuads;
+    VkBool32 computeDerivativeGroupLinear;
+
+    safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* in_struct,
+                                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
+        const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& operator=(
+        const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV();
+    ~safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV();
+    void initialize(const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceMeshShaderFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 taskShader;
+    VkBool32 meshShader;
+
+    safe_VkPhysicalDeviceMeshShaderFeaturesNV(const VkPhysicalDeviceMeshShaderFeaturesNV* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceMeshShaderFeaturesNV(const safe_VkPhysicalDeviceMeshShaderFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceMeshShaderFeaturesNV& operator=(const safe_VkPhysicalDeviceMeshShaderFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceMeshShaderFeaturesNV();
+    ~safe_VkPhysicalDeviceMeshShaderFeaturesNV();
+    void initialize(const VkPhysicalDeviceMeshShaderFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMeshShaderFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMeshShaderFeaturesNV* ptr() { return reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>(this); }
+    VkPhysicalDeviceMeshShaderFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceMeshShaderPropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxDrawMeshTasksCount;
+    uint32_t maxTaskWorkGroupInvocations;
+    uint32_t maxTaskWorkGroupSize[3];
+    uint32_t maxTaskTotalMemorySize;
+    uint32_t maxTaskOutputCount;
+    uint32_t maxMeshWorkGroupInvocations;
+    uint32_t maxMeshWorkGroupSize[3];
+    uint32_t maxMeshTotalMemorySize;
+    uint32_t maxMeshOutputVertices;
+    uint32_t maxMeshOutputPrimitives;
+    uint32_t maxMeshMultiviewViewCount;
+    uint32_t meshOutputPerVertexGranularity;
+    uint32_t meshOutputPerPrimitiveGranularity;
+
+    safe_VkPhysicalDeviceMeshShaderPropertiesNV(const VkPhysicalDeviceMeshShaderPropertiesNV* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceMeshShaderPropertiesNV(const safe_VkPhysicalDeviceMeshShaderPropertiesNV& copy_src);
+    safe_VkPhysicalDeviceMeshShaderPropertiesNV& operator=(const safe_VkPhysicalDeviceMeshShaderPropertiesNV& copy_src);
+    safe_VkPhysicalDeviceMeshShaderPropertiesNV();
+    ~safe_VkPhysicalDeviceMeshShaderPropertiesNV();
+    void initialize(const VkPhysicalDeviceMeshShaderPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMeshShaderPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMeshShaderPropertiesNV* ptr() { return reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV*>(this); }
+    VkPhysicalDeviceMeshShaderPropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 imageFootprint;
+
+    safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV(const VkPhysicalDeviceShaderImageFootprintFeaturesNV* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV(const safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV& operator=(
+        const safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV();
+    ~safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV();
+    void initialize(const VkPhysicalDeviceShaderImageFootprintFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderImageFootprintFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceShaderImageFootprintFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV const*>(this);
+    }
+};
+struct safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t exclusiveScissorCount;
+    const VkRect2D* pExclusiveScissors{};
+
+    safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV(const VkPipelineViewportExclusiveScissorStateCreateInfoNV* in_struct,
+                                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
+        const safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV& copy_src);
+    safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV& operator=(
+        const safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV& copy_src);
+    safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV();
+    ~safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV();
+    void initialize(const VkPipelineViewportExclusiveScissorStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineViewportExclusiveScissorStateCreateInfoNV* ptr() {
+        return reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(this);
+    }
+    VkPipelineViewportExclusiveScissorStateCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceExclusiveScissorFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 exclusiveScissor;
+
+    safe_VkPhysicalDeviceExclusiveScissorFeaturesNV(const VkPhysicalDeviceExclusiveScissorFeaturesNV* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceExclusiveScissorFeaturesNV(const safe_VkPhysicalDeviceExclusiveScissorFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceExclusiveScissorFeaturesNV& operator=(const safe_VkPhysicalDeviceExclusiveScissorFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceExclusiveScissorFeaturesNV();
+    ~safe_VkPhysicalDeviceExclusiveScissorFeaturesNV();
+    void initialize(const VkPhysicalDeviceExclusiveScissorFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceExclusiveScissorFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExclusiveScissorFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceExclusiveScissorFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV const*>(this);
+    }
+};
+struct safe_VkQueueFamilyCheckpointPropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkPipelineStageFlags checkpointExecutionStageMask;
+
+    safe_VkQueueFamilyCheckpointPropertiesNV(const VkQueueFamilyCheckpointPropertiesNV* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkQueueFamilyCheckpointPropertiesNV(const safe_VkQueueFamilyCheckpointPropertiesNV& copy_src);
+    safe_VkQueueFamilyCheckpointPropertiesNV& operator=(const safe_VkQueueFamilyCheckpointPropertiesNV& copy_src);
+    safe_VkQueueFamilyCheckpointPropertiesNV();
+    ~safe_VkQueueFamilyCheckpointPropertiesNV();
+    void initialize(const VkQueueFamilyCheckpointPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkQueueFamilyCheckpointPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkQueueFamilyCheckpointPropertiesNV* ptr() { return reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(this); }
+    VkQueueFamilyCheckpointPropertiesNV const* ptr() const {
+        return reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV const*>(this);
+    }
+};
+struct safe_VkCheckpointDataNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkPipelineStageFlagBits stage;
+    void* pCheckpointMarker{};
+
+    safe_VkCheckpointDataNV(const VkCheckpointDataNV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkCheckpointDataNV(const safe_VkCheckpointDataNV& copy_src);
+    safe_VkCheckpointDataNV& operator=(const safe_VkCheckpointDataNV& copy_src);
+    safe_VkCheckpointDataNV();
+    ~safe_VkCheckpointDataNV();
+    void initialize(const VkCheckpointDataNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCheckpointDataNV* copy_src, PNextCopyState* copy_state = {});
+    VkCheckpointDataNV* ptr() { return reinterpret_cast<VkCheckpointDataNV*>(this); }
+    VkCheckpointDataNV const* ptr() const { return reinterpret_cast<VkCheckpointDataNV const*>(this); }
+};
+struct safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderIntegerFunctions2;
+
+    safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* in_struct,
+                                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
+        const safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& copy_src);
+    safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& operator=(
+        const safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& copy_src);
+    safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL();
+    ~safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL();
+    void initialize(const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL*>(this);
+    }
+    VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const*>(this);
+    }
+};
+union safe_VkPerformanceValueDataINTEL {
+    uint32_t value32;
+    uint64_t value64;
+    float valueFloat;
+    VkBool32 valueBool;
+    const char* valueString{};
+
+    safe_VkPerformanceValueDataINTEL(const VkPerformanceValueDataINTEL* in_struct, PNextCopyState* copy_state = {});
+    safe_VkPerformanceValueDataINTEL(const safe_VkPerformanceValueDataINTEL& copy_src);
+    safe_VkPerformanceValueDataINTEL& operator=(const safe_VkPerformanceValueDataINTEL& copy_src);
+    safe_VkPerformanceValueDataINTEL();
+    ~safe_VkPerformanceValueDataINTEL();
+    void initialize(const VkPerformanceValueDataINTEL* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPerformanceValueDataINTEL* copy_src, PNextCopyState* copy_state = {});
+    VkPerformanceValueDataINTEL* ptr() { return reinterpret_cast<VkPerformanceValueDataINTEL*>(this); }
+    VkPerformanceValueDataINTEL const* ptr() const { return reinterpret_cast<VkPerformanceValueDataINTEL const*>(this); }
+};
+struct safe_VkInitializePerformanceApiInfoINTEL {
+    VkStructureType sType;
+    const void* pNext{};
+    void* pUserData{};
+
+    safe_VkInitializePerformanceApiInfoINTEL(const VkInitializePerformanceApiInfoINTEL* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkInitializePerformanceApiInfoINTEL(const safe_VkInitializePerformanceApiInfoINTEL& copy_src);
+    safe_VkInitializePerformanceApiInfoINTEL& operator=(const safe_VkInitializePerformanceApiInfoINTEL& copy_src);
+    safe_VkInitializePerformanceApiInfoINTEL();
+    ~safe_VkInitializePerformanceApiInfoINTEL();
+    void initialize(const VkInitializePerformanceApiInfoINTEL* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkInitializePerformanceApiInfoINTEL* copy_src, PNextCopyState* copy_state = {});
+    VkInitializePerformanceApiInfoINTEL* ptr() { return reinterpret_cast<VkInitializePerformanceApiInfoINTEL*>(this); }
+    VkInitializePerformanceApiInfoINTEL const* ptr() const {
+        return reinterpret_cast<VkInitializePerformanceApiInfoINTEL const*>(this);
+    }
+};
+struct safe_VkQueryPoolPerformanceQueryCreateInfoINTEL {
+    VkStructureType sType;
+    const void* pNext{};
+    VkQueryPoolSamplingModeINTEL performanceCountersSampling;
+
+    safe_VkQueryPoolPerformanceQueryCreateInfoINTEL(const VkQueryPoolPerformanceQueryCreateInfoINTEL* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkQueryPoolPerformanceQueryCreateInfoINTEL(const safe_VkQueryPoolPerformanceQueryCreateInfoINTEL& copy_src);
+    safe_VkQueryPoolPerformanceQueryCreateInfoINTEL& operator=(const safe_VkQueryPoolPerformanceQueryCreateInfoINTEL& copy_src);
+    safe_VkQueryPoolPerformanceQueryCreateInfoINTEL();
+    ~safe_VkQueryPoolPerformanceQueryCreateInfoINTEL();
+    void initialize(const VkQueryPoolPerformanceQueryCreateInfoINTEL* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkQueryPoolPerformanceQueryCreateInfoINTEL* copy_src, PNextCopyState* copy_state = {});
+    VkQueryPoolPerformanceQueryCreateInfoINTEL* ptr() {
+        return reinterpret_cast<VkQueryPoolPerformanceQueryCreateInfoINTEL*>(this);
+    }
+    VkQueryPoolPerformanceQueryCreateInfoINTEL const* ptr() const {
+        return reinterpret_cast<VkQueryPoolPerformanceQueryCreateInfoINTEL const*>(this);
+    }
+};
+struct safe_VkPerformanceMarkerInfoINTEL {
+    VkStructureType sType;
+    const void* pNext{};
+    uint64_t marker;
+
+    safe_VkPerformanceMarkerInfoINTEL(const VkPerformanceMarkerInfoINTEL* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    safe_VkPerformanceMarkerInfoINTEL(const safe_VkPerformanceMarkerInfoINTEL& copy_src);
+    safe_VkPerformanceMarkerInfoINTEL& operator=(const safe_VkPerformanceMarkerInfoINTEL& copy_src);
+    safe_VkPerformanceMarkerInfoINTEL();
+    ~safe_VkPerformanceMarkerInfoINTEL();
+    void initialize(const VkPerformanceMarkerInfoINTEL* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPerformanceMarkerInfoINTEL* copy_src, PNextCopyState* copy_state = {});
+    VkPerformanceMarkerInfoINTEL* ptr() { return reinterpret_cast<VkPerformanceMarkerInfoINTEL*>(this); }
+    VkPerformanceMarkerInfoINTEL const* ptr() const { return reinterpret_cast<VkPerformanceMarkerInfoINTEL const*>(this); }
+};
+struct safe_VkPerformanceStreamMarkerInfoINTEL {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t marker;
+
+    safe_VkPerformanceStreamMarkerInfoINTEL(const VkPerformanceStreamMarkerInfoINTEL* in_struct, PNextCopyState* copy_state = {},
+                                            bool copy_pnext = true);
+    safe_VkPerformanceStreamMarkerInfoINTEL(const safe_VkPerformanceStreamMarkerInfoINTEL& copy_src);
+    safe_VkPerformanceStreamMarkerInfoINTEL& operator=(const safe_VkPerformanceStreamMarkerInfoINTEL& copy_src);
+    safe_VkPerformanceStreamMarkerInfoINTEL();
+    ~safe_VkPerformanceStreamMarkerInfoINTEL();
+    void initialize(const VkPerformanceStreamMarkerInfoINTEL* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPerformanceStreamMarkerInfoINTEL* copy_src, PNextCopyState* copy_state = {});
+    VkPerformanceStreamMarkerInfoINTEL* ptr() { return reinterpret_cast<VkPerformanceStreamMarkerInfoINTEL*>(this); }
+    VkPerformanceStreamMarkerInfoINTEL const* ptr() const {
+        return reinterpret_cast<VkPerformanceStreamMarkerInfoINTEL const*>(this);
+    }
+};
+struct safe_VkPerformanceOverrideInfoINTEL {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPerformanceOverrideTypeINTEL type;
+    VkBool32 enable;
+    uint64_t parameter;
+
+    safe_VkPerformanceOverrideInfoINTEL(const VkPerformanceOverrideInfoINTEL* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkPerformanceOverrideInfoINTEL(const safe_VkPerformanceOverrideInfoINTEL& copy_src);
+    safe_VkPerformanceOverrideInfoINTEL& operator=(const safe_VkPerformanceOverrideInfoINTEL& copy_src);
+    safe_VkPerformanceOverrideInfoINTEL();
+    ~safe_VkPerformanceOverrideInfoINTEL();
+    void initialize(const VkPerformanceOverrideInfoINTEL* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPerformanceOverrideInfoINTEL* copy_src, PNextCopyState* copy_state = {});
+    VkPerformanceOverrideInfoINTEL* ptr() { return reinterpret_cast<VkPerformanceOverrideInfoINTEL*>(this); }
+    VkPerformanceOverrideInfoINTEL const* ptr() const { return reinterpret_cast<VkPerformanceOverrideInfoINTEL const*>(this); }
+};
+struct safe_VkPerformanceConfigurationAcquireInfoINTEL {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPerformanceConfigurationTypeINTEL type;
+
+    safe_VkPerformanceConfigurationAcquireInfoINTEL(const VkPerformanceConfigurationAcquireInfoINTEL* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPerformanceConfigurationAcquireInfoINTEL(const safe_VkPerformanceConfigurationAcquireInfoINTEL& copy_src);
+    safe_VkPerformanceConfigurationAcquireInfoINTEL& operator=(const safe_VkPerformanceConfigurationAcquireInfoINTEL& copy_src);
+    safe_VkPerformanceConfigurationAcquireInfoINTEL();
+    ~safe_VkPerformanceConfigurationAcquireInfoINTEL();
+    void initialize(const VkPerformanceConfigurationAcquireInfoINTEL* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPerformanceConfigurationAcquireInfoINTEL* copy_src, PNextCopyState* copy_state = {});
+    VkPerformanceConfigurationAcquireInfoINTEL* ptr() {
+        return reinterpret_cast<VkPerformanceConfigurationAcquireInfoINTEL*>(this);
+    }
+    VkPerformanceConfigurationAcquireInfoINTEL const* ptr() const {
+        return reinterpret_cast<VkPerformanceConfigurationAcquireInfoINTEL const*>(this);
+    }
+};
+struct safe_VkPhysicalDevicePCIBusInfoPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t pciDomain;
+    uint32_t pciBus;
+    uint32_t pciDevice;
+    uint32_t pciFunction;
+
+    safe_VkPhysicalDevicePCIBusInfoPropertiesEXT(const VkPhysicalDevicePCIBusInfoPropertiesEXT* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDevicePCIBusInfoPropertiesEXT(const safe_VkPhysicalDevicePCIBusInfoPropertiesEXT& copy_src);
+    safe_VkPhysicalDevicePCIBusInfoPropertiesEXT& operator=(const safe_VkPhysicalDevicePCIBusInfoPropertiesEXT& copy_src);
+    safe_VkPhysicalDevicePCIBusInfoPropertiesEXT();
+    ~safe_VkPhysicalDevicePCIBusInfoPropertiesEXT();
+    void initialize(const VkPhysicalDevicePCIBusInfoPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePCIBusInfoPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePCIBusInfoPropertiesEXT* ptr() { return reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT*>(this); }
+    VkPhysicalDevicePCIBusInfoPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT const*>(this);
+    }
+};
+struct safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 localDimmingSupport;
+
+    safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD(const VkDisplayNativeHdrSurfaceCapabilitiesAMD* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD(const safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD& copy_src);
+    safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD& operator=(const safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD& copy_src);
+    safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD();
+    ~safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD();
+    void initialize(const VkDisplayNativeHdrSurfaceCapabilitiesAMD* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD* copy_src, PNextCopyState* copy_state = {});
+    VkDisplayNativeHdrSurfaceCapabilitiesAMD* ptr() { return reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD*>(this); }
+    VkDisplayNativeHdrSurfaceCapabilitiesAMD const* ptr() const {
+        return reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD const*>(this);
+    }
+};
+struct safe_VkSwapchainDisplayNativeHdrCreateInfoAMD {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 localDimmingEnable;
+
+    safe_VkSwapchainDisplayNativeHdrCreateInfoAMD(const VkSwapchainDisplayNativeHdrCreateInfoAMD* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSwapchainDisplayNativeHdrCreateInfoAMD(const safe_VkSwapchainDisplayNativeHdrCreateInfoAMD& copy_src);
+    safe_VkSwapchainDisplayNativeHdrCreateInfoAMD& operator=(const safe_VkSwapchainDisplayNativeHdrCreateInfoAMD& copy_src);
+    safe_VkSwapchainDisplayNativeHdrCreateInfoAMD();
+    ~safe_VkSwapchainDisplayNativeHdrCreateInfoAMD();
+    void initialize(const VkSwapchainDisplayNativeHdrCreateInfoAMD* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSwapchainDisplayNativeHdrCreateInfoAMD* copy_src, PNextCopyState* copy_state = {});
+    VkSwapchainDisplayNativeHdrCreateInfoAMD* ptr() { return reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD*>(this); }
+    VkSwapchainDisplayNativeHdrCreateInfoAMD const* ptr() const {
+        return reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD const*>(this);
+    }
+};
+#ifdef VK_USE_PLATFORM_FUCHSIA
+struct safe_VkImagePipeSurfaceCreateInfoFUCHSIA {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImagePipeSurfaceCreateFlagsFUCHSIA flags;
+    zx_handle_t imagePipeHandle;
+
+    safe_VkImagePipeSurfaceCreateInfoFUCHSIA(const VkImagePipeSurfaceCreateInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkImagePipeSurfaceCreateInfoFUCHSIA(const safe_VkImagePipeSurfaceCreateInfoFUCHSIA& copy_src);
+    safe_VkImagePipeSurfaceCreateInfoFUCHSIA& operator=(const safe_VkImagePipeSurfaceCreateInfoFUCHSIA& copy_src);
+    safe_VkImagePipeSurfaceCreateInfoFUCHSIA();
+    ~safe_VkImagePipeSurfaceCreateInfoFUCHSIA();
+    void initialize(const VkImagePipeSurfaceCreateInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImagePipeSurfaceCreateInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {});
+    VkImagePipeSurfaceCreateInfoFUCHSIA* ptr() { return reinterpret_cast<VkImagePipeSurfaceCreateInfoFUCHSIA*>(this); }
+    VkImagePipeSurfaceCreateInfoFUCHSIA const* ptr() const {
+        return reinterpret_cast<VkImagePipeSurfaceCreateInfoFUCHSIA const*>(this);
+    }
+};
+#endif  // VK_USE_PLATFORM_FUCHSIA
+struct safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 fragmentDensityMap;
+    VkBool32 fragmentDensityMapDynamic;
+    VkBool32 fragmentDensityMapNonSubsampledImages;
+
+    safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(const safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT();
+    ~safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT();
+    void initialize(const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFragmentDensityMapFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceFragmentDensityMapFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkExtent2D minFragmentDensityTexelSize;
+    VkExtent2D maxFragmentDensityTexelSize;
+    VkBool32 fragmentDensityInvocations;
+
+    safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(const safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT& operator=(
+        const safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT();
+    ~safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT();
+    void initialize(const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFragmentDensityMapPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceFragmentDensityMapPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT const*>(this);
+    }
+};
+struct safe_VkRenderPassFragmentDensityMapCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAttachmentReference fragmentDensityMapAttachment;
+
+    safe_VkRenderPassFragmentDensityMapCreateInfoEXT(const VkRenderPassFragmentDensityMapCreateInfoEXT* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkRenderPassFragmentDensityMapCreateInfoEXT(const safe_VkRenderPassFragmentDensityMapCreateInfoEXT& copy_src);
+    safe_VkRenderPassFragmentDensityMapCreateInfoEXT& operator=(const safe_VkRenderPassFragmentDensityMapCreateInfoEXT& copy_src);
+    safe_VkRenderPassFragmentDensityMapCreateInfoEXT();
+    ~safe_VkRenderPassFragmentDensityMapCreateInfoEXT();
+    void initialize(const VkRenderPassFragmentDensityMapCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderPassFragmentDensityMapCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassFragmentDensityMapCreateInfoEXT* ptr() {
+        return reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT*>(this);
+    }
+    VkRenderPassFragmentDensityMapCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceShaderCoreProperties2AMD {
+    VkStructureType sType;
+    void* pNext{};
+    VkShaderCorePropertiesFlagsAMD shaderCoreFeatures;
+    uint32_t activeComputeUnitCount;
+
+    safe_VkPhysicalDeviceShaderCoreProperties2AMD(const VkPhysicalDeviceShaderCoreProperties2AMD* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderCoreProperties2AMD(const safe_VkPhysicalDeviceShaderCoreProperties2AMD& copy_src);
+    safe_VkPhysicalDeviceShaderCoreProperties2AMD& operator=(const safe_VkPhysicalDeviceShaderCoreProperties2AMD& copy_src);
+    safe_VkPhysicalDeviceShaderCoreProperties2AMD();
+    ~safe_VkPhysicalDeviceShaderCoreProperties2AMD();
+    void initialize(const VkPhysicalDeviceShaderCoreProperties2AMD* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderCoreProperties2AMD* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderCoreProperties2AMD* ptr() { return reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD*>(this); }
+    VkPhysicalDeviceShaderCoreProperties2AMD const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 deviceCoherentMemory;
+
+    safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD(const VkPhysicalDeviceCoherentMemoryFeaturesAMD* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD(const safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD& copy_src);
+    safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD& operator=(const safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD& copy_src);
+    safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD();
+    ~safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD();
+    void initialize(const VkPhysicalDeviceCoherentMemoryFeaturesAMD* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCoherentMemoryFeaturesAMD* ptr() { return reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD*>(this); }
+    VkPhysicalDeviceCoherentMemoryFeaturesAMD const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderImageInt64Atomics;
+    VkBool32 sparseImageInt64Atomics;
+
+    safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* in_struct,
+                                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(const safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT();
+    ~safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT();
+    void initialize(const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceSize heapBudget[VK_MAX_MEMORY_HEAPS];
+    VkDeviceSize heapUsage[VK_MAX_MEMORY_HEAPS];
+
+    safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT(const VkPhysicalDeviceMemoryBudgetPropertiesEXT* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT(const safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT& operator=(const safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT();
+    ~safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT();
+    void initialize(const VkPhysicalDeviceMemoryBudgetPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMemoryBudgetPropertiesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT*>(this); }
+    VkPhysicalDeviceMemoryBudgetPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 memoryPriority;
+
+    safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT(const VkPhysicalDeviceMemoryPriorityFeaturesEXT* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT(const safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT& operator=(const safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT();
+    ~safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT();
+    void initialize(const VkPhysicalDeviceMemoryPriorityFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMemoryPriorityFeaturesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT*>(this); }
+    VkPhysicalDeviceMemoryPriorityFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkMemoryPriorityAllocateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    float priority;
+
+    safe_VkMemoryPriorityAllocateInfoEXT(const VkMemoryPriorityAllocateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkMemoryPriorityAllocateInfoEXT(const safe_VkMemoryPriorityAllocateInfoEXT& copy_src);
+    safe_VkMemoryPriorityAllocateInfoEXT& operator=(const safe_VkMemoryPriorityAllocateInfoEXT& copy_src);
+    safe_VkMemoryPriorityAllocateInfoEXT();
+    ~safe_VkMemoryPriorityAllocateInfoEXT();
+    void initialize(const VkMemoryPriorityAllocateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMemoryPriorityAllocateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryPriorityAllocateInfoEXT* ptr() { return reinterpret_cast<VkMemoryPriorityAllocateInfoEXT*>(this); }
+    VkMemoryPriorityAllocateInfoEXT const* ptr() const { return reinterpret_cast<VkMemoryPriorityAllocateInfoEXT const*>(this); }
+};
+struct safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 dedicatedAllocationImageAliasing;
+
+    safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
+        const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
+        const safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& operator=(
+        const safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV();
+    ~safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV();
+    void initialize(const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* copy_src,
+                    PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 bufferDeviceAddress;
+    VkBool32 bufferDeviceAddressCaptureReplay;
+    VkBool32 bufferDeviceAddressMultiDevice;
+
+    safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(const safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT();
+    ~safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT();
+    void initialize(const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkBufferDeviceAddressCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceAddress deviceAddress;
+
+    safe_VkBufferDeviceAddressCreateInfoEXT(const VkBufferDeviceAddressCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                            bool copy_pnext = true);
+    safe_VkBufferDeviceAddressCreateInfoEXT(const safe_VkBufferDeviceAddressCreateInfoEXT& copy_src);
+    safe_VkBufferDeviceAddressCreateInfoEXT& operator=(const safe_VkBufferDeviceAddressCreateInfoEXT& copy_src);
+    safe_VkBufferDeviceAddressCreateInfoEXT();
+    ~safe_VkBufferDeviceAddressCreateInfoEXT();
+    void initialize(const VkBufferDeviceAddressCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBufferDeviceAddressCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkBufferDeviceAddressCreateInfoEXT* ptr() { return reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT*>(this); }
+    VkBufferDeviceAddressCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT const*>(this);
+    }
+};
+struct safe_VkValidationFeaturesEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t enabledValidationFeatureCount;
+    const VkValidationFeatureEnableEXT* pEnabledValidationFeatures{};
+    uint32_t disabledValidationFeatureCount;
+    const VkValidationFeatureDisableEXT* pDisabledValidationFeatures{};
+
+    safe_VkValidationFeaturesEXT(const VkValidationFeaturesEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkValidationFeaturesEXT(const safe_VkValidationFeaturesEXT& copy_src);
+    safe_VkValidationFeaturesEXT& operator=(const safe_VkValidationFeaturesEXT& copy_src);
+    safe_VkValidationFeaturesEXT();
+    ~safe_VkValidationFeaturesEXT();
+    void initialize(const VkValidationFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkValidationFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkValidationFeaturesEXT* ptr() { return reinterpret_cast<VkValidationFeaturesEXT*>(this); }
+    VkValidationFeaturesEXT const* ptr() const { return reinterpret_cast<VkValidationFeaturesEXT const*>(this); }
+};
+struct safe_VkCooperativeMatrixPropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t MSize;
+    uint32_t NSize;
+    uint32_t KSize;
+    VkComponentTypeNV AType;
+    VkComponentTypeNV BType;
+    VkComponentTypeNV CType;
+    VkComponentTypeNV DType;
+    VkScopeNV scope;
+
+    safe_VkCooperativeMatrixPropertiesNV(const VkCooperativeMatrixPropertiesNV* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkCooperativeMatrixPropertiesNV(const safe_VkCooperativeMatrixPropertiesNV& copy_src);
+    safe_VkCooperativeMatrixPropertiesNV& operator=(const safe_VkCooperativeMatrixPropertiesNV& copy_src);
+    safe_VkCooperativeMatrixPropertiesNV();
+    ~safe_VkCooperativeMatrixPropertiesNV();
+    void initialize(const VkCooperativeMatrixPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCooperativeMatrixPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkCooperativeMatrixPropertiesNV* ptr() { return reinterpret_cast<VkCooperativeMatrixPropertiesNV*>(this); }
+    VkCooperativeMatrixPropertiesNV const* ptr() const { return reinterpret_cast<VkCooperativeMatrixPropertiesNV const*>(this); }
+};
+struct safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 cooperativeMatrix;
+    VkBool32 cooperativeMatrixRobustBufferAccess;
+
+    safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV(const VkPhysicalDeviceCooperativeMatrixFeaturesNV* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV(const safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV& operator=(const safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV();
+    ~safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV();
+    void initialize(const VkPhysicalDeviceCooperativeMatrixFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCooperativeMatrixFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceCooperativeMatrixFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkShaderStageFlags cooperativeMatrixSupportedStages;
+
+    safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV(const VkPhysicalDeviceCooperativeMatrixPropertiesNV* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV(const safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV& copy_src);
+    safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV& operator=(
+        const safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV& copy_src);
+    safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV();
+    ~safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV();
+    void initialize(const VkPhysicalDeviceCooperativeMatrixPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCooperativeMatrixPropertiesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV*>(this);
+    }
+    VkPhysicalDeviceCooperativeMatrixPropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 coverageReductionMode;
+
+    safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV(const VkPhysicalDeviceCoverageReductionModeFeaturesNV* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV(const safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV& operator=(
+        const safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV();
+    ~safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV();
+    void initialize(const VkPhysicalDeviceCoverageReductionModeFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCoverageReductionModeFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceCoverageReductionModeFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV const*>(this);
+    }
+};
+struct safe_VkPipelineCoverageReductionStateCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineCoverageReductionStateCreateFlagsNV flags;
+    VkCoverageReductionModeNV coverageReductionMode;
+
+    safe_VkPipelineCoverageReductionStateCreateInfoNV(const VkPipelineCoverageReductionStateCreateInfoNV* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineCoverageReductionStateCreateInfoNV(const safe_VkPipelineCoverageReductionStateCreateInfoNV& copy_src);
+    safe_VkPipelineCoverageReductionStateCreateInfoNV& operator=(const safe_VkPipelineCoverageReductionStateCreateInfoNV& copy_src);
+    safe_VkPipelineCoverageReductionStateCreateInfoNV();
+    ~safe_VkPipelineCoverageReductionStateCreateInfoNV();
+    void initialize(const VkPipelineCoverageReductionStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineCoverageReductionStateCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineCoverageReductionStateCreateInfoNV* ptr() {
+        return reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV*>(this);
+    }
+    VkPipelineCoverageReductionStateCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV const*>(this);
+    }
+};
+struct safe_VkFramebufferMixedSamplesCombinationNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkCoverageReductionModeNV coverageReductionMode;
+    VkSampleCountFlagBits rasterizationSamples;
+    VkSampleCountFlags depthStencilSamples;
+    VkSampleCountFlags colorSamples;
+
+    safe_VkFramebufferMixedSamplesCombinationNV(const VkFramebufferMixedSamplesCombinationNV* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkFramebufferMixedSamplesCombinationNV(const safe_VkFramebufferMixedSamplesCombinationNV& copy_src);
+    safe_VkFramebufferMixedSamplesCombinationNV& operator=(const safe_VkFramebufferMixedSamplesCombinationNV& copy_src);
+    safe_VkFramebufferMixedSamplesCombinationNV();
+    ~safe_VkFramebufferMixedSamplesCombinationNV();
+    void initialize(const VkFramebufferMixedSamplesCombinationNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkFramebufferMixedSamplesCombinationNV* copy_src, PNextCopyState* copy_state = {});
+    VkFramebufferMixedSamplesCombinationNV* ptr() { return reinterpret_cast<VkFramebufferMixedSamplesCombinationNV*>(this); }
+    VkFramebufferMixedSamplesCombinationNV const* ptr() const {
+        return reinterpret_cast<VkFramebufferMixedSamplesCombinationNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 fragmentShaderSampleInterlock;
+    VkBool32 fragmentShaderPixelInterlock;
+    VkBool32 fragmentShaderShadingRateInterlock;
+
+    safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* in_struct,
+                                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
+        const safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT();
+    ~safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT();
+    void initialize(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 ycbcrImageArrays;
+
+    safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(const safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& operator=(const safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT();
+    ~safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT();
+    void initialize(const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceProvokingVertexFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 provokingVertexLast;
+    VkBool32 transformFeedbackPreservesProvokingVertex;
+
+    safe_VkPhysicalDeviceProvokingVertexFeaturesEXT(const VkPhysicalDeviceProvokingVertexFeaturesEXT* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceProvokingVertexFeaturesEXT(const safe_VkPhysicalDeviceProvokingVertexFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceProvokingVertexFeaturesEXT& operator=(const safe_VkPhysicalDeviceProvokingVertexFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceProvokingVertexFeaturesEXT();
+    ~safe_VkPhysicalDeviceProvokingVertexFeaturesEXT();
+    void initialize(const VkPhysicalDeviceProvokingVertexFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceProvokingVertexFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceProvokingVertexFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceProvokingVertexFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceProvokingVertexFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceProvokingVertexFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceProvokingVertexPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 provokingVertexModePerPipeline;
+    VkBool32 transformFeedbackPreservesTriangleFanProvokingVertex;
+
+    safe_VkPhysicalDeviceProvokingVertexPropertiesEXT(const VkPhysicalDeviceProvokingVertexPropertiesEXT* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceProvokingVertexPropertiesEXT(const safe_VkPhysicalDeviceProvokingVertexPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceProvokingVertexPropertiesEXT& operator=(const safe_VkPhysicalDeviceProvokingVertexPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceProvokingVertexPropertiesEXT();
+    ~safe_VkPhysicalDeviceProvokingVertexPropertiesEXT();
+    void initialize(const VkPhysicalDeviceProvokingVertexPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceProvokingVertexPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceProvokingVertexPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceProvokingVertexPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceProvokingVertexPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceProvokingVertexPropertiesEXT const*>(this);
+    }
+};
+struct safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkProvokingVertexModeEXT provokingVertexMode;
+
+    safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
+        const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
+        const safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT& copy_src);
+    safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT& operator=(
+        const safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT& copy_src);
+    safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT();
+    ~safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT();
+    void initialize(const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* ptr() {
+        return reinterpret_cast<VkPipelineRasterizationProvokingVertexStateCreateInfoEXT*>(this);
+    }
+    VkPipelineRasterizationProvokingVertexStateCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkPipelineRasterizationProvokingVertexStateCreateInfoEXT const*>(this);
+    }
+};
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+struct safe_VkSurfaceFullScreenExclusiveInfoEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkFullScreenExclusiveEXT fullScreenExclusive;
+
+    safe_VkSurfaceFullScreenExclusiveInfoEXT(const VkSurfaceFullScreenExclusiveInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkSurfaceFullScreenExclusiveInfoEXT(const safe_VkSurfaceFullScreenExclusiveInfoEXT& copy_src);
+    safe_VkSurfaceFullScreenExclusiveInfoEXT& operator=(const safe_VkSurfaceFullScreenExclusiveInfoEXT& copy_src);
+    safe_VkSurfaceFullScreenExclusiveInfoEXT();
+    ~safe_VkSurfaceFullScreenExclusiveInfoEXT();
+    void initialize(const VkSurfaceFullScreenExclusiveInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSurfaceFullScreenExclusiveInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSurfaceFullScreenExclusiveInfoEXT* ptr() { return reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT*>(this); }
+    VkSurfaceFullScreenExclusiveInfoEXT const* ptr() const {
+        return reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT const*>(this);
+    }
+};
+struct safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 fullScreenExclusiveSupported;
+
+    safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT(const VkSurfaceCapabilitiesFullScreenExclusiveEXT* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT(const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT& copy_src);
+    safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT& operator=(const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT& copy_src);
+    safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT();
+    ~safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT();
+    void initialize(const VkSurfaceCapabilitiesFullScreenExclusiveEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSurfaceCapabilitiesFullScreenExclusiveEXT* ptr() {
+        return reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT*>(this);
+    }
+    VkSurfaceCapabilitiesFullScreenExclusiveEXT const* ptr() const {
+        return reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT const*>(this);
+    }
+};
+struct safe_VkSurfaceFullScreenExclusiveWin32InfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    HMONITOR hmonitor;
+
+    safe_VkSurfaceFullScreenExclusiveWin32InfoEXT(const VkSurfaceFullScreenExclusiveWin32InfoEXT* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSurfaceFullScreenExclusiveWin32InfoEXT(const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT& copy_src);
+    safe_VkSurfaceFullScreenExclusiveWin32InfoEXT& operator=(const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT& copy_src);
+    safe_VkSurfaceFullScreenExclusiveWin32InfoEXT();
+    ~safe_VkSurfaceFullScreenExclusiveWin32InfoEXT();
+    void initialize(const VkSurfaceFullScreenExclusiveWin32InfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSurfaceFullScreenExclusiveWin32InfoEXT* ptr() { return reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT*>(this); }
+    VkSurfaceFullScreenExclusiveWin32InfoEXT const* ptr() const {
+        return reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT const*>(this);
+    }
+};
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+struct safe_VkHeadlessSurfaceCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkHeadlessSurfaceCreateFlagsEXT flags;
+
+    safe_VkHeadlessSurfaceCreateInfoEXT(const VkHeadlessSurfaceCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkHeadlessSurfaceCreateInfoEXT(const safe_VkHeadlessSurfaceCreateInfoEXT& copy_src);
+    safe_VkHeadlessSurfaceCreateInfoEXT& operator=(const safe_VkHeadlessSurfaceCreateInfoEXT& copy_src);
+    safe_VkHeadlessSurfaceCreateInfoEXT();
+    ~safe_VkHeadlessSurfaceCreateInfoEXT();
+    void initialize(const VkHeadlessSurfaceCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkHeadlessSurfaceCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkHeadlessSurfaceCreateInfoEXT* ptr() { return reinterpret_cast<VkHeadlessSurfaceCreateInfoEXT*>(this); }
+    VkHeadlessSurfaceCreateInfoEXT const* ptr() const { return reinterpret_cast<VkHeadlessSurfaceCreateInfoEXT const*>(this); }
+};
+struct safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderBufferFloat32Atomics;
+    VkBool32 shaderBufferFloat32AtomicAdd;
+    VkBool32 shaderBufferFloat64Atomics;
+    VkBool32 shaderBufferFloat64AtomicAdd;
+    VkBool32 shaderSharedFloat32Atomics;
+    VkBool32 shaderSharedFloat32AtomicAdd;
+    VkBool32 shaderSharedFloat64Atomics;
+    VkBool32 shaderSharedFloat64AtomicAdd;
+    VkBool32 shaderImageFloat32Atomics;
+    VkBool32 shaderImageFloat32AtomicAdd;
+    VkBool32 sparseImageFloat32Atomics;
+    VkBool32 sparseImageFloat32AtomicAdd;
+
+    safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(const safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& operator=(const safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT();
+    ~safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT();
+    void initialize(const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceShaderAtomicFloatFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 extendedDynamicState;
+
+    safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(const safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT();
+    ~safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT();
+    void initialize(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceExtendedDynamicStateFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceHostImageCopyFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 hostImageCopy;
+
+    safe_VkPhysicalDeviceHostImageCopyFeaturesEXT(const VkPhysicalDeviceHostImageCopyFeaturesEXT* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceHostImageCopyFeaturesEXT(const safe_VkPhysicalDeviceHostImageCopyFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceHostImageCopyFeaturesEXT& operator=(const safe_VkPhysicalDeviceHostImageCopyFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceHostImageCopyFeaturesEXT();
+    ~safe_VkPhysicalDeviceHostImageCopyFeaturesEXT();
+    void initialize(const VkPhysicalDeviceHostImageCopyFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceHostImageCopyFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceHostImageCopyFeaturesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceHostImageCopyFeaturesEXT*>(this); }
+    VkPhysicalDeviceHostImageCopyFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceHostImageCopyFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceHostImageCopyPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t copySrcLayoutCount;
+    VkImageLayout* pCopySrcLayouts{};
+    uint32_t copyDstLayoutCount;
+    VkImageLayout* pCopyDstLayouts{};
+    uint8_t optimalTilingLayoutUUID[VK_UUID_SIZE];
+    VkBool32 identicalMemoryTypeRequirements;
+
+    safe_VkPhysicalDeviceHostImageCopyPropertiesEXT(const VkPhysicalDeviceHostImageCopyPropertiesEXT* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceHostImageCopyPropertiesEXT(const safe_VkPhysicalDeviceHostImageCopyPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceHostImageCopyPropertiesEXT& operator=(const safe_VkPhysicalDeviceHostImageCopyPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceHostImageCopyPropertiesEXT();
+    ~safe_VkPhysicalDeviceHostImageCopyPropertiesEXT();
+    void initialize(const VkPhysicalDeviceHostImageCopyPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceHostImageCopyPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceHostImageCopyPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceHostImageCopyPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceHostImageCopyPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceHostImageCopyPropertiesEXT const*>(this);
+    }
+};
+struct safe_VkMemoryToImageCopyEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    const void* pHostPointer{};
+    uint32_t memoryRowLength;
+    uint32_t memoryImageHeight;
+    VkImageSubresourceLayers imageSubresource;
+    VkOffset3D imageOffset;
+    VkExtent3D imageExtent;
+
+    safe_VkMemoryToImageCopyEXT(const VkMemoryToImageCopyEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkMemoryToImageCopyEXT(const safe_VkMemoryToImageCopyEXT& copy_src);
+    safe_VkMemoryToImageCopyEXT& operator=(const safe_VkMemoryToImageCopyEXT& copy_src);
+    safe_VkMemoryToImageCopyEXT();
+    ~safe_VkMemoryToImageCopyEXT();
+    void initialize(const VkMemoryToImageCopyEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMemoryToImageCopyEXT* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryToImageCopyEXT* ptr() { return reinterpret_cast<VkMemoryToImageCopyEXT*>(this); }
+    VkMemoryToImageCopyEXT const* ptr() const { return reinterpret_cast<VkMemoryToImageCopyEXT const*>(this); }
+};
+struct safe_VkImageToMemoryCopyEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    void* pHostPointer{};
+    uint32_t memoryRowLength;
+    uint32_t memoryImageHeight;
+    VkImageSubresourceLayers imageSubresource;
+    VkOffset3D imageOffset;
+    VkExtent3D imageExtent;
+
+    safe_VkImageToMemoryCopyEXT(const VkImageToMemoryCopyEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkImageToMemoryCopyEXT(const safe_VkImageToMemoryCopyEXT& copy_src);
+    safe_VkImageToMemoryCopyEXT& operator=(const safe_VkImageToMemoryCopyEXT& copy_src);
+    safe_VkImageToMemoryCopyEXT();
+    ~safe_VkImageToMemoryCopyEXT();
+    void initialize(const VkImageToMemoryCopyEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageToMemoryCopyEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImageToMemoryCopyEXT* ptr() { return reinterpret_cast<VkImageToMemoryCopyEXT*>(this); }
+    VkImageToMemoryCopyEXT const* ptr() const { return reinterpret_cast<VkImageToMemoryCopyEXT const*>(this); }
+};
+struct safe_VkCopyMemoryToImageInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkHostImageCopyFlagsEXT flags;
+    VkImage dstImage;
+    VkImageLayout dstImageLayout;
+    uint32_t regionCount;
+    safe_VkMemoryToImageCopyEXT* pRegions{};
+
+    safe_VkCopyMemoryToImageInfoEXT(const VkCopyMemoryToImageInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    safe_VkCopyMemoryToImageInfoEXT(const safe_VkCopyMemoryToImageInfoEXT& copy_src);
+    safe_VkCopyMemoryToImageInfoEXT& operator=(const safe_VkCopyMemoryToImageInfoEXT& copy_src);
+    safe_VkCopyMemoryToImageInfoEXT();
+    ~safe_VkCopyMemoryToImageInfoEXT();
+    void initialize(const VkCopyMemoryToImageInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCopyMemoryToImageInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkCopyMemoryToImageInfoEXT* ptr() { return reinterpret_cast<VkCopyMemoryToImageInfoEXT*>(this); }
+    VkCopyMemoryToImageInfoEXT const* ptr() const { return reinterpret_cast<VkCopyMemoryToImageInfoEXT const*>(this); }
+};
+struct safe_VkCopyImageToMemoryInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkHostImageCopyFlagsEXT flags;
+    VkImage srcImage;
+    VkImageLayout srcImageLayout;
+    uint32_t regionCount;
+    safe_VkImageToMemoryCopyEXT* pRegions{};
+
+    safe_VkCopyImageToMemoryInfoEXT(const VkCopyImageToMemoryInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    safe_VkCopyImageToMemoryInfoEXT(const safe_VkCopyImageToMemoryInfoEXT& copy_src);
+    safe_VkCopyImageToMemoryInfoEXT& operator=(const safe_VkCopyImageToMemoryInfoEXT& copy_src);
+    safe_VkCopyImageToMemoryInfoEXT();
+    ~safe_VkCopyImageToMemoryInfoEXT();
+    void initialize(const VkCopyImageToMemoryInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCopyImageToMemoryInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkCopyImageToMemoryInfoEXT* ptr() { return reinterpret_cast<VkCopyImageToMemoryInfoEXT*>(this); }
+    VkCopyImageToMemoryInfoEXT const* ptr() const { return reinterpret_cast<VkCopyImageToMemoryInfoEXT const*>(this); }
+};
+struct safe_VkCopyImageToImageInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkHostImageCopyFlagsEXT flags;
+    VkImage srcImage;
+    VkImageLayout srcImageLayout;
+    VkImage dstImage;
+    VkImageLayout dstImageLayout;
+    uint32_t regionCount;
+    safe_VkImageCopy2* pRegions{};
+
+    safe_VkCopyImageToImageInfoEXT(const VkCopyImageToImageInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    safe_VkCopyImageToImageInfoEXT(const safe_VkCopyImageToImageInfoEXT& copy_src);
+    safe_VkCopyImageToImageInfoEXT& operator=(const safe_VkCopyImageToImageInfoEXT& copy_src);
+    safe_VkCopyImageToImageInfoEXT();
+    ~safe_VkCopyImageToImageInfoEXT();
+    void initialize(const VkCopyImageToImageInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCopyImageToImageInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkCopyImageToImageInfoEXT* ptr() { return reinterpret_cast<VkCopyImageToImageInfoEXT*>(this); }
+    VkCopyImageToImageInfoEXT const* ptr() const { return reinterpret_cast<VkCopyImageToImageInfoEXT const*>(this); }
+};
+struct safe_VkHostImageLayoutTransitionInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImage image;
+    VkImageLayout oldLayout;
+    VkImageLayout newLayout;
+    VkImageSubresourceRange subresourceRange;
+
+    safe_VkHostImageLayoutTransitionInfoEXT(const VkHostImageLayoutTransitionInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                            bool copy_pnext = true);
+    safe_VkHostImageLayoutTransitionInfoEXT(const safe_VkHostImageLayoutTransitionInfoEXT& copy_src);
+    safe_VkHostImageLayoutTransitionInfoEXT& operator=(const safe_VkHostImageLayoutTransitionInfoEXT& copy_src);
+    safe_VkHostImageLayoutTransitionInfoEXT();
+    ~safe_VkHostImageLayoutTransitionInfoEXT();
+    void initialize(const VkHostImageLayoutTransitionInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkHostImageLayoutTransitionInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkHostImageLayoutTransitionInfoEXT* ptr() { return reinterpret_cast<VkHostImageLayoutTransitionInfoEXT*>(this); }
+    VkHostImageLayoutTransitionInfoEXT const* ptr() const {
+        return reinterpret_cast<VkHostImageLayoutTransitionInfoEXT const*>(this);
+    }
+};
+struct safe_VkSubresourceHostMemcpySizeEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceSize size;
+
+    safe_VkSubresourceHostMemcpySizeEXT(const VkSubresourceHostMemcpySizeEXT* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkSubresourceHostMemcpySizeEXT(const safe_VkSubresourceHostMemcpySizeEXT& copy_src);
+    safe_VkSubresourceHostMemcpySizeEXT& operator=(const safe_VkSubresourceHostMemcpySizeEXT& copy_src);
+    safe_VkSubresourceHostMemcpySizeEXT();
+    ~safe_VkSubresourceHostMemcpySizeEXT();
+    void initialize(const VkSubresourceHostMemcpySizeEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSubresourceHostMemcpySizeEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSubresourceHostMemcpySizeEXT* ptr() { return reinterpret_cast<VkSubresourceHostMemcpySizeEXT*>(this); }
+    VkSubresourceHostMemcpySizeEXT const* ptr() const { return reinterpret_cast<VkSubresourceHostMemcpySizeEXT const*>(this); }
+};
+struct safe_VkHostImageCopyDevicePerformanceQueryEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 optimalDeviceAccess;
+    VkBool32 identicalMemoryLayout;
+
+    safe_VkHostImageCopyDevicePerformanceQueryEXT(const VkHostImageCopyDevicePerformanceQueryEXT* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkHostImageCopyDevicePerformanceQueryEXT(const safe_VkHostImageCopyDevicePerformanceQueryEXT& copy_src);
+    safe_VkHostImageCopyDevicePerformanceQueryEXT& operator=(const safe_VkHostImageCopyDevicePerformanceQueryEXT& copy_src);
+    safe_VkHostImageCopyDevicePerformanceQueryEXT();
+    ~safe_VkHostImageCopyDevicePerformanceQueryEXT();
+    void initialize(const VkHostImageCopyDevicePerformanceQueryEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkHostImageCopyDevicePerformanceQueryEXT* copy_src, PNextCopyState* copy_state = {});
+    VkHostImageCopyDevicePerformanceQueryEXT* ptr() { return reinterpret_cast<VkHostImageCopyDevicePerformanceQueryEXT*>(this); }
+    VkHostImageCopyDevicePerformanceQueryEXT const* ptr() const {
+        return reinterpret_cast<VkHostImageCopyDevicePerformanceQueryEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 memoryMapPlaced;
+    VkBool32 memoryMapRangePlaced;
+    VkBool32 memoryUnmapReserve;
+
+    safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT(const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT(const safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT& operator=(const safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT();
+    ~safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT();
+    void initialize(const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceMapMemoryPlacedFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceMapMemoryPlacedFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMapMemoryPlacedFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceSize minPlacedMemoryMapAlignment;
+
+    safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT(const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT(const safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT& operator=(const safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT();
+    ~safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT();
+    void initialize(const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMapMemoryPlacedPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceMapMemoryPlacedPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceMapMemoryPlacedPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMapMemoryPlacedPropertiesEXT const*>(this);
+    }
+};
+struct safe_VkMemoryMapPlacedInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    void* pPlacedAddress{};
+
+    safe_VkMemoryMapPlacedInfoEXT(const VkMemoryMapPlacedInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    safe_VkMemoryMapPlacedInfoEXT(const safe_VkMemoryMapPlacedInfoEXT& copy_src);
+    safe_VkMemoryMapPlacedInfoEXT& operator=(const safe_VkMemoryMapPlacedInfoEXT& copy_src);
+    safe_VkMemoryMapPlacedInfoEXT();
+    ~safe_VkMemoryMapPlacedInfoEXT();
+    void initialize(const VkMemoryMapPlacedInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMemoryMapPlacedInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryMapPlacedInfoEXT* ptr() { return reinterpret_cast<VkMemoryMapPlacedInfoEXT*>(this); }
+    VkMemoryMapPlacedInfoEXT const* ptr() const { return reinterpret_cast<VkMemoryMapPlacedInfoEXT const*>(this); }
+};
+struct safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderBufferFloat16Atomics;
+    VkBool32 shaderBufferFloat16AtomicAdd;
+    VkBool32 shaderBufferFloat16AtomicMinMax;
+    VkBool32 shaderBufferFloat32AtomicMinMax;
+    VkBool32 shaderBufferFloat64AtomicMinMax;
+    VkBool32 shaderSharedFloat16Atomics;
+    VkBool32 shaderSharedFloat16AtomicAdd;
+    VkBool32 shaderSharedFloat16AtomicMinMax;
+    VkBool32 shaderSharedFloat32AtomicMinMax;
+    VkBool32 shaderSharedFloat64AtomicMinMax;
+    VkBool32 shaderImageFloat32AtomicMinMax;
+    VkBool32 sparseImageFloat32AtomicMinMax;
+
+    safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(const safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT();
+    ~safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT();
+    void initialize(const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT const*>(this);
+    }
+};
+struct safe_VkSurfacePresentModeEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkPresentModeKHR presentMode;
+
+    safe_VkSurfacePresentModeEXT(const VkSurfacePresentModeEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSurfacePresentModeEXT(const safe_VkSurfacePresentModeEXT& copy_src);
+    safe_VkSurfacePresentModeEXT& operator=(const safe_VkSurfacePresentModeEXT& copy_src);
+    safe_VkSurfacePresentModeEXT();
+    ~safe_VkSurfacePresentModeEXT();
+    void initialize(const VkSurfacePresentModeEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSurfacePresentModeEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSurfacePresentModeEXT* ptr() { return reinterpret_cast<VkSurfacePresentModeEXT*>(this); }
+    VkSurfacePresentModeEXT const* ptr() const { return reinterpret_cast<VkSurfacePresentModeEXT const*>(this); }
+};
+struct safe_VkSurfacePresentScalingCapabilitiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkPresentScalingFlagsEXT supportedPresentScaling;
+    VkPresentGravityFlagsEXT supportedPresentGravityX;
+    VkPresentGravityFlagsEXT supportedPresentGravityY;
+    VkExtent2D minScaledImageExtent;
+    VkExtent2D maxScaledImageExtent;
+
+    safe_VkSurfacePresentScalingCapabilitiesEXT(const VkSurfacePresentScalingCapabilitiesEXT* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSurfacePresentScalingCapabilitiesEXT(const safe_VkSurfacePresentScalingCapabilitiesEXT& copy_src);
+    safe_VkSurfacePresentScalingCapabilitiesEXT& operator=(const safe_VkSurfacePresentScalingCapabilitiesEXT& copy_src);
+    safe_VkSurfacePresentScalingCapabilitiesEXT();
+    ~safe_VkSurfacePresentScalingCapabilitiesEXT();
+    void initialize(const VkSurfacePresentScalingCapabilitiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSurfacePresentScalingCapabilitiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSurfacePresentScalingCapabilitiesEXT* ptr() { return reinterpret_cast<VkSurfacePresentScalingCapabilitiesEXT*>(this); }
+    VkSurfacePresentScalingCapabilitiesEXT const* ptr() const {
+        return reinterpret_cast<VkSurfacePresentScalingCapabilitiesEXT const*>(this);
+    }
+};
+struct safe_VkSurfacePresentModeCompatibilityEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t presentModeCount;
+    VkPresentModeKHR* pPresentModes{};
+
+    safe_VkSurfacePresentModeCompatibilityEXT(const VkSurfacePresentModeCompatibilityEXT* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSurfacePresentModeCompatibilityEXT(const safe_VkSurfacePresentModeCompatibilityEXT& copy_src);
+    safe_VkSurfacePresentModeCompatibilityEXT& operator=(const safe_VkSurfacePresentModeCompatibilityEXT& copy_src);
+    safe_VkSurfacePresentModeCompatibilityEXT();
+    ~safe_VkSurfacePresentModeCompatibilityEXT();
+    void initialize(const VkSurfacePresentModeCompatibilityEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSurfacePresentModeCompatibilityEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSurfacePresentModeCompatibilityEXT* ptr() { return reinterpret_cast<VkSurfacePresentModeCompatibilityEXT*>(this); }
+    VkSurfacePresentModeCompatibilityEXT const* ptr() const {
+        return reinterpret_cast<VkSurfacePresentModeCompatibilityEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 swapchainMaintenance1;
+
+    safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* in_struct,
+                                                          PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(const safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT();
+    ~safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT();
+    void initialize(const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT const*>(this);
+    }
+};
+struct safe_VkSwapchainPresentFenceInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t swapchainCount;
+    VkFence* pFences{};
+
+    safe_VkSwapchainPresentFenceInfoEXT(const VkSwapchainPresentFenceInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkSwapchainPresentFenceInfoEXT(const safe_VkSwapchainPresentFenceInfoEXT& copy_src);
+    safe_VkSwapchainPresentFenceInfoEXT& operator=(const safe_VkSwapchainPresentFenceInfoEXT& copy_src);
+    safe_VkSwapchainPresentFenceInfoEXT();
+    ~safe_VkSwapchainPresentFenceInfoEXT();
+    void initialize(const VkSwapchainPresentFenceInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSwapchainPresentFenceInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSwapchainPresentFenceInfoEXT* ptr() { return reinterpret_cast<VkSwapchainPresentFenceInfoEXT*>(this); }
+    VkSwapchainPresentFenceInfoEXT const* ptr() const { return reinterpret_cast<VkSwapchainPresentFenceInfoEXT const*>(this); }
+};
+struct safe_VkSwapchainPresentModesCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t presentModeCount;
+    const VkPresentModeKHR* pPresentModes{};
+
+    safe_VkSwapchainPresentModesCreateInfoEXT(const VkSwapchainPresentModesCreateInfoEXT* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSwapchainPresentModesCreateInfoEXT(const safe_VkSwapchainPresentModesCreateInfoEXT& copy_src);
+    safe_VkSwapchainPresentModesCreateInfoEXT& operator=(const safe_VkSwapchainPresentModesCreateInfoEXT& copy_src);
+    safe_VkSwapchainPresentModesCreateInfoEXT();
+    ~safe_VkSwapchainPresentModesCreateInfoEXT();
+    void initialize(const VkSwapchainPresentModesCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSwapchainPresentModesCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSwapchainPresentModesCreateInfoEXT* ptr() { return reinterpret_cast<VkSwapchainPresentModesCreateInfoEXT*>(this); }
+    VkSwapchainPresentModesCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkSwapchainPresentModesCreateInfoEXT const*>(this);
+    }
+};
+struct safe_VkSwapchainPresentModeInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t swapchainCount;
+    const VkPresentModeKHR* pPresentModes{};
+
+    safe_VkSwapchainPresentModeInfoEXT(const VkSwapchainPresentModeInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    safe_VkSwapchainPresentModeInfoEXT(const safe_VkSwapchainPresentModeInfoEXT& copy_src);
+    safe_VkSwapchainPresentModeInfoEXT& operator=(const safe_VkSwapchainPresentModeInfoEXT& copy_src);
+    safe_VkSwapchainPresentModeInfoEXT();
+    ~safe_VkSwapchainPresentModeInfoEXT();
+    void initialize(const VkSwapchainPresentModeInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSwapchainPresentModeInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSwapchainPresentModeInfoEXT* ptr() { return reinterpret_cast<VkSwapchainPresentModeInfoEXT*>(this); }
+    VkSwapchainPresentModeInfoEXT const* ptr() const { return reinterpret_cast<VkSwapchainPresentModeInfoEXT const*>(this); }
+};
+struct safe_VkSwapchainPresentScalingCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPresentScalingFlagsEXT scalingBehavior;
+    VkPresentGravityFlagsEXT presentGravityX;
+    VkPresentGravityFlagsEXT presentGravityY;
+
+    safe_VkSwapchainPresentScalingCreateInfoEXT(const VkSwapchainPresentScalingCreateInfoEXT* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSwapchainPresentScalingCreateInfoEXT(const safe_VkSwapchainPresentScalingCreateInfoEXT& copy_src);
+    safe_VkSwapchainPresentScalingCreateInfoEXT& operator=(const safe_VkSwapchainPresentScalingCreateInfoEXT& copy_src);
+    safe_VkSwapchainPresentScalingCreateInfoEXT();
+    ~safe_VkSwapchainPresentScalingCreateInfoEXT();
+    void initialize(const VkSwapchainPresentScalingCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSwapchainPresentScalingCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSwapchainPresentScalingCreateInfoEXT* ptr() { return reinterpret_cast<VkSwapchainPresentScalingCreateInfoEXT*>(this); }
+    VkSwapchainPresentScalingCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkSwapchainPresentScalingCreateInfoEXT const*>(this);
+    }
+};
+struct safe_VkReleaseSwapchainImagesInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSwapchainKHR swapchain;
+    uint32_t imageIndexCount;
+    const uint32_t* pImageIndices{};
+
+    safe_VkReleaseSwapchainImagesInfoEXT(const VkReleaseSwapchainImagesInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkReleaseSwapchainImagesInfoEXT(const safe_VkReleaseSwapchainImagesInfoEXT& copy_src);
+    safe_VkReleaseSwapchainImagesInfoEXT& operator=(const safe_VkReleaseSwapchainImagesInfoEXT& copy_src);
+    safe_VkReleaseSwapchainImagesInfoEXT();
+    ~safe_VkReleaseSwapchainImagesInfoEXT();
+    void initialize(const VkReleaseSwapchainImagesInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkReleaseSwapchainImagesInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkReleaseSwapchainImagesInfoEXT* ptr() { return reinterpret_cast<VkReleaseSwapchainImagesInfoEXT*>(this); }
+    VkReleaseSwapchainImagesInfoEXT const* ptr() const { return reinterpret_cast<VkReleaseSwapchainImagesInfoEXT const*>(this); }
+};
+struct safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxGraphicsShaderGroupCount;
+    uint32_t maxIndirectSequenceCount;
+    uint32_t maxIndirectCommandsTokenCount;
+    uint32_t maxIndirectCommandsStreamCount;
+    uint32_t maxIndirectCommandsTokenOffset;
+    uint32_t maxIndirectCommandsStreamStride;
+    uint32_t minSequencesCountBufferOffsetAlignment;
+    uint32_t minSequencesIndexBufferOffsetAlignment;
+    uint32_t minIndirectCommandsBufferOffsetAlignment;
+
+    safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* in_struct,
+                                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
+        const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV& copy_src);
+    safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV& operator=(
+        const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV& copy_src);
+    safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV();
+    ~safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV();
+    void initialize(const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV*>(this);
+    }
+    VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 deviceGeneratedCommands;
+
+    safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* in_struct,
+                                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV& operator=(
+        const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV();
+    ~safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV();
+    void initialize(const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV const*>(this);
+    }
+};
+struct safe_VkGraphicsShaderGroupCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t stageCount;
+    safe_VkPipelineShaderStageCreateInfo* pStages{};
+    safe_VkPipelineVertexInputStateCreateInfo* pVertexInputState{};
+    safe_VkPipelineTessellationStateCreateInfo* pTessellationState{};
+
+    safe_VkGraphicsShaderGroupCreateInfoNV(const VkGraphicsShaderGroupCreateInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                           bool copy_pnext = true);
+    safe_VkGraphicsShaderGroupCreateInfoNV(const safe_VkGraphicsShaderGroupCreateInfoNV& copy_src);
+    safe_VkGraphicsShaderGroupCreateInfoNV& operator=(const safe_VkGraphicsShaderGroupCreateInfoNV& copy_src);
+    safe_VkGraphicsShaderGroupCreateInfoNV();
+    ~safe_VkGraphicsShaderGroupCreateInfoNV();
+    void initialize(const VkGraphicsShaderGroupCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkGraphicsShaderGroupCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkGraphicsShaderGroupCreateInfoNV* ptr() { return reinterpret_cast<VkGraphicsShaderGroupCreateInfoNV*>(this); }
+    VkGraphicsShaderGroupCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkGraphicsShaderGroupCreateInfoNV const*>(this);
+    }
+};
+struct safe_VkGraphicsPipelineShaderGroupsCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t groupCount;
+    safe_VkGraphicsShaderGroupCreateInfoNV* pGroups{};
+    uint32_t pipelineCount;
+    VkPipeline* pPipelines{};
+
+    safe_VkGraphicsPipelineShaderGroupsCreateInfoNV(const VkGraphicsPipelineShaderGroupsCreateInfoNV* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkGraphicsPipelineShaderGroupsCreateInfoNV(const safe_VkGraphicsPipelineShaderGroupsCreateInfoNV& copy_src);
+    safe_VkGraphicsPipelineShaderGroupsCreateInfoNV& operator=(const safe_VkGraphicsPipelineShaderGroupsCreateInfoNV& copy_src);
+    safe_VkGraphicsPipelineShaderGroupsCreateInfoNV();
+    ~safe_VkGraphicsPipelineShaderGroupsCreateInfoNV();
+    void initialize(const VkGraphicsPipelineShaderGroupsCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkGraphicsPipelineShaderGroupsCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkGraphicsPipelineShaderGroupsCreateInfoNV* ptr() {
+        return reinterpret_cast<VkGraphicsPipelineShaderGroupsCreateInfoNV*>(this);
+    }
+    VkGraphicsPipelineShaderGroupsCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkGraphicsPipelineShaderGroupsCreateInfoNV const*>(this);
+    }
+};
+struct safe_VkIndirectCommandsLayoutTokenNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkIndirectCommandsTokenTypeNV tokenType;
+    uint32_t stream;
+    uint32_t offset;
+    uint32_t vertexBindingUnit;
+    VkBool32 vertexDynamicStride;
+    VkPipelineLayout pushconstantPipelineLayout;
+    VkShaderStageFlags pushconstantShaderStageFlags;
+    uint32_t pushconstantOffset;
+    uint32_t pushconstantSize;
+    VkIndirectStateFlagsNV indirectStateFlags;
+    uint32_t indexTypeCount;
+    const VkIndexType* pIndexTypes{};
+    const uint32_t* pIndexTypeValues{};
+
+    safe_VkIndirectCommandsLayoutTokenNV(const VkIndirectCommandsLayoutTokenNV* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkIndirectCommandsLayoutTokenNV(const safe_VkIndirectCommandsLayoutTokenNV& copy_src);
+    safe_VkIndirectCommandsLayoutTokenNV& operator=(const safe_VkIndirectCommandsLayoutTokenNV& copy_src);
+    safe_VkIndirectCommandsLayoutTokenNV();
+    ~safe_VkIndirectCommandsLayoutTokenNV();
+    void initialize(const VkIndirectCommandsLayoutTokenNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkIndirectCommandsLayoutTokenNV* copy_src, PNextCopyState* copy_state = {});
+    VkIndirectCommandsLayoutTokenNV* ptr() { return reinterpret_cast<VkIndirectCommandsLayoutTokenNV*>(this); }
+    VkIndirectCommandsLayoutTokenNV const* ptr() const { return reinterpret_cast<VkIndirectCommandsLayoutTokenNV const*>(this); }
+};
+struct safe_VkIndirectCommandsLayoutCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkIndirectCommandsLayoutUsageFlagsNV flags;
+    VkPipelineBindPoint pipelineBindPoint;
+    uint32_t tokenCount;
+    safe_VkIndirectCommandsLayoutTokenNV* pTokens{};
+    uint32_t streamCount;
+    const uint32_t* pStreamStrides{};
+
+    safe_VkIndirectCommandsLayoutCreateInfoNV(const VkIndirectCommandsLayoutCreateInfoNV* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkIndirectCommandsLayoutCreateInfoNV(const safe_VkIndirectCommandsLayoutCreateInfoNV& copy_src);
+    safe_VkIndirectCommandsLayoutCreateInfoNV& operator=(const safe_VkIndirectCommandsLayoutCreateInfoNV& copy_src);
+    safe_VkIndirectCommandsLayoutCreateInfoNV();
+    ~safe_VkIndirectCommandsLayoutCreateInfoNV();
+    void initialize(const VkIndirectCommandsLayoutCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkIndirectCommandsLayoutCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkIndirectCommandsLayoutCreateInfoNV* ptr() { return reinterpret_cast<VkIndirectCommandsLayoutCreateInfoNV*>(this); }
+    VkIndirectCommandsLayoutCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkIndirectCommandsLayoutCreateInfoNV const*>(this);
+    }
+};
+struct safe_VkGeneratedCommandsInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineBindPoint pipelineBindPoint;
+    VkPipeline pipeline;
+    VkIndirectCommandsLayoutNV indirectCommandsLayout;
+    uint32_t streamCount;
+    VkIndirectCommandsStreamNV* pStreams{};
+    uint32_t sequencesCount;
+    VkBuffer preprocessBuffer;
+    VkDeviceSize preprocessOffset;
+    VkDeviceSize preprocessSize;
+    VkBuffer sequencesCountBuffer;
+    VkDeviceSize sequencesCountOffset;
+    VkBuffer sequencesIndexBuffer;
+    VkDeviceSize sequencesIndexOffset;
+
+    safe_VkGeneratedCommandsInfoNV(const VkGeneratedCommandsInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    safe_VkGeneratedCommandsInfoNV(const safe_VkGeneratedCommandsInfoNV& copy_src);
+    safe_VkGeneratedCommandsInfoNV& operator=(const safe_VkGeneratedCommandsInfoNV& copy_src);
+    safe_VkGeneratedCommandsInfoNV();
+    ~safe_VkGeneratedCommandsInfoNV();
+    void initialize(const VkGeneratedCommandsInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkGeneratedCommandsInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkGeneratedCommandsInfoNV* ptr() { return reinterpret_cast<VkGeneratedCommandsInfoNV*>(this); }
+    VkGeneratedCommandsInfoNV const* ptr() const { return reinterpret_cast<VkGeneratedCommandsInfoNV const*>(this); }
+};
+struct safe_VkGeneratedCommandsMemoryRequirementsInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineBindPoint pipelineBindPoint;
+    VkPipeline pipeline;
+    VkIndirectCommandsLayoutNV indirectCommandsLayout;
+    uint32_t maxSequencesCount;
+
+    safe_VkGeneratedCommandsMemoryRequirementsInfoNV(const VkGeneratedCommandsMemoryRequirementsInfoNV* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkGeneratedCommandsMemoryRequirementsInfoNV(const safe_VkGeneratedCommandsMemoryRequirementsInfoNV& copy_src);
+    safe_VkGeneratedCommandsMemoryRequirementsInfoNV& operator=(const safe_VkGeneratedCommandsMemoryRequirementsInfoNV& copy_src);
+    safe_VkGeneratedCommandsMemoryRequirementsInfoNV();
+    ~safe_VkGeneratedCommandsMemoryRequirementsInfoNV();
+    void initialize(const VkGeneratedCommandsMemoryRequirementsInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkGeneratedCommandsMemoryRequirementsInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkGeneratedCommandsMemoryRequirementsInfoNV* ptr() {
+        return reinterpret_cast<VkGeneratedCommandsMemoryRequirementsInfoNV*>(this);
+    }
+    VkGeneratedCommandsMemoryRequirementsInfoNV const* ptr() const {
+        return reinterpret_cast<VkGeneratedCommandsMemoryRequirementsInfoNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 inheritedViewportScissor2D;
+
+    safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* in_struct,
+                                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
+        const safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV& operator=(
+        const safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV();
+    ~safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV();
+    void initialize(const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceInheritedViewportScissorFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceInheritedViewportScissorFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceInheritedViewportScissorFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceInheritedViewportScissorFeaturesNV const*>(this);
+    }
+};
+struct safe_VkCommandBufferInheritanceViewportScissorInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 viewportScissor2D;
+    uint32_t viewportDepthCount;
+    const VkViewport* pViewportDepths{};
+
+    safe_VkCommandBufferInheritanceViewportScissorInfoNV(const VkCommandBufferInheritanceViewportScissorInfoNV* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkCommandBufferInheritanceViewportScissorInfoNV(const safe_VkCommandBufferInheritanceViewportScissorInfoNV& copy_src);
+    safe_VkCommandBufferInheritanceViewportScissorInfoNV& operator=(
+        const safe_VkCommandBufferInheritanceViewportScissorInfoNV& copy_src);
+    safe_VkCommandBufferInheritanceViewportScissorInfoNV();
+    ~safe_VkCommandBufferInheritanceViewportScissorInfoNV();
+    void initialize(const VkCommandBufferInheritanceViewportScissorInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCommandBufferInheritanceViewportScissorInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkCommandBufferInheritanceViewportScissorInfoNV* ptr() {
+        return reinterpret_cast<VkCommandBufferInheritanceViewportScissorInfoNV*>(this);
+    }
+    VkCommandBufferInheritanceViewportScissorInfoNV const* ptr() const {
+        return reinterpret_cast<VkCommandBufferInheritanceViewportScissorInfoNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 texelBufferAlignment;
+
+    safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(const safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT();
+    ~safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT();
+    void initialize(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkRenderPassTransformBeginInfoQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkSurfaceTransformFlagBitsKHR transform;
+
+    safe_VkRenderPassTransformBeginInfoQCOM(const VkRenderPassTransformBeginInfoQCOM* in_struct, PNextCopyState* copy_state = {},
+                                            bool copy_pnext = true);
+    safe_VkRenderPassTransformBeginInfoQCOM(const safe_VkRenderPassTransformBeginInfoQCOM& copy_src);
+    safe_VkRenderPassTransformBeginInfoQCOM& operator=(const safe_VkRenderPassTransformBeginInfoQCOM& copy_src);
+    safe_VkRenderPassTransformBeginInfoQCOM();
+    ~safe_VkRenderPassTransformBeginInfoQCOM();
+    void initialize(const VkRenderPassTransformBeginInfoQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderPassTransformBeginInfoQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassTransformBeginInfoQCOM* ptr() { return reinterpret_cast<VkRenderPassTransformBeginInfoQCOM*>(this); }
+    VkRenderPassTransformBeginInfoQCOM const* ptr() const {
+        return reinterpret_cast<VkRenderPassTransformBeginInfoQCOM const*>(this);
+    }
+};
+struct safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkSurfaceTransformFlagBitsKHR transform;
+    VkRect2D renderArea;
+
+    safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
+        const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
+        const safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM& copy_src);
+    safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM& operator=(
+        const safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM& copy_src);
+    safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM();
+    ~safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM();
+    void initialize(const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkCommandBufferInheritanceRenderPassTransformInfoQCOM* ptr() {
+        return reinterpret_cast<VkCommandBufferInheritanceRenderPassTransformInfoQCOM*>(this);
+    }
+    VkCommandBufferInheritanceRenderPassTransformInfoQCOM const* ptr() const {
+        return reinterpret_cast<VkCommandBufferInheritanceRenderPassTransformInfoQCOM const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 depthBiasControl;
+    VkBool32 leastRepresentableValueForceUnormRepresentation;
+    VkBool32 floatRepresentation;
+    VkBool32 depthBiasExact;
+
+    safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT(const VkPhysicalDeviceDepthBiasControlFeaturesEXT* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT(const safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT& operator=(const safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT();
+    ~safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT();
+    void initialize(const VkPhysicalDeviceDepthBiasControlFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDepthBiasControlFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDepthBiasControlFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceDepthBiasControlFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDepthBiasControlFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkDepthBiasInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    float depthBiasConstantFactor;
+    float depthBiasClamp;
+    float depthBiasSlopeFactor;
+
+    safe_VkDepthBiasInfoEXT(const VkDepthBiasInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDepthBiasInfoEXT(const safe_VkDepthBiasInfoEXT& copy_src);
+    safe_VkDepthBiasInfoEXT& operator=(const safe_VkDepthBiasInfoEXT& copy_src);
+    safe_VkDepthBiasInfoEXT();
+    ~safe_VkDepthBiasInfoEXT();
+    void initialize(const VkDepthBiasInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDepthBiasInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDepthBiasInfoEXT* ptr() { return reinterpret_cast<VkDepthBiasInfoEXT*>(this); }
+    VkDepthBiasInfoEXT const* ptr() const { return reinterpret_cast<VkDepthBiasInfoEXT const*>(this); }
+};
+struct safe_VkDepthBiasRepresentationInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDepthBiasRepresentationEXT depthBiasRepresentation;
+    VkBool32 depthBiasExact;
+
+    safe_VkDepthBiasRepresentationInfoEXT(const VkDepthBiasRepresentationInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkDepthBiasRepresentationInfoEXT(const safe_VkDepthBiasRepresentationInfoEXT& copy_src);
+    safe_VkDepthBiasRepresentationInfoEXT& operator=(const safe_VkDepthBiasRepresentationInfoEXT& copy_src);
+    safe_VkDepthBiasRepresentationInfoEXT();
+    ~safe_VkDepthBiasRepresentationInfoEXT();
+    void initialize(const VkDepthBiasRepresentationInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDepthBiasRepresentationInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDepthBiasRepresentationInfoEXT* ptr() { return reinterpret_cast<VkDepthBiasRepresentationInfoEXT*>(this); }
+    VkDepthBiasRepresentationInfoEXT const* ptr() const { return reinterpret_cast<VkDepthBiasRepresentationInfoEXT const*>(this); }
+};
+struct safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 deviceMemoryReport;
+
+    safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(const safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT();
+    ~safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT();
+    void initialize(const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceDeviceMemoryReportFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkDeviceMemoryReportCallbackDataEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceMemoryReportFlagsEXT flags;
+    VkDeviceMemoryReportEventTypeEXT type;
+    uint64_t memoryObjectId;
+    VkDeviceSize size;
+    VkObjectType objectType;
+    uint64_t objectHandle;
+    uint32_t heapIndex;
+
+    safe_VkDeviceMemoryReportCallbackDataEXT(const VkDeviceMemoryReportCallbackDataEXT* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkDeviceMemoryReportCallbackDataEXT(const safe_VkDeviceMemoryReportCallbackDataEXT& copy_src);
+    safe_VkDeviceMemoryReportCallbackDataEXT& operator=(const safe_VkDeviceMemoryReportCallbackDataEXT& copy_src);
+    safe_VkDeviceMemoryReportCallbackDataEXT();
+    ~safe_VkDeviceMemoryReportCallbackDataEXT();
+    void initialize(const VkDeviceMemoryReportCallbackDataEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDeviceMemoryReportCallbackDataEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceMemoryReportCallbackDataEXT* ptr() { return reinterpret_cast<VkDeviceMemoryReportCallbackDataEXT*>(this); }
+    VkDeviceMemoryReportCallbackDataEXT const* ptr() const {
+        return reinterpret_cast<VkDeviceMemoryReportCallbackDataEXT const*>(this);
+    }
+};
+struct safe_VkDeviceDeviceMemoryReportCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceMemoryReportFlagsEXT flags;
+    PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback;
+    void* pUserData{};
+
+    safe_VkDeviceDeviceMemoryReportCreateInfoEXT(const VkDeviceDeviceMemoryReportCreateInfoEXT* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDeviceDeviceMemoryReportCreateInfoEXT(const safe_VkDeviceDeviceMemoryReportCreateInfoEXT& copy_src);
+    safe_VkDeviceDeviceMemoryReportCreateInfoEXT& operator=(const safe_VkDeviceDeviceMemoryReportCreateInfoEXT& copy_src);
+    safe_VkDeviceDeviceMemoryReportCreateInfoEXT();
+    ~safe_VkDeviceDeviceMemoryReportCreateInfoEXT();
+    void initialize(const VkDeviceDeviceMemoryReportCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDeviceDeviceMemoryReportCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceDeviceMemoryReportCreateInfoEXT* ptr() { return reinterpret_cast<VkDeviceDeviceMemoryReportCreateInfoEXT*>(this); }
+    VkDeviceDeviceMemoryReportCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkDeviceDeviceMemoryReportCreateInfoEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceRobustness2FeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 robustBufferAccess2;
+    VkBool32 robustImageAccess2;
+    VkBool32 nullDescriptor;
+
+    safe_VkPhysicalDeviceRobustness2FeaturesEXT(const VkPhysicalDeviceRobustness2FeaturesEXT* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceRobustness2FeaturesEXT(const safe_VkPhysicalDeviceRobustness2FeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceRobustness2FeaturesEXT& operator=(const safe_VkPhysicalDeviceRobustness2FeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceRobustness2FeaturesEXT();
+    ~safe_VkPhysicalDeviceRobustness2FeaturesEXT();
+    void initialize(const VkPhysicalDeviceRobustness2FeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceRobustness2FeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRobustness2FeaturesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesEXT*>(this); }
+    VkPhysicalDeviceRobustness2FeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceRobustness2PropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceSize robustStorageBufferAccessSizeAlignment;
+    VkDeviceSize robustUniformBufferAccessSizeAlignment;
+
+    safe_VkPhysicalDeviceRobustness2PropertiesEXT(const VkPhysicalDeviceRobustness2PropertiesEXT* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceRobustness2PropertiesEXT(const safe_VkPhysicalDeviceRobustness2PropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceRobustness2PropertiesEXT& operator=(const safe_VkPhysicalDeviceRobustness2PropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceRobustness2PropertiesEXT();
+    ~safe_VkPhysicalDeviceRobustness2PropertiesEXT();
+    void initialize(const VkPhysicalDeviceRobustness2PropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceRobustness2PropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRobustness2PropertiesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesEXT*>(this); }
+    VkPhysicalDeviceRobustness2PropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesEXT const*>(this);
+    }
+};
+struct safe_VkSamplerCustomBorderColorCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkClearColorValue customBorderColor;
+    VkFormat format;
+
+    safe_VkSamplerCustomBorderColorCreateInfoEXT(const VkSamplerCustomBorderColorCreateInfoEXT* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSamplerCustomBorderColorCreateInfoEXT(const safe_VkSamplerCustomBorderColorCreateInfoEXT& copy_src);
+    safe_VkSamplerCustomBorderColorCreateInfoEXT& operator=(const safe_VkSamplerCustomBorderColorCreateInfoEXT& copy_src);
+    safe_VkSamplerCustomBorderColorCreateInfoEXT();
+    ~safe_VkSamplerCustomBorderColorCreateInfoEXT();
+    void initialize(const VkSamplerCustomBorderColorCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSamplerCustomBorderColorCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSamplerCustomBorderColorCreateInfoEXT* ptr() { return reinterpret_cast<VkSamplerCustomBorderColorCreateInfoEXT*>(this); }
+    VkSamplerCustomBorderColorCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkSamplerCustomBorderColorCreateInfoEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxCustomBorderColorSamplers;
+
+    safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT(const VkPhysicalDeviceCustomBorderColorPropertiesEXT* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT(const safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT& operator=(
+        const safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT();
+    ~safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT();
+    void initialize(const VkPhysicalDeviceCustomBorderColorPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCustomBorderColorPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceCustomBorderColorPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceCustomBorderColorPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCustomBorderColorPropertiesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 customBorderColors;
+    VkBool32 customBorderColorWithoutFormat;
+
+    safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT(const VkPhysicalDeviceCustomBorderColorFeaturesEXT* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT(const safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT& operator=(const safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT();
+    ~safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT();
+    void initialize(const VkPhysicalDeviceCustomBorderColorFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCustomBorderColorFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceCustomBorderColorFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDevicePresentBarrierFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 presentBarrier;
+
+    safe_VkPhysicalDevicePresentBarrierFeaturesNV(const VkPhysicalDevicePresentBarrierFeaturesNV* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDevicePresentBarrierFeaturesNV(const safe_VkPhysicalDevicePresentBarrierFeaturesNV& copy_src);
+    safe_VkPhysicalDevicePresentBarrierFeaturesNV& operator=(const safe_VkPhysicalDevicePresentBarrierFeaturesNV& copy_src);
+    safe_VkPhysicalDevicePresentBarrierFeaturesNV();
+    ~safe_VkPhysicalDevicePresentBarrierFeaturesNV();
+    void initialize(const VkPhysicalDevicePresentBarrierFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePresentBarrierFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePresentBarrierFeaturesNV* ptr() { return reinterpret_cast<VkPhysicalDevicePresentBarrierFeaturesNV*>(this); }
+    VkPhysicalDevicePresentBarrierFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePresentBarrierFeaturesNV const*>(this);
+    }
+};
+struct safe_VkSurfaceCapabilitiesPresentBarrierNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 presentBarrierSupported;
+
+    safe_VkSurfaceCapabilitiesPresentBarrierNV(const VkSurfaceCapabilitiesPresentBarrierNV* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSurfaceCapabilitiesPresentBarrierNV(const safe_VkSurfaceCapabilitiesPresentBarrierNV& copy_src);
+    safe_VkSurfaceCapabilitiesPresentBarrierNV& operator=(const safe_VkSurfaceCapabilitiesPresentBarrierNV& copy_src);
+    safe_VkSurfaceCapabilitiesPresentBarrierNV();
+    ~safe_VkSurfaceCapabilitiesPresentBarrierNV();
+    void initialize(const VkSurfaceCapabilitiesPresentBarrierNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSurfaceCapabilitiesPresentBarrierNV* copy_src, PNextCopyState* copy_state = {});
+    VkSurfaceCapabilitiesPresentBarrierNV* ptr() { return reinterpret_cast<VkSurfaceCapabilitiesPresentBarrierNV*>(this); }
+    VkSurfaceCapabilitiesPresentBarrierNV const* ptr() const {
+        return reinterpret_cast<VkSurfaceCapabilitiesPresentBarrierNV const*>(this);
+    }
+};
+struct safe_VkSwapchainPresentBarrierCreateInfoNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 presentBarrierEnable;
+
+    safe_VkSwapchainPresentBarrierCreateInfoNV(const VkSwapchainPresentBarrierCreateInfoNV* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSwapchainPresentBarrierCreateInfoNV(const safe_VkSwapchainPresentBarrierCreateInfoNV& copy_src);
+    safe_VkSwapchainPresentBarrierCreateInfoNV& operator=(const safe_VkSwapchainPresentBarrierCreateInfoNV& copy_src);
+    safe_VkSwapchainPresentBarrierCreateInfoNV();
+    ~safe_VkSwapchainPresentBarrierCreateInfoNV();
+    void initialize(const VkSwapchainPresentBarrierCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSwapchainPresentBarrierCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkSwapchainPresentBarrierCreateInfoNV* ptr() { return reinterpret_cast<VkSwapchainPresentBarrierCreateInfoNV*>(this); }
+    VkSwapchainPresentBarrierCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkSwapchainPresentBarrierCreateInfoNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 diagnosticsConfig;
+
+    safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(const safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV& operator=(const safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV();
+    ~safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV();
+    void initialize(const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDiagnosticsConfigFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDiagnosticsConfigFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceDiagnosticsConfigFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDiagnosticsConfigFeaturesNV const*>(this);
+    }
+};
+struct safe_VkDeviceDiagnosticsConfigCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceDiagnosticsConfigFlagsNV flags;
+
+    safe_VkDeviceDiagnosticsConfigCreateInfoNV(const VkDeviceDiagnosticsConfigCreateInfoNV* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDeviceDiagnosticsConfigCreateInfoNV(const safe_VkDeviceDiagnosticsConfigCreateInfoNV& copy_src);
+    safe_VkDeviceDiagnosticsConfigCreateInfoNV& operator=(const safe_VkDeviceDiagnosticsConfigCreateInfoNV& copy_src);
+    safe_VkDeviceDiagnosticsConfigCreateInfoNV();
+    ~safe_VkDeviceDiagnosticsConfigCreateInfoNV();
+    void initialize(const VkDeviceDiagnosticsConfigCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDeviceDiagnosticsConfigCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceDiagnosticsConfigCreateInfoNV* ptr() { return reinterpret_cast<VkDeviceDiagnosticsConfigCreateInfoNV*>(this); }
+    VkDeviceDiagnosticsConfigCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkDeviceDiagnosticsConfigCreateInfoNV const*>(this);
+    }
+};
+struct safe_VkCudaModuleCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    size_t dataSize;
+    const void* pData{};
+
+    safe_VkCudaModuleCreateInfoNV(const VkCudaModuleCreateInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    safe_VkCudaModuleCreateInfoNV(const safe_VkCudaModuleCreateInfoNV& copy_src);
+    safe_VkCudaModuleCreateInfoNV& operator=(const safe_VkCudaModuleCreateInfoNV& copy_src);
+    safe_VkCudaModuleCreateInfoNV();
+    ~safe_VkCudaModuleCreateInfoNV();
+    void initialize(const VkCudaModuleCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCudaModuleCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkCudaModuleCreateInfoNV* ptr() { return reinterpret_cast<VkCudaModuleCreateInfoNV*>(this); }
+    VkCudaModuleCreateInfoNV const* ptr() const { return reinterpret_cast<VkCudaModuleCreateInfoNV const*>(this); }
+};
+struct safe_VkCudaFunctionCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkCudaModuleNV module;
+    const char* pName{};
+
+    safe_VkCudaFunctionCreateInfoNV(const VkCudaFunctionCreateInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    safe_VkCudaFunctionCreateInfoNV(const safe_VkCudaFunctionCreateInfoNV& copy_src);
+    safe_VkCudaFunctionCreateInfoNV& operator=(const safe_VkCudaFunctionCreateInfoNV& copy_src);
+    safe_VkCudaFunctionCreateInfoNV();
+    ~safe_VkCudaFunctionCreateInfoNV();
+    void initialize(const VkCudaFunctionCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCudaFunctionCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkCudaFunctionCreateInfoNV* ptr() { return reinterpret_cast<VkCudaFunctionCreateInfoNV*>(this); }
+    VkCudaFunctionCreateInfoNV const* ptr() const { return reinterpret_cast<VkCudaFunctionCreateInfoNV const*>(this); }
+};
+struct safe_VkCudaLaunchInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkCudaFunctionNV function;
+    uint32_t gridDimX;
+    uint32_t gridDimY;
+    uint32_t gridDimZ;
+    uint32_t blockDimX;
+    uint32_t blockDimY;
+    uint32_t blockDimZ;
+    uint32_t sharedMemBytes;
+    size_t paramCount;
+    const void* const* pParams{};
+    size_t extraCount;
+    const void* const* pExtras{};
+
+    safe_VkCudaLaunchInfoNV(const VkCudaLaunchInfoNV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkCudaLaunchInfoNV(const safe_VkCudaLaunchInfoNV& copy_src);
+    safe_VkCudaLaunchInfoNV& operator=(const safe_VkCudaLaunchInfoNV& copy_src);
+    safe_VkCudaLaunchInfoNV();
+    ~safe_VkCudaLaunchInfoNV();
+    void initialize(const VkCudaLaunchInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCudaLaunchInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkCudaLaunchInfoNV* ptr() { return reinterpret_cast<VkCudaLaunchInfoNV*>(this); }
+    VkCudaLaunchInfoNV const* ptr() const { return reinterpret_cast<VkCudaLaunchInfoNV const*>(this); }
+};
+struct safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 cudaKernelLaunchFeatures;
+
+    safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV(const VkPhysicalDeviceCudaKernelLaunchFeaturesNV* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV(const safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV& operator=(const safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV();
+    ~safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV();
+    void initialize(const VkPhysicalDeviceCudaKernelLaunchFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCudaKernelLaunchFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceCudaKernelLaunchFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceCudaKernelLaunchFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCudaKernelLaunchFeaturesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t computeCapabilityMinor;
+    uint32_t computeCapabilityMajor;
+
+    safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV(const VkPhysicalDeviceCudaKernelLaunchPropertiesNV* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV(const safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV& copy_src);
+    safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV& operator=(const safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV& copy_src);
+    safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV();
+    ~safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV();
+    void initialize(const VkPhysicalDeviceCudaKernelLaunchPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCudaKernelLaunchPropertiesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceCudaKernelLaunchPropertiesNV*>(this);
+    }
+    VkPhysicalDeviceCudaKernelLaunchPropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCudaKernelLaunchPropertiesNV const*>(this);
+    }
+};
+struct safe_VkQueryLowLatencySupportNV {
+    VkStructureType sType;
+    const void* pNext{};
+    void* pQueriedLowLatencyData{};
+
+    safe_VkQueryLowLatencySupportNV(const VkQueryLowLatencySupportNV* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    safe_VkQueryLowLatencySupportNV(const safe_VkQueryLowLatencySupportNV& copy_src);
+    safe_VkQueryLowLatencySupportNV& operator=(const safe_VkQueryLowLatencySupportNV& copy_src);
+    safe_VkQueryLowLatencySupportNV();
+    ~safe_VkQueryLowLatencySupportNV();
+    void initialize(const VkQueryLowLatencySupportNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkQueryLowLatencySupportNV* copy_src, PNextCopyState* copy_state = {});
+    VkQueryLowLatencySupportNV* ptr() { return reinterpret_cast<VkQueryLowLatencySupportNV*>(this); }
+    VkQueryLowLatencySupportNV const* ptr() const { return reinterpret_cast<VkQueryLowLatencySupportNV const*>(this); }
+};
+#ifdef VK_USE_PLATFORM_METAL_EXT
+struct safe_VkExportMetalObjectCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExportMetalObjectTypeFlagBitsEXT exportObjectType;
+
+    safe_VkExportMetalObjectCreateInfoEXT(const VkExportMetalObjectCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkExportMetalObjectCreateInfoEXT(const safe_VkExportMetalObjectCreateInfoEXT& copy_src);
+    safe_VkExportMetalObjectCreateInfoEXT& operator=(const safe_VkExportMetalObjectCreateInfoEXT& copy_src);
+    safe_VkExportMetalObjectCreateInfoEXT();
+    ~safe_VkExportMetalObjectCreateInfoEXT();
+    void initialize(const VkExportMetalObjectCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExportMetalObjectCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkExportMetalObjectCreateInfoEXT* ptr() { return reinterpret_cast<VkExportMetalObjectCreateInfoEXT*>(this); }
+    VkExportMetalObjectCreateInfoEXT const* ptr() const { return reinterpret_cast<VkExportMetalObjectCreateInfoEXT const*>(this); }
+};
+struct safe_VkExportMetalObjectsInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+
+    safe_VkExportMetalObjectsInfoEXT(const VkExportMetalObjectsInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    safe_VkExportMetalObjectsInfoEXT(const safe_VkExportMetalObjectsInfoEXT& copy_src);
+    safe_VkExportMetalObjectsInfoEXT& operator=(const safe_VkExportMetalObjectsInfoEXT& copy_src);
+    safe_VkExportMetalObjectsInfoEXT();
+    ~safe_VkExportMetalObjectsInfoEXT();
+    void initialize(const VkExportMetalObjectsInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExportMetalObjectsInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkExportMetalObjectsInfoEXT* ptr() { return reinterpret_cast<VkExportMetalObjectsInfoEXT*>(this); }
+    VkExportMetalObjectsInfoEXT const* ptr() const { return reinterpret_cast<VkExportMetalObjectsInfoEXT const*>(this); }
+};
+struct safe_VkExportMetalDeviceInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    MTLDevice_id mtlDevice;
+
+    safe_VkExportMetalDeviceInfoEXT(const VkExportMetalDeviceInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    safe_VkExportMetalDeviceInfoEXT(const safe_VkExportMetalDeviceInfoEXT& copy_src);
+    safe_VkExportMetalDeviceInfoEXT& operator=(const safe_VkExportMetalDeviceInfoEXT& copy_src);
+    safe_VkExportMetalDeviceInfoEXT();
+    ~safe_VkExportMetalDeviceInfoEXT();
+    void initialize(const VkExportMetalDeviceInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExportMetalDeviceInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkExportMetalDeviceInfoEXT* ptr() { return reinterpret_cast<VkExportMetalDeviceInfoEXT*>(this); }
+    VkExportMetalDeviceInfoEXT const* ptr() const { return reinterpret_cast<VkExportMetalDeviceInfoEXT const*>(this); }
+};
+struct safe_VkExportMetalCommandQueueInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkQueue queue;
+    MTLCommandQueue_id mtlCommandQueue;
+
+    safe_VkExportMetalCommandQueueInfoEXT(const VkExportMetalCommandQueueInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkExportMetalCommandQueueInfoEXT(const safe_VkExportMetalCommandQueueInfoEXT& copy_src);
+    safe_VkExportMetalCommandQueueInfoEXT& operator=(const safe_VkExportMetalCommandQueueInfoEXT& copy_src);
+    safe_VkExportMetalCommandQueueInfoEXT();
+    ~safe_VkExportMetalCommandQueueInfoEXT();
+    void initialize(const VkExportMetalCommandQueueInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExportMetalCommandQueueInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkExportMetalCommandQueueInfoEXT* ptr() { return reinterpret_cast<VkExportMetalCommandQueueInfoEXT*>(this); }
+    VkExportMetalCommandQueueInfoEXT const* ptr() const { return reinterpret_cast<VkExportMetalCommandQueueInfoEXT const*>(this); }
+};
+struct safe_VkExportMetalBufferInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceMemory memory;
+    MTLBuffer_id mtlBuffer;
+
+    safe_VkExportMetalBufferInfoEXT(const VkExportMetalBufferInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    safe_VkExportMetalBufferInfoEXT(const safe_VkExportMetalBufferInfoEXT& copy_src);
+    safe_VkExportMetalBufferInfoEXT& operator=(const safe_VkExportMetalBufferInfoEXT& copy_src);
+    safe_VkExportMetalBufferInfoEXT();
+    ~safe_VkExportMetalBufferInfoEXT();
+    void initialize(const VkExportMetalBufferInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExportMetalBufferInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkExportMetalBufferInfoEXT* ptr() { return reinterpret_cast<VkExportMetalBufferInfoEXT*>(this); }
+    VkExportMetalBufferInfoEXT const* ptr() const { return reinterpret_cast<VkExportMetalBufferInfoEXT const*>(this); }
+};
+struct safe_VkImportMetalBufferInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    MTLBuffer_id mtlBuffer;
+
+    safe_VkImportMetalBufferInfoEXT(const VkImportMetalBufferInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    safe_VkImportMetalBufferInfoEXT(const safe_VkImportMetalBufferInfoEXT& copy_src);
+    safe_VkImportMetalBufferInfoEXT& operator=(const safe_VkImportMetalBufferInfoEXT& copy_src);
+    safe_VkImportMetalBufferInfoEXT();
+    ~safe_VkImportMetalBufferInfoEXT();
+    void initialize(const VkImportMetalBufferInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImportMetalBufferInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImportMetalBufferInfoEXT* ptr() { return reinterpret_cast<VkImportMetalBufferInfoEXT*>(this); }
+    VkImportMetalBufferInfoEXT const* ptr() const { return reinterpret_cast<VkImportMetalBufferInfoEXT const*>(this); }
+};
+struct safe_VkExportMetalTextureInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImage image;
+    VkImageView imageView;
+    VkBufferView bufferView;
+    VkImageAspectFlagBits plane;
+    MTLTexture_id mtlTexture;
+
+    safe_VkExportMetalTextureInfoEXT(const VkExportMetalTextureInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    safe_VkExportMetalTextureInfoEXT(const safe_VkExportMetalTextureInfoEXT& copy_src);
+    safe_VkExportMetalTextureInfoEXT& operator=(const safe_VkExportMetalTextureInfoEXT& copy_src);
+    safe_VkExportMetalTextureInfoEXT();
+    ~safe_VkExportMetalTextureInfoEXT();
+    void initialize(const VkExportMetalTextureInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExportMetalTextureInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkExportMetalTextureInfoEXT* ptr() { return reinterpret_cast<VkExportMetalTextureInfoEXT*>(this); }
+    VkExportMetalTextureInfoEXT const* ptr() const { return reinterpret_cast<VkExportMetalTextureInfoEXT const*>(this); }
+};
+struct safe_VkImportMetalTextureInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageAspectFlagBits plane;
+    MTLTexture_id mtlTexture;
+
+    safe_VkImportMetalTextureInfoEXT(const VkImportMetalTextureInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    safe_VkImportMetalTextureInfoEXT(const safe_VkImportMetalTextureInfoEXT& copy_src);
+    safe_VkImportMetalTextureInfoEXT& operator=(const safe_VkImportMetalTextureInfoEXT& copy_src);
+    safe_VkImportMetalTextureInfoEXT();
+    ~safe_VkImportMetalTextureInfoEXT();
+    void initialize(const VkImportMetalTextureInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImportMetalTextureInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImportMetalTextureInfoEXT* ptr() { return reinterpret_cast<VkImportMetalTextureInfoEXT*>(this); }
+    VkImportMetalTextureInfoEXT const* ptr() const { return reinterpret_cast<VkImportMetalTextureInfoEXT const*>(this); }
+};
+struct safe_VkExportMetalIOSurfaceInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImage image;
+    IOSurfaceRef ioSurface;
+
+    safe_VkExportMetalIOSurfaceInfoEXT(const VkExportMetalIOSurfaceInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    safe_VkExportMetalIOSurfaceInfoEXT(const safe_VkExportMetalIOSurfaceInfoEXT& copy_src);
+    safe_VkExportMetalIOSurfaceInfoEXT& operator=(const safe_VkExportMetalIOSurfaceInfoEXT& copy_src);
+    safe_VkExportMetalIOSurfaceInfoEXT();
+    ~safe_VkExportMetalIOSurfaceInfoEXT();
+    void initialize(const VkExportMetalIOSurfaceInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExportMetalIOSurfaceInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkExportMetalIOSurfaceInfoEXT* ptr() { return reinterpret_cast<VkExportMetalIOSurfaceInfoEXT*>(this); }
+    VkExportMetalIOSurfaceInfoEXT const* ptr() const { return reinterpret_cast<VkExportMetalIOSurfaceInfoEXT const*>(this); }
+};
+struct safe_VkImportMetalIOSurfaceInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    IOSurfaceRef ioSurface;
+
+    safe_VkImportMetalIOSurfaceInfoEXT(const VkImportMetalIOSurfaceInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    safe_VkImportMetalIOSurfaceInfoEXT(const safe_VkImportMetalIOSurfaceInfoEXT& copy_src);
+    safe_VkImportMetalIOSurfaceInfoEXT& operator=(const safe_VkImportMetalIOSurfaceInfoEXT& copy_src);
+    safe_VkImportMetalIOSurfaceInfoEXT();
+    ~safe_VkImportMetalIOSurfaceInfoEXT();
+    void initialize(const VkImportMetalIOSurfaceInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImportMetalIOSurfaceInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImportMetalIOSurfaceInfoEXT* ptr() { return reinterpret_cast<VkImportMetalIOSurfaceInfoEXT*>(this); }
+    VkImportMetalIOSurfaceInfoEXT const* ptr() const { return reinterpret_cast<VkImportMetalIOSurfaceInfoEXT const*>(this); }
+};
+struct safe_VkExportMetalSharedEventInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSemaphore semaphore;
+    VkEvent event;
+    MTLSharedEvent_id mtlSharedEvent;
+
+    safe_VkExportMetalSharedEventInfoEXT(const VkExportMetalSharedEventInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkExportMetalSharedEventInfoEXT(const safe_VkExportMetalSharedEventInfoEXT& copy_src);
+    safe_VkExportMetalSharedEventInfoEXT& operator=(const safe_VkExportMetalSharedEventInfoEXT& copy_src);
+    safe_VkExportMetalSharedEventInfoEXT();
+    ~safe_VkExportMetalSharedEventInfoEXT();
+    void initialize(const VkExportMetalSharedEventInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExportMetalSharedEventInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkExportMetalSharedEventInfoEXT* ptr() { return reinterpret_cast<VkExportMetalSharedEventInfoEXT*>(this); }
+    VkExportMetalSharedEventInfoEXT const* ptr() const { return reinterpret_cast<VkExportMetalSharedEventInfoEXT const*>(this); }
+};
+struct safe_VkImportMetalSharedEventInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    MTLSharedEvent_id mtlSharedEvent;
+
+    safe_VkImportMetalSharedEventInfoEXT(const VkImportMetalSharedEventInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkImportMetalSharedEventInfoEXT(const safe_VkImportMetalSharedEventInfoEXT& copy_src);
+    safe_VkImportMetalSharedEventInfoEXT& operator=(const safe_VkImportMetalSharedEventInfoEXT& copy_src);
+    safe_VkImportMetalSharedEventInfoEXT();
+    ~safe_VkImportMetalSharedEventInfoEXT();
+    void initialize(const VkImportMetalSharedEventInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImportMetalSharedEventInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImportMetalSharedEventInfoEXT* ptr() { return reinterpret_cast<VkImportMetalSharedEventInfoEXT*>(this); }
+    VkImportMetalSharedEventInfoEXT const* ptr() const { return reinterpret_cast<VkImportMetalSharedEventInfoEXT const*>(this); }
+};
+#endif  // VK_USE_PLATFORM_METAL_EXT
+struct safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 combinedImageSamplerDescriptorSingleArray;
+    VkBool32 bufferlessPushDescriptors;
+    VkBool32 allowSamplerImageViewPostSubmitCreation;
+    VkDeviceSize descriptorBufferOffsetAlignment;
+    uint32_t maxDescriptorBufferBindings;
+    uint32_t maxResourceDescriptorBufferBindings;
+    uint32_t maxSamplerDescriptorBufferBindings;
+    uint32_t maxEmbeddedImmutableSamplerBindings;
+    uint32_t maxEmbeddedImmutableSamplers;
+    size_t bufferCaptureReplayDescriptorDataSize;
+    size_t imageCaptureReplayDescriptorDataSize;
+    size_t imageViewCaptureReplayDescriptorDataSize;
+    size_t samplerCaptureReplayDescriptorDataSize;
+    size_t accelerationStructureCaptureReplayDescriptorDataSize;
+    size_t samplerDescriptorSize;
+    size_t combinedImageSamplerDescriptorSize;
+    size_t sampledImageDescriptorSize;
+    size_t storageImageDescriptorSize;
+    size_t uniformTexelBufferDescriptorSize;
+    size_t robustUniformTexelBufferDescriptorSize;
+    size_t storageTexelBufferDescriptorSize;
+    size_t robustStorageTexelBufferDescriptorSize;
+    size_t uniformBufferDescriptorSize;
+    size_t robustUniformBufferDescriptorSize;
+    size_t storageBufferDescriptorSize;
+    size_t robustStorageBufferDescriptorSize;
+    size_t inputAttachmentDescriptorSize;
+    size_t accelerationStructureDescriptorSize;
+    VkDeviceSize maxSamplerDescriptorBufferRange;
+    VkDeviceSize maxResourceDescriptorBufferRange;
+    VkDeviceSize samplerDescriptorBufferAddressSpaceSize;
+    VkDeviceSize resourceDescriptorBufferAddressSpaceSize;
+    VkDeviceSize descriptorBufferAddressSpaceSize;
+
+    safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT(const VkPhysicalDeviceDescriptorBufferPropertiesEXT* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT(const safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT& operator=(
+        const safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT();
+    ~safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT();
+    void initialize(const VkPhysicalDeviceDescriptorBufferPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDescriptorBufferPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorBufferPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceDescriptorBufferPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorBufferPropertiesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    size_t combinedImageSamplerDensityMapDescriptorSize;
+
+    safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+        const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+        const safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT& operator=(
+        const safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT();
+    ~safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT();
+    void initialize(const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 descriptorBuffer;
+    VkBool32 descriptorBufferCaptureReplay;
+    VkBool32 descriptorBufferImageLayoutIgnored;
+    VkBool32 descriptorBufferPushDescriptors;
+
+    safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT(const VkPhysicalDeviceDescriptorBufferFeaturesEXT* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT(const safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT& operator=(const safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT();
+    ~safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT();
+    void initialize(const VkPhysicalDeviceDescriptorBufferFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDescriptorBufferFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorBufferFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceDescriptorBufferFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorBufferFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkDescriptorAddressInfoEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceAddress address;
+    VkDeviceSize range;
+    VkFormat format;
+
+    safe_VkDescriptorAddressInfoEXT(const VkDescriptorAddressInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    safe_VkDescriptorAddressInfoEXT(const safe_VkDescriptorAddressInfoEXT& copy_src);
+    safe_VkDescriptorAddressInfoEXT& operator=(const safe_VkDescriptorAddressInfoEXT& copy_src);
+    safe_VkDescriptorAddressInfoEXT();
+    ~safe_VkDescriptorAddressInfoEXT();
+    void initialize(const VkDescriptorAddressInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDescriptorAddressInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorAddressInfoEXT* ptr() { return reinterpret_cast<VkDescriptorAddressInfoEXT*>(this); }
+    VkDescriptorAddressInfoEXT const* ptr() const { return reinterpret_cast<VkDescriptorAddressInfoEXT const*>(this); }
+};
+struct safe_VkDescriptorBufferBindingInfoEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceAddress address;
+    VkBufferUsageFlags usage;
+
+    safe_VkDescriptorBufferBindingInfoEXT(const VkDescriptorBufferBindingInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkDescriptorBufferBindingInfoEXT(const safe_VkDescriptorBufferBindingInfoEXT& copy_src);
+    safe_VkDescriptorBufferBindingInfoEXT& operator=(const safe_VkDescriptorBufferBindingInfoEXT& copy_src);
+    safe_VkDescriptorBufferBindingInfoEXT();
+    ~safe_VkDescriptorBufferBindingInfoEXT();
+    void initialize(const VkDescriptorBufferBindingInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDescriptorBufferBindingInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorBufferBindingInfoEXT* ptr() { return reinterpret_cast<VkDescriptorBufferBindingInfoEXT*>(this); }
+    VkDescriptorBufferBindingInfoEXT const* ptr() const { return reinterpret_cast<VkDescriptorBufferBindingInfoEXT const*>(this); }
+};
+struct safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBuffer buffer;
+
+    safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
+        const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
+        const safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT& copy_src);
+    safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT& operator=(
+        const safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT& copy_src);
+    safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT();
+    ~safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT();
+    void initialize(const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* ptr() {
+        return reinterpret_cast<VkDescriptorBufferBindingPushDescriptorBufferHandleEXT*>(this);
+    }
+    VkDescriptorBufferBindingPushDescriptorBufferHandleEXT const* ptr() const {
+        return reinterpret_cast<VkDescriptorBufferBindingPushDescriptorBufferHandleEXT const*>(this);
+    }
+};
+union safe_VkDescriptorDataEXT {
+    const VkSampler* pSampler{};
+    const VkDescriptorImageInfo* pCombinedImageSampler;
+    const VkDescriptorImageInfo* pInputAttachmentImage;
+    const VkDescriptorImageInfo* pSampledImage;
+    const VkDescriptorImageInfo* pStorageImage;
+    safe_VkDescriptorAddressInfoEXT* pUniformTexelBuffer;
+    safe_VkDescriptorAddressInfoEXT* pStorageTexelBuffer;
+    safe_VkDescriptorAddressInfoEXT* pUniformBuffer;
+    safe_VkDescriptorAddressInfoEXT* pStorageBuffer;
+    VkDeviceAddress accelerationStructure;
+    char type_at_end[sizeof(VkDescriptorDataEXT) + sizeof(VkDescriptorGetInfoEXT::type)];
+    safe_VkDescriptorDataEXT(const VkDescriptorDataEXT* in_struct, const VkDescriptorType type, PNextCopyState* copy_state = {});
+    safe_VkDescriptorDataEXT(const safe_VkDescriptorDataEXT& copy_src);
+    safe_VkDescriptorDataEXT& operator=(const safe_VkDescriptorDataEXT& copy_src);
+    safe_VkDescriptorDataEXT();
+    ~safe_VkDescriptorDataEXT();
+    void initialize(const VkDescriptorDataEXT* in_struct, const VkDescriptorType type, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDescriptorDataEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorDataEXT* ptr() { return reinterpret_cast<VkDescriptorDataEXT*>(this); }
+    VkDescriptorDataEXT const* ptr() const { return reinterpret_cast<VkDescriptorDataEXT const*>(this); }
+};
+struct safe_VkDescriptorGetInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDescriptorType type;
+    safe_VkDescriptorDataEXT data;
+
+    safe_VkDescriptorGetInfoEXT(const VkDescriptorGetInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDescriptorGetInfoEXT(const safe_VkDescriptorGetInfoEXT& copy_src);
+    safe_VkDescriptorGetInfoEXT& operator=(const safe_VkDescriptorGetInfoEXT& copy_src);
+    safe_VkDescriptorGetInfoEXT();
+    ~safe_VkDescriptorGetInfoEXT();
+    void initialize(const VkDescriptorGetInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDescriptorGetInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorGetInfoEXT* ptr() { return reinterpret_cast<VkDescriptorGetInfoEXT*>(this); }
+    VkDescriptorGetInfoEXT const* ptr() const { return reinterpret_cast<VkDescriptorGetInfoEXT const*>(this); }
+};
+struct safe_VkBufferCaptureDescriptorDataInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBuffer buffer;
+
+    safe_VkBufferCaptureDescriptorDataInfoEXT(const VkBufferCaptureDescriptorDataInfoEXT* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkBufferCaptureDescriptorDataInfoEXT(const safe_VkBufferCaptureDescriptorDataInfoEXT& copy_src);
+    safe_VkBufferCaptureDescriptorDataInfoEXT& operator=(const safe_VkBufferCaptureDescriptorDataInfoEXT& copy_src);
+    safe_VkBufferCaptureDescriptorDataInfoEXT();
+    ~safe_VkBufferCaptureDescriptorDataInfoEXT();
+    void initialize(const VkBufferCaptureDescriptorDataInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBufferCaptureDescriptorDataInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkBufferCaptureDescriptorDataInfoEXT* ptr() { return reinterpret_cast<VkBufferCaptureDescriptorDataInfoEXT*>(this); }
+    VkBufferCaptureDescriptorDataInfoEXT const* ptr() const {
+        return reinterpret_cast<VkBufferCaptureDescriptorDataInfoEXT const*>(this);
+    }
+};
+struct safe_VkImageCaptureDescriptorDataInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImage image;
+
+    safe_VkImageCaptureDescriptorDataInfoEXT(const VkImageCaptureDescriptorDataInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkImageCaptureDescriptorDataInfoEXT(const safe_VkImageCaptureDescriptorDataInfoEXT& copy_src);
+    safe_VkImageCaptureDescriptorDataInfoEXT& operator=(const safe_VkImageCaptureDescriptorDataInfoEXT& copy_src);
+    safe_VkImageCaptureDescriptorDataInfoEXT();
+    ~safe_VkImageCaptureDescriptorDataInfoEXT();
+    void initialize(const VkImageCaptureDescriptorDataInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageCaptureDescriptorDataInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImageCaptureDescriptorDataInfoEXT* ptr() { return reinterpret_cast<VkImageCaptureDescriptorDataInfoEXT*>(this); }
+    VkImageCaptureDescriptorDataInfoEXT const* ptr() const {
+        return reinterpret_cast<VkImageCaptureDescriptorDataInfoEXT const*>(this);
+    }
+};
+struct safe_VkImageViewCaptureDescriptorDataInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageView imageView;
+
+    safe_VkImageViewCaptureDescriptorDataInfoEXT(const VkImageViewCaptureDescriptorDataInfoEXT* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkImageViewCaptureDescriptorDataInfoEXT(const safe_VkImageViewCaptureDescriptorDataInfoEXT& copy_src);
+    safe_VkImageViewCaptureDescriptorDataInfoEXT& operator=(const safe_VkImageViewCaptureDescriptorDataInfoEXT& copy_src);
+    safe_VkImageViewCaptureDescriptorDataInfoEXT();
+    ~safe_VkImageViewCaptureDescriptorDataInfoEXT();
+    void initialize(const VkImageViewCaptureDescriptorDataInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageViewCaptureDescriptorDataInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImageViewCaptureDescriptorDataInfoEXT* ptr() { return reinterpret_cast<VkImageViewCaptureDescriptorDataInfoEXT*>(this); }
+    VkImageViewCaptureDescriptorDataInfoEXT const* ptr() const {
+        return reinterpret_cast<VkImageViewCaptureDescriptorDataInfoEXT const*>(this);
+    }
+};
+struct safe_VkSamplerCaptureDescriptorDataInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSampler sampler;
+
+    safe_VkSamplerCaptureDescriptorDataInfoEXT(const VkSamplerCaptureDescriptorDataInfoEXT* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSamplerCaptureDescriptorDataInfoEXT(const safe_VkSamplerCaptureDescriptorDataInfoEXT& copy_src);
+    safe_VkSamplerCaptureDescriptorDataInfoEXT& operator=(const safe_VkSamplerCaptureDescriptorDataInfoEXT& copy_src);
+    safe_VkSamplerCaptureDescriptorDataInfoEXT();
+    ~safe_VkSamplerCaptureDescriptorDataInfoEXT();
+    void initialize(const VkSamplerCaptureDescriptorDataInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSamplerCaptureDescriptorDataInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSamplerCaptureDescriptorDataInfoEXT* ptr() { return reinterpret_cast<VkSamplerCaptureDescriptorDataInfoEXT*>(this); }
+    VkSamplerCaptureDescriptorDataInfoEXT const* ptr() const {
+        return reinterpret_cast<VkSamplerCaptureDescriptorDataInfoEXT const*>(this);
+    }
+};
+struct safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    const void* opaqueCaptureDescriptorData{};
+
+    safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT(const VkOpaqueCaptureDescriptorDataCreateInfoEXT* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT(const safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT& copy_src);
+    safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT& operator=(const safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT& copy_src);
+    safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT();
+    ~safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT();
+    void initialize(const VkOpaqueCaptureDescriptorDataCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkOpaqueCaptureDescriptorDataCreateInfoEXT* ptr() {
+        return reinterpret_cast<VkOpaqueCaptureDescriptorDataCreateInfoEXT*>(this);
+    }
+    VkOpaqueCaptureDescriptorDataCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkOpaqueCaptureDescriptorDataCreateInfoEXT const*>(this);
+    }
+};
+struct safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAccelerationStructureKHR accelerationStructure;
+    VkAccelerationStructureNV accelerationStructureNV;
+
+    safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT(const VkAccelerationStructureCaptureDescriptorDataInfoEXT* in_struct,
+                                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT(
+        const safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT& copy_src);
+    safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT& operator=(
+        const safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT& copy_src);
+    safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT();
+    ~safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT();
+    void initialize(const VkAccelerationStructureCaptureDescriptorDataInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureCaptureDescriptorDataInfoEXT* ptr() {
+        return reinterpret_cast<VkAccelerationStructureCaptureDescriptorDataInfoEXT*>(this);
+    }
+    VkAccelerationStructureCaptureDescriptorDataInfoEXT const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureCaptureDescriptorDataInfoEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 graphicsPipelineLibrary;
+
+    safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* in_struct,
+                                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
+        const safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT();
+    ~safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT();
+    void initialize(const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 graphicsPipelineLibraryFastLinking;
+    VkBool32 graphicsPipelineLibraryIndependentInterpolationDecoration;
+
+    safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* in_struct,
+                                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
+        const safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT& operator=(
+        const safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT();
+    ~safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT();
+    void initialize(const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const*>(this);
+    }
+};
+struct safe_VkGraphicsPipelineLibraryCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkGraphicsPipelineLibraryFlagsEXT flags;
+
+    safe_VkGraphicsPipelineLibraryCreateInfoEXT(const VkGraphicsPipelineLibraryCreateInfoEXT* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkGraphicsPipelineLibraryCreateInfoEXT(const safe_VkGraphicsPipelineLibraryCreateInfoEXT& copy_src);
+    safe_VkGraphicsPipelineLibraryCreateInfoEXT& operator=(const safe_VkGraphicsPipelineLibraryCreateInfoEXT& copy_src);
+    safe_VkGraphicsPipelineLibraryCreateInfoEXT();
+    ~safe_VkGraphicsPipelineLibraryCreateInfoEXT();
+    void initialize(const VkGraphicsPipelineLibraryCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkGraphicsPipelineLibraryCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkGraphicsPipelineLibraryCreateInfoEXT* ptr() { return reinterpret_cast<VkGraphicsPipelineLibraryCreateInfoEXT*>(this); }
+    VkGraphicsPipelineLibraryCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkGraphicsPipelineLibraryCreateInfoEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderEarlyAndLateFragmentTests;
+
+    safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+        const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+        const safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD& copy_src);
+    safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD& operator=(
+        const safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD& copy_src);
+    safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD();
+    ~safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD();
+    void initialize(const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* copy_src,
+                    PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD*>(this);
+    }
+    VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 fragmentShadingRateEnums;
+    VkBool32 supersampleFragmentShadingRates;
+    VkBool32 noInvocationFragmentShadingRates;
+
+    safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* in_struct,
+                                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
+        const safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV& operator=(
+        const safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV();
+    ~safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV();
+    void initialize(const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkSampleCountFlagBits maxFragmentShadingRateInvocationCount;
+
+    safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* in_struct,
+                                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
+        const safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV& copy_src);
+    safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV& operator=(
+        const safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV& copy_src);
+    safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV();
+    ~safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV();
+    void initialize(const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV*>(this);
+    }
+    VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV const*>(this);
+    }
+};
+struct safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkFragmentShadingRateTypeNV shadingRateType;
+    VkFragmentShadingRateNV shadingRate;
+    VkFragmentShadingRateCombinerOpKHR combinerOps[2];
+
+    safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* in_struct,
+                                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
+        const safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV& copy_src);
+    safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV& operator=(
+        const safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV& copy_src);
+    safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV();
+    ~safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV();
+    void initialize(const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineFragmentShadingRateEnumStateCreateInfoNV* ptr() {
+        return reinterpret_cast<VkPipelineFragmentShadingRateEnumStateCreateInfoNV*>(this);
+    }
+    VkPipelineFragmentShadingRateEnumStateCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkPipelineFragmentShadingRateEnumStateCreateInfoNV const*>(this);
+    }
+};
+union safe_VkDeviceOrHostAddressConstKHR {
+    VkDeviceAddress deviceAddress;
+    const void* hostAddress{};
+
+    safe_VkDeviceOrHostAddressConstKHR(const VkDeviceOrHostAddressConstKHR* in_struct, PNextCopyState* copy_state = {});
+    safe_VkDeviceOrHostAddressConstKHR(const safe_VkDeviceOrHostAddressConstKHR& copy_src);
+    safe_VkDeviceOrHostAddressConstKHR& operator=(const safe_VkDeviceOrHostAddressConstKHR& copy_src);
+    safe_VkDeviceOrHostAddressConstKHR();
+    ~safe_VkDeviceOrHostAddressConstKHR();
+    void initialize(const VkDeviceOrHostAddressConstKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDeviceOrHostAddressConstKHR* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceOrHostAddressConstKHR* ptr() { return reinterpret_cast<VkDeviceOrHostAddressConstKHR*>(this); }
+    VkDeviceOrHostAddressConstKHR const* ptr() const { return reinterpret_cast<VkDeviceOrHostAddressConstKHR const*>(this); }
+};
+struct safe_VkAccelerationStructureGeometryMotionTrianglesDataNV {
+    VkStructureType sType;
+    const void* pNext{};
+    safe_VkDeviceOrHostAddressConstKHR vertexData;
+
+    safe_VkAccelerationStructureGeometryMotionTrianglesDataNV(const VkAccelerationStructureGeometryMotionTrianglesDataNV* in_struct,
+                                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkAccelerationStructureGeometryMotionTrianglesDataNV(
+        const safe_VkAccelerationStructureGeometryMotionTrianglesDataNV& copy_src);
+    safe_VkAccelerationStructureGeometryMotionTrianglesDataNV& operator=(
+        const safe_VkAccelerationStructureGeometryMotionTrianglesDataNV& copy_src);
+    safe_VkAccelerationStructureGeometryMotionTrianglesDataNV();
+    ~safe_VkAccelerationStructureGeometryMotionTrianglesDataNV();
+    void initialize(const VkAccelerationStructureGeometryMotionTrianglesDataNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAccelerationStructureGeometryMotionTrianglesDataNV* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureGeometryMotionTrianglesDataNV* ptr() {
+        return reinterpret_cast<VkAccelerationStructureGeometryMotionTrianglesDataNV*>(this);
+    }
+    VkAccelerationStructureGeometryMotionTrianglesDataNV const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureGeometryMotionTrianglesDataNV const*>(this);
+    }
+};
+struct safe_VkAccelerationStructureMotionInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t maxInstances;
+    VkAccelerationStructureMotionInfoFlagsNV flags;
+
+    safe_VkAccelerationStructureMotionInfoNV(const VkAccelerationStructureMotionInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkAccelerationStructureMotionInfoNV(const safe_VkAccelerationStructureMotionInfoNV& copy_src);
+    safe_VkAccelerationStructureMotionInfoNV& operator=(const safe_VkAccelerationStructureMotionInfoNV& copy_src);
+    safe_VkAccelerationStructureMotionInfoNV();
+    ~safe_VkAccelerationStructureMotionInfoNV();
+    void initialize(const VkAccelerationStructureMotionInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAccelerationStructureMotionInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureMotionInfoNV* ptr() { return reinterpret_cast<VkAccelerationStructureMotionInfoNV*>(this); }
+    VkAccelerationStructureMotionInfoNV const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureMotionInfoNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 rayTracingMotionBlur;
+    VkBool32 rayTracingMotionBlurPipelineTraceRaysIndirect;
+
+    safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(const safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV& operator=(
+        const safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV();
+    ~safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV();
+    void initialize(const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceRayTracingMotionBlurFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 ycbcr2plane444Formats;
+
+    safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* in_struct,
+                                                          PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(const safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT();
+    ~safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT();
+    void initialize(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 fragmentDensityMapDeferred;
+
+    safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(const safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT();
+    ~safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT();
+    void initialize(const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceFragmentDensityMap2FeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 subsampledLoads;
+    VkBool32 subsampledCoarseReconstructionEarlyAccess;
+    uint32_t maxSubsampledArrayLayers;
+    uint32_t maxDescriptorSetSubsampledSamplers;
+
+    safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* in_struct,
+                                                          PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(const safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT& operator=(
+        const safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT();
+    ~safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT();
+    void initialize(const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceFragmentDensityMap2PropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT const*>(this);
+    }
+};
+struct safe_VkCopyCommandTransformInfoQCOM {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSurfaceTransformFlagBitsKHR transform;
+
+    safe_VkCopyCommandTransformInfoQCOM(const VkCopyCommandTransformInfoQCOM* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkCopyCommandTransformInfoQCOM(const safe_VkCopyCommandTransformInfoQCOM& copy_src);
+    safe_VkCopyCommandTransformInfoQCOM& operator=(const safe_VkCopyCommandTransformInfoQCOM& copy_src);
+    safe_VkCopyCommandTransformInfoQCOM();
+    ~safe_VkCopyCommandTransformInfoQCOM();
+    void initialize(const VkCopyCommandTransformInfoQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCopyCommandTransformInfoQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkCopyCommandTransformInfoQCOM* ptr() { return reinterpret_cast<VkCopyCommandTransformInfoQCOM*>(this); }
+    VkCopyCommandTransformInfoQCOM const* ptr() const { return reinterpret_cast<VkCopyCommandTransformInfoQCOM const*>(this); }
+};
+struct safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 imageCompressionControl;
+
+    safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT(const VkPhysicalDeviceImageCompressionControlFeaturesEXT* in_struct,
+                                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
+        const safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT();
+    ~safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT();
+    void initialize(const VkPhysicalDeviceImageCompressionControlFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceImageCompressionControlFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceImageCompressionControlFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceImageCompressionControlFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceImageCompressionControlFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkImageCompressionControlEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageCompressionFlagsEXT flags;
+    uint32_t compressionControlPlaneCount;
+    VkImageCompressionFixedRateFlagsEXT* pFixedRateFlags{};
+
+    safe_VkImageCompressionControlEXT(const VkImageCompressionControlEXT* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    safe_VkImageCompressionControlEXT(const safe_VkImageCompressionControlEXT& copy_src);
+    safe_VkImageCompressionControlEXT& operator=(const safe_VkImageCompressionControlEXT& copy_src);
+    safe_VkImageCompressionControlEXT();
+    ~safe_VkImageCompressionControlEXT();
+    void initialize(const VkImageCompressionControlEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageCompressionControlEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImageCompressionControlEXT* ptr() { return reinterpret_cast<VkImageCompressionControlEXT*>(this); }
+    VkImageCompressionControlEXT const* ptr() const { return reinterpret_cast<VkImageCompressionControlEXT const*>(this); }
+};
+struct safe_VkImageCompressionPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkImageCompressionFlagsEXT imageCompressionFlags;
+    VkImageCompressionFixedRateFlagsEXT imageCompressionFixedRateFlags;
+
+    safe_VkImageCompressionPropertiesEXT(const VkImageCompressionPropertiesEXT* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkImageCompressionPropertiesEXT(const safe_VkImageCompressionPropertiesEXT& copy_src);
+    safe_VkImageCompressionPropertiesEXT& operator=(const safe_VkImageCompressionPropertiesEXT& copy_src);
+    safe_VkImageCompressionPropertiesEXT();
+    ~safe_VkImageCompressionPropertiesEXT();
+    void initialize(const VkImageCompressionPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageCompressionPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImageCompressionPropertiesEXT* ptr() { return reinterpret_cast<VkImageCompressionPropertiesEXT*>(this); }
+    VkImageCompressionPropertiesEXT const* ptr() const { return reinterpret_cast<VkImageCompressionPropertiesEXT const*>(this); }
+};
+struct safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 attachmentFeedbackLoopLayout;
+
+    safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
+        const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
+        const safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT();
+    ~safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT();
+    void initialize(const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDevice4444FormatsFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 formatA4R4G4B4;
+    VkBool32 formatA4B4G4R4;
+
+    safe_VkPhysicalDevice4444FormatsFeaturesEXT(const VkPhysicalDevice4444FormatsFeaturesEXT* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDevice4444FormatsFeaturesEXT(const safe_VkPhysicalDevice4444FormatsFeaturesEXT& copy_src);
+    safe_VkPhysicalDevice4444FormatsFeaturesEXT& operator=(const safe_VkPhysicalDevice4444FormatsFeaturesEXT& copy_src);
+    safe_VkPhysicalDevice4444FormatsFeaturesEXT();
+    ~safe_VkPhysicalDevice4444FormatsFeaturesEXT();
+    void initialize(const VkPhysicalDevice4444FormatsFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevice4444FormatsFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevice4444FormatsFeaturesEXT* ptr() { return reinterpret_cast<VkPhysicalDevice4444FormatsFeaturesEXT*>(this); }
+    VkPhysicalDevice4444FormatsFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevice4444FormatsFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceFaultFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 deviceFault;
+    VkBool32 deviceFaultVendorBinary;
+
+    safe_VkPhysicalDeviceFaultFeaturesEXT(const VkPhysicalDeviceFaultFeaturesEXT* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkPhysicalDeviceFaultFeaturesEXT(const safe_VkPhysicalDeviceFaultFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceFaultFeaturesEXT& operator=(const safe_VkPhysicalDeviceFaultFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceFaultFeaturesEXT();
+    ~safe_VkPhysicalDeviceFaultFeaturesEXT();
+    void initialize(const VkPhysicalDeviceFaultFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceFaultFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFaultFeaturesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceFaultFeaturesEXT*>(this); }
+    VkPhysicalDeviceFaultFeaturesEXT const* ptr() const { return reinterpret_cast<VkPhysicalDeviceFaultFeaturesEXT const*>(this); }
+};
+struct safe_VkDeviceFaultCountsEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t addressInfoCount;
+    uint32_t vendorInfoCount;
+    VkDeviceSize vendorBinarySize;
+
+    safe_VkDeviceFaultCountsEXT(const VkDeviceFaultCountsEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDeviceFaultCountsEXT(const safe_VkDeviceFaultCountsEXT& copy_src);
+    safe_VkDeviceFaultCountsEXT& operator=(const safe_VkDeviceFaultCountsEXT& copy_src);
+    safe_VkDeviceFaultCountsEXT();
+    ~safe_VkDeviceFaultCountsEXT();
+    void initialize(const VkDeviceFaultCountsEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDeviceFaultCountsEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceFaultCountsEXT* ptr() { return reinterpret_cast<VkDeviceFaultCountsEXT*>(this); }
+    VkDeviceFaultCountsEXT const* ptr() const { return reinterpret_cast<VkDeviceFaultCountsEXT const*>(this); }
+};
+struct safe_VkDeviceFaultInfoEXT {
+    VkStructureType sType;
+    void* pNext{};
+    char description[VK_MAX_DESCRIPTION_SIZE];
+    VkDeviceFaultAddressInfoEXT* pAddressInfos{};
+    VkDeviceFaultVendorInfoEXT* pVendorInfos{};
+    void* pVendorBinaryData{};
+
+    safe_VkDeviceFaultInfoEXT(const VkDeviceFaultInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDeviceFaultInfoEXT(const safe_VkDeviceFaultInfoEXT& copy_src);
+    safe_VkDeviceFaultInfoEXT& operator=(const safe_VkDeviceFaultInfoEXT& copy_src);
+    safe_VkDeviceFaultInfoEXT();
+    ~safe_VkDeviceFaultInfoEXT();
+    void initialize(const VkDeviceFaultInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDeviceFaultInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceFaultInfoEXT* ptr() { return reinterpret_cast<VkDeviceFaultInfoEXT*>(this); }
+    VkDeviceFaultInfoEXT const* ptr() const { return reinterpret_cast<VkDeviceFaultInfoEXT const*>(this); }
+};
+struct safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 rasterizationOrderColorAttachmentAccess;
+    VkBool32 rasterizationOrderDepthAttachmentAccess;
+    VkBool32 rasterizationOrderStencilAttachmentAccess;
+
+    safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+        const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+        const safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT();
+    ~safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT();
+    void initialize(const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* in_struct,
+                    PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* copy_src,
+                    PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 formatRgba10x6WithoutYCbCrSampler;
+
+    safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(const safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT& operator=(const safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT();
+    ~safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT();
+    void initialize(const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT const*>(this);
+    }
+};
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+struct safe_VkDirectFBSurfaceCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDirectFBSurfaceCreateFlagsEXT flags;
+    IDirectFB* dfb{};
+    IDirectFBSurface* surface{};
+
+    safe_VkDirectFBSurfaceCreateInfoEXT(const VkDirectFBSurfaceCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkDirectFBSurfaceCreateInfoEXT(const safe_VkDirectFBSurfaceCreateInfoEXT& copy_src);
+    safe_VkDirectFBSurfaceCreateInfoEXT& operator=(const safe_VkDirectFBSurfaceCreateInfoEXT& copy_src);
+    safe_VkDirectFBSurfaceCreateInfoEXT();
+    ~safe_VkDirectFBSurfaceCreateInfoEXT();
+    void initialize(const VkDirectFBSurfaceCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDirectFBSurfaceCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDirectFBSurfaceCreateInfoEXT* ptr() { return reinterpret_cast<VkDirectFBSurfaceCreateInfoEXT*>(this); }
+    VkDirectFBSurfaceCreateInfoEXT const* ptr() const { return reinterpret_cast<VkDirectFBSurfaceCreateInfoEXT const*>(this); }
+};
+#endif  // VK_USE_PLATFORM_DIRECTFB_EXT
+struct safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 mutableDescriptorType;
+
+    safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* in_struct,
+                                                          PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(const safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT();
+    ~safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT();
+    void initialize(const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkMutableDescriptorTypeListEXT {
+    uint32_t descriptorTypeCount;
+    const VkDescriptorType* pDescriptorTypes{};
+
+    safe_VkMutableDescriptorTypeListEXT(const VkMutableDescriptorTypeListEXT* in_struct, PNextCopyState* copy_state = {});
+    safe_VkMutableDescriptorTypeListEXT(const safe_VkMutableDescriptorTypeListEXT& copy_src);
+    safe_VkMutableDescriptorTypeListEXT& operator=(const safe_VkMutableDescriptorTypeListEXT& copy_src);
+    safe_VkMutableDescriptorTypeListEXT();
+    ~safe_VkMutableDescriptorTypeListEXT();
+    void initialize(const VkMutableDescriptorTypeListEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMutableDescriptorTypeListEXT* copy_src, PNextCopyState* copy_state = {});
+    VkMutableDescriptorTypeListEXT* ptr() { return reinterpret_cast<VkMutableDescriptorTypeListEXT*>(this); }
+    VkMutableDescriptorTypeListEXT const* ptr() const { return reinterpret_cast<VkMutableDescriptorTypeListEXT const*>(this); }
+};
+struct safe_VkMutableDescriptorTypeCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t mutableDescriptorTypeListCount;
+    safe_VkMutableDescriptorTypeListEXT* pMutableDescriptorTypeLists{};
+
+    safe_VkMutableDescriptorTypeCreateInfoEXT(const VkMutableDescriptorTypeCreateInfoEXT* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkMutableDescriptorTypeCreateInfoEXT(const safe_VkMutableDescriptorTypeCreateInfoEXT& copy_src);
+    safe_VkMutableDescriptorTypeCreateInfoEXT& operator=(const safe_VkMutableDescriptorTypeCreateInfoEXT& copy_src);
+    safe_VkMutableDescriptorTypeCreateInfoEXT();
+    ~safe_VkMutableDescriptorTypeCreateInfoEXT();
+    void initialize(const VkMutableDescriptorTypeCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMutableDescriptorTypeCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkMutableDescriptorTypeCreateInfoEXT* ptr() { return reinterpret_cast<VkMutableDescriptorTypeCreateInfoEXT*>(this); }
+    VkMutableDescriptorTypeCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkMutableDescriptorTypeCreateInfoEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 vertexInputDynamicState;
+
+    safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* in_struct,
+                                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
+        const safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT();
+    ~safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT();
+    void initialize(const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkVertexInputBindingDescription2EXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t binding;
+    uint32_t stride;
+    VkVertexInputRate inputRate;
+    uint32_t divisor;
+
+    safe_VkVertexInputBindingDescription2EXT(const VkVertexInputBindingDescription2EXT* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkVertexInputBindingDescription2EXT(const safe_VkVertexInputBindingDescription2EXT& copy_src);
+    safe_VkVertexInputBindingDescription2EXT& operator=(const safe_VkVertexInputBindingDescription2EXT& copy_src);
+    safe_VkVertexInputBindingDescription2EXT();
+    ~safe_VkVertexInputBindingDescription2EXT();
+    void initialize(const VkVertexInputBindingDescription2EXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVertexInputBindingDescription2EXT* copy_src, PNextCopyState* copy_state = {});
+    VkVertexInputBindingDescription2EXT* ptr() { return reinterpret_cast<VkVertexInputBindingDescription2EXT*>(this); }
+    VkVertexInputBindingDescription2EXT const* ptr() const {
+        return reinterpret_cast<VkVertexInputBindingDescription2EXT const*>(this);
+    }
+};
+struct safe_VkVertexInputAttributeDescription2EXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t location;
+    uint32_t binding;
+    VkFormat format;
+    uint32_t offset;
+
+    safe_VkVertexInputAttributeDescription2EXT(const VkVertexInputAttributeDescription2EXT* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVertexInputAttributeDescription2EXT(const safe_VkVertexInputAttributeDescription2EXT& copy_src);
+    safe_VkVertexInputAttributeDescription2EXT& operator=(const safe_VkVertexInputAttributeDescription2EXT& copy_src);
+    safe_VkVertexInputAttributeDescription2EXT();
+    ~safe_VkVertexInputAttributeDescription2EXT();
+    void initialize(const VkVertexInputAttributeDescription2EXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVertexInputAttributeDescription2EXT* copy_src, PNextCopyState* copy_state = {});
+    VkVertexInputAttributeDescription2EXT* ptr() { return reinterpret_cast<VkVertexInputAttributeDescription2EXT*>(this); }
+    VkVertexInputAttributeDescription2EXT const* ptr() const {
+        return reinterpret_cast<VkVertexInputAttributeDescription2EXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceDrmPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 hasPrimary;
+    VkBool32 hasRender;
+    int64_t primaryMajor;
+    int64_t primaryMinor;
+    int64_t renderMajor;
+    int64_t renderMinor;
+
+    safe_VkPhysicalDeviceDrmPropertiesEXT(const VkPhysicalDeviceDrmPropertiesEXT* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkPhysicalDeviceDrmPropertiesEXT(const safe_VkPhysicalDeviceDrmPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceDrmPropertiesEXT& operator=(const safe_VkPhysicalDeviceDrmPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceDrmPropertiesEXT();
+    ~safe_VkPhysicalDeviceDrmPropertiesEXT();
+    void initialize(const VkPhysicalDeviceDrmPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDrmPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDrmPropertiesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceDrmPropertiesEXT*>(this); }
+    VkPhysicalDeviceDrmPropertiesEXT const* ptr() const { return reinterpret_cast<VkPhysicalDeviceDrmPropertiesEXT const*>(this); }
+};
+struct safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 reportAddressBinding;
+
+    safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT(const VkPhysicalDeviceAddressBindingReportFeaturesEXT* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT(const safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT();
+    ~safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT();
+    void initialize(const VkPhysicalDeviceAddressBindingReportFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceAddressBindingReportFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceAddressBindingReportFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceAddressBindingReportFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceAddressBindingReportFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkDeviceAddressBindingCallbackDataEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceAddressBindingFlagsEXT flags;
+    VkDeviceAddress baseAddress;
+    VkDeviceSize size;
+    VkDeviceAddressBindingTypeEXT bindingType;
+
+    safe_VkDeviceAddressBindingCallbackDataEXT(const VkDeviceAddressBindingCallbackDataEXT* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDeviceAddressBindingCallbackDataEXT(const safe_VkDeviceAddressBindingCallbackDataEXT& copy_src);
+    safe_VkDeviceAddressBindingCallbackDataEXT& operator=(const safe_VkDeviceAddressBindingCallbackDataEXT& copy_src);
+    safe_VkDeviceAddressBindingCallbackDataEXT();
+    ~safe_VkDeviceAddressBindingCallbackDataEXT();
+    void initialize(const VkDeviceAddressBindingCallbackDataEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDeviceAddressBindingCallbackDataEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceAddressBindingCallbackDataEXT* ptr() { return reinterpret_cast<VkDeviceAddressBindingCallbackDataEXT*>(this); }
+    VkDeviceAddressBindingCallbackDataEXT const* ptr() const {
+        return reinterpret_cast<VkDeviceAddressBindingCallbackDataEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceDepthClipControlFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 depthClipControl;
+
+    safe_VkPhysicalDeviceDepthClipControlFeaturesEXT(const VkPhysicalDeviceDepthClipControlFeaturesEXT* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceDepthClipControlFeaturesEXT(const safe_VkPhysicalDeviceDepthClipControlFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceDepthClipControlFeaturesEXT& operator=(const safe_VkPhysicalDeviceDepthClipControlFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceDepthClipControlFeaturesEXT();
+    ~safe_VkPhysicalDeviceDepthClipControlFeaturesEXT();
+    void initialize(const VkPhysicalDeviceDepthClipControlFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDepthClipControlFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDepthClipControlFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDepthClipControlFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceDepthClipControlFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDepthClipControlFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPipelineViewportDepthClipControlCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 negativeOneToOne;
+
+    safe_VkPipelineViewportDepthClipControlCreateInfoEXT(const VkPipelineViewportDepthClipControlCreateInfoEXT* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineViewportDepthClipControlCreateInfoEXT(const safe_VkPipelineViewportDepthClipControlCreateInfoEXT& copy_src);
+    safe_VkPipelineViewportDepthClipControlCreateInfoEXT& operator=(
+        const safe_VkPipelineViewportDepthClipControlCreateInfoEXT& copy_src);
+    safe_VkPipelineViewportDepthClipControlCreateInfoEXT();
+    ~safe_VkPipelineViewportDepthClipControlCreateInfoEXT();
+    void initialize(const VkPipelineViewportDepthClipControlCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineViewportDepthClipControlCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineViewportDepthClipControlCreateInfoEXT* ptr() {
+        return reinterpret_cast<VkPipelineViewportDepthClipControlCreateInfoEXT*>(this);
+    }
+    VkPipelineViewportDepthClipControlCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkPipelineViewportDepthClipControlCreateInfoEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 primitiveTopologyListRestart;
+    VkBool32 primitiveTopologyPatchListRestart;
+
+    safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
+        const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
+        const safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT& copy_src);
+    safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT& operator=(
+        const safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT& copy_src);
+    safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT();
+    ~safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT();
+    void initialize(const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT*>(this);
+    }
+    VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const*>(this);
+    }
+};
+#ifdef VK_USE_PLATFORM_FUCHSIA
+struct safe_VkImportMemoryZirconHandleInfoFUCHSIA {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalMemoryHandleTypeFlagBits handleType;
+    zx_handle_t handle;
+
+    safe_VkImportMemoryZirconHandleInfoFUCHSIA(const VkImportMemoryZirconHandleInfoFUCHSIA* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkImportMemoryZirconHandleInfoFUCHSIA(const safe_VkImportMemoryZirconHandleInfoFUCHSIA& copy_src);
+    safe_VkImportMemoryZirconHandleInfoFUCHSIA& operator=(const safe_VkImportMemoryZirconHandleInfoFUCHSIA& copy_src);
+    safe_VkImportMemoryZirconHandleInfoFUCHSIA();
+    ~safe_VkImportMemoryZirconHandleInfoFUCHSIA();
+    void initialize(const VkImportMemoryZirconHandleInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImportMemoryZirconHandleInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {});
+    VkImportMemoryZirconHandleInfoFUCHSIA* ptr() { return reinterpret_cast<VkImportMemoryZirconHandleInfoFUCHSIA*>(this); }
+    VkImportMemoryZirconHandleInfoFUCHSIA const* ptr() const {
+        return reinterpret_cast<VkImportMemoryZirconHandleInfoFUCHSIA const*>(this);
+    }
+};
+struct safe_VkMemoryZirconHandlePropertiesFUCHSIA {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t memoryTypeBits;
+
+    safe_VkMemoryZirconHandlePropertiesFUCHSIA(const VkMemoryZirconHandlePropertiesFUCHSIA* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkMemoryZirconHandlePropertiesFUCHSIA(const safe_VkMemoryZirconHandlePropertiesFUCHSIA& copy_src);
+    safe_VkMemoryZirconHandlePropertiesFUCHSIA& operator=(const safe_VkMemoryZirconHandlePropertiesFUCHSIA& copy_src);
+    safe_VkMemoryZirconHandlePropertiesFUCHSIA();
+    ~safe_VkMemoryZirconHandlePropertiesFUCHSIA();
+    void initialize(const VkMemoryZirconHandlePropertiesFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMemoryZirconHandlePropertiesFUCHSIA* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryZirconHandlePropertiesFUCHSIA* ptr() { return reinterpret_cast<VkMemoryZirconHandlePropertiesFUCHSIA*>(this); }
+    VkMemoryZirconHandlePropertiesFUCHSIA const* ptr() const {
+        return reinterpret_cast<VkMemoryZirconHandlePropertiesFUCHSIA const*>(this);
+    }
+};
+struct safe_VkMemoryGetZirconHandleInfoFUCHSIA {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceMemory memory;
+    VkExternalMemoryHandleTypeFlagBits handleType;
+
+    safe_VkMemoryGetZirconHandleInfoFUCHSIA(const VkMemoryGetZirconHandleInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {},
+                                            bool copy_pnext = true);
+    safe_VkMemoryGetZirconHandleInfoFUCHSIA(const safe_VkMemoryGetZirconHandleInfoFUCHSIA& copy_src);
+    safe_VkMemoryGetZirconHandleInfoFUCHSIA& operator=(const safe_VkMemoryGetZirconHandleInfoFUCHSIA& copy_src);
+    safe_VkMemoryGetZirconHandleInfoFUCHSIA();
+    ~safe_VkMemoryGetZirconHandleInfoFUCHSIA();
+    void initialize(const VkMemoryGetZirconHandleInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMemoryGetZirconHandleInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryGetZirconHandleInfoFUCHSIA* ptr() { return reinterpret_cast<VkMemoryGetZirconHandleInfoFUCHSIA*>(this); }
+    VkMemoryGetZirconHandleInfoFUCHSIA const* ptr() const {
+        return reinterpret_cast<VkMemoryGetZirconHandleInfoFUCHSIA const*>(this);
+    }
+};
+struct safe_VkImportSemaphoreZirconHandleInfoFUCHSIA {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSemaphore semaphore;
+    VkSemaphoreImportFlags flags;
+    VkExternalSemaphoreHandleTypeFlagBits handleType;
+    zx_handle_t zirconHandle;
+
+    safe_VkImportSemaphoreZirconHandleInfoFUCHSIA(const VkImportSemaphoreZirconHandleInfoFUCHSIA* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkImportSemaphoreZirconHandleInfoFUCHSIA(const safe_VkImportSemaphoreZirconHandleInfoFUCHSIA& copy_src);
+    safe_VkImportSemaphoreZirconHandleInfoFUCHSIA& operator=(const safe_VkImportSemaphoreZirconHandleInfoFUCHSIA& copy_src);
+    safe_VkImportSemaphoreZirconHandleInfoFUCHSIA();
+    ~safe_VkImportSemaphoreZirconHandleInfoFUCHSIA();
+    void initialize(const VkImportSemaphoreZirconHandleInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImportSemaphoreZirconHandleInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {});
+    VkImportSemaphoreZirconHandleInfoFUCHSIA* ptr() { return reinterpret_cast<VkImportSemaphoreZirconHandleInfoFUCHSIA*>(this); }
+    VkImportSemaphoreZirconHandleInfoFUCHSIA const* ptr() const {
+        return reinterpret_cast<VkImportSemaphoreZirconHandleInfoFUCHSIA const*>(this);
+    }
+};
+struct safe_VkSemaphoreGetZirconHandleInfoFUCHSIA {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSemaphore semaphore;
+    VkExternalSemaphoreHandleTypeFlagBits handleType;
+
+    safe_VkSemaphoreGetZirconHandleInfoFUCHSIA(const VkSemaphoreGetZirconHandleInfoFUCHSIA* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSemaphoreGetZirconHandleInfoFUCHSIA(const safe_VkSemaphoreGetZirconHandleInfoFUCHSIA& copy_src);
+    safe_VkSemaphoreGetZirconHandleInfoFUCHSIA& operator=(const safe_VkSemaphoreGetZirconHandleInfoFUCHSIA& copy_src);
+    safe_VkSemaphoreGetZirconHandleInfoFUCHSIA();
+    ~safe_VkSemaphoreGetZirconHandleInfoFUCHSIA();
+    void initialize(const VkSemaphoreGetZirconHandleInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSemaphoreGetZirconHandleInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {});
+    VkSemaphoreGetZirconHandleInfoFUCHSIA* ptr() { return reinterpret_cast<VkSemaphoreGetZirconHandleInfoFUCHSIA*>(this); }
+    VkSemaphoreGetZirconHandleInfoFUCHSIA const* ptr() const {
+        return reinterpret_cast<VkSemaphoreGetZirconHandleInfoFUCHSIA const*>(this);
+    }
+};
+struct safe_VkBufferCollectionCreateInfoFUCHSIA {
+    VkStructureType sType;
+    const void* pNext{};
+    zx_handle_t collectionToken;
+
+    safe_VkBufferCollectionCreateInfoFUCHSIA(const VkBufferCollectionCreateInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkBufferCollectionCreateInfoFUCHSIA(const safe_VkBufferCollectionCreateInfoFUCHSIA& copy_src);
+    safe_VkBufferCollectionCreateInfoFUCHSIA& operator=(const safe_VkBufferCollectionCreateInfoFUCHSIA& copy_src);
+    safe_VkBufferCollectionCreateInfoFUCHSIA();
+    ~safe_VkBufferCollectionCreateInfoFUCHSIA();
+    void initialize(const VkBufferCollectionCreateInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBufferCollectionCreateInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {});
+    VkBufferCollectionCreateInfoFUCHSIA* ptr() { return reinterpret_cast<VkBufferCollectionCreateInfoFUCHSIA*>(this); }
+    VkBufferCollectionCreateInfoFUCHSIA const* ptr() const {
+        return reinterpret_cast<VkBufferCollectionCreateInfoFUCHSIA const*>(this);
+    }
+};
+struct safe_VkImportMemoryBufferCollectionFUCHSIA {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBufferCollectionFUCHSIA collection;
+    uint32_t index;
+
+    safe_VkImportMemoryBufferCollectionFUCHSIA(const VkImportMemoryBufferCollectionFUCHSIA* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkImportMemoryBufferCollectionFUCHSIA(const safe_VkImportMemoryBufferCollectionFUCHSIA& copy_src);
+    safe_VkImportMemoryBufferCollectionFUCHSIA& operator=(const safe_VkImportMemoryBufferCollectionFUCHSIA& copy_src);
+    safe_VkImportMemoryBufferCollectionFUCHSIA();
+    ~safe_VkImportMemoryBufferCollectionFUCHSIA();
+    void initialize(const VkImportMemoryBufferCollectionFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImportMemoryBufferCollectionFUCHSIA* copy_src, PNextCopyState* copy_state = {});
+    VkImportMemoryBufferCollectionFUCHSIA* ptr() { return reinterpret_cast<VkImportMemoryBufferCollectionFUCHSIA*>(this); }
+    VkImportMemoryBufferCollectionFUCHSIA const* ptr() const {
+        return reinterpret_cast<VkImportMemoryBufferCollectionFUCHSIA const*>(this);
+    }
+};
+struct safe_VkBufferCollectionImageCreateInfoFUCHSIA {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBufferCollectionFUCHSIA collection;
+    uint32_t index;
+
+    safe_VkBufferCollectionImageCreateInfoFUCHSIA(const VkBufferCollectionImageCreateInfoFUCHSIA* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkBufferCollectionImageCreateInfoFUCHSIA(const safe_VkBufferCollectionImageCreateInfoFUCHSIA& copy_src);
+    safe_VkBufferCollectionImageCreateInfoFUCHSIA& operator=(const safe_VkBufferCollectionImageCreateInfoFUCHSIA& copy_src);
+    safe_VkBufferCollectionImageCreateInfoFUCHSIA();
+    ~safe_VkBufferCollectionImageCreateInfoFUCHSIA();
+    void initialize(const VkBufferCollectionImageCreateInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBufferCollectionImageCreateInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {});
+    VkBufferCollectionImageCreateInfoFUCHSIA* ptr() { return reinterpret_cast<VkBufferCollectionImageCreateInfoFUCHSIA*>(this); }
+    VkBufferCollectionImageCreateInfoFUCHSIA const* ptr() const {
+        return reinterpret_cast<VkBufferCollectionImageCreateInfoFUCHSIA const*>(this);
+    }
+};
+struct safe_VkBufferCollectionConstraintsInfoFUCHSIA {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t minBufferCount;
+    uint32_t maxBufferCount;
+    uint32_t minBufferCountForCamping;
+    uint32_t minBufferCountForDedicatedSlack;
+    uint32_t minBufferCountForSharedSlack;
+
+    safe_VkBufferCollectionConstraintsInfoFUCHSIA(const VkBufferCollectionConstraintsInfoFUCHSIA* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkBufferCollectionConstraintsInfoFUCHSIA(const safe_VkBufferCollectionConstraintsInfoFUCHSIA& copy_src);
+    safe_VkBufferCollectionConstraintsInfoFUCHSIA& operator=(const safe_VkBufferCollectionConstraintsInfoFUCHSIA& copy_src);
+    safe_VkBufferCollectionConstraintsInfoFUCHSIA();
+    ~safe_VkBufferCollectionConstraintsInfoFUCHSIA();
+    void initialize(const VkBufferCollectionConstraintsInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBufferCollectionConstraintsInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {});
+    VkBufferCollectionConstraintsInfoFUCHSIA* ptr() { return reinterpret_cast<VkBufferCollectionConstraintsInfoFUCHSIA*>(this); }
+    VkBufferCollectionConstraintsInfoFUCHSIA const* ptr() const {
+        return reinterpret_cast<VkBufferCollectionConstraintsInfoFUCHSIA const*>(this);
+    }
+};
+struct safe_VkBufferConstraintsInfoFUCHSIA {
+    VkStructureType sType;
+    const void* pNext{};
+    safe_VkBufferCreateInfo createInfo;
+    VkFormatFeatureFlags requiredFormatFeatures;
+    safe_VkBufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints;
+
+    safe_VkBufferConstraintsInfoFUCHSIA(const VkBufferConstraintsInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkBufferConstraintsInfoFUCHSIA(const safe_VkBufferConstraintsInfoFUCHSIA& copy_src);
+    safe_VkBufferConstraintsInfoFUCHSIA& operator=(const safe_VkBufferConstraintsInfoFUCHSIA& copy_src);
+    safe_VkBufferConstraintsInfoFUCHSIA();
+    ~safe_VkBufferConstraintsInfoFUCHSIA();
+    void initialize(const VkBufferConstraintsInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBufferConstraintsInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {});
+    VkBufferConstraintsInfoFUCHSIA* ptr() { return reinterpret_cast<VkBufferConstraintsInfoFUCHSIA*>(this); }
+    VkBufferConstraintsInfoFUCHSIA const* ptr() const { return reinterpret_cast<VkBufferConstraintsInfoFUCHSIA const*>(this); }
+};
+struct safe_VkBufferCollectionBufferCreateInfoFUCHSIA {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBufferCollectionFUCHSIA collection;
+    uint32_t index;
+
+    safe_VkBufferCollectionBufferCreateInfoFUCHSIA(const VkBufferCollectionBufferCreateInfoFUCHSIA* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkBufferCollectionBufferCreateInfoFUCHSIA(const safe_VkBufferCollectionBufferCreateInfoFUCHSIA& copy_src);
+    safe_VkBufferCollectionBufferCreateInfoFUCHSIA& operator=(const safe_VkBufferCollectionBufferCreateInfoFUCHSIA& copy_src);
+    safe_VkBufferCollectionBufferCreateInfoFUCHSIA();
+    ~safe_VkBufferCollectionBufferCreateInfoFUCHSIA();
+    void initialize(const VkBufferCollectionBufferCreateInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBufferCollectionBufferCreateInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {});
+    VkBufferCollectionBufferCreateInfoFUCHSIA* ptr() { return reinterpret_cast<VkBufferCollectionBufferCreateInfoFUCHSIA*>(this); }
+    VkBufferCollectionBufferCreateInfoFUCHSIA const* ptr() const {
+        return reinterpret_cast<VkBufferCollectionBufferCreateInfoFUCHSIA const*>(this);
+    }
+};
+struct safe_VkSysmemColorSpaceFUCHSIA {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t colorSpace;
+
+    safe_VkSysmemColorSpaceFUCHSIA(const VkSysmemColorSpaceFUCHSIA* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    safe_VkSysmemColorSpaceFUCHSIA(const safe_VkSysmemColorSpaceFUCHSIA& copy_src);
+    safe_VkSysmemColorSpaceFUCHSIA& operator=(const safe_VkSysmemColorSpaceFUCHSIA& copy_src);
+    safe_VkSysmemColorSpaceFUCHSIA();
+    ~safe_VkSysmemColorSpaceFUCHSIA();
+    void initialize(const VkSysmemColorSpaceFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSysmemColorSpaceFUCHSIA* copy_src, PNextCopyState* copy_state = {});
+    VkSysmemColorSpaceFUCHSIA* ptr() { return reinterpret_cast<VkSysmemColorSpaceFUCHSIA*>(this); }
+    VkSysmemColorSpaceFUCHSIA const* ptr() const { return reinterpret_cast<VkSysmemColorSpaceFUCHSIA const*>(this); }
+};
+struct safe_VkBufferCollectionPropertiesFUCHSIA {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t memoryTypeBits;
+    uint32_t bufferCount;
+    uint32_t createInfoIndex;
+    uint64_t sysmemPixelFormat;
+    VkFormatFeatureFlags formatFeatures;
+    safe_VkSysmemColorSpaceFUCHSIA sysmemColorSpaceIndex;
+    VkComponentMapping samplerYcbcrConversionComponents;
+    VkSamplerYcbcrModelConversion suggestedYcbcrModel;
+    VkSamplerYcbcrRange suggestedYcbcrRange;
+    VkChromaLocation suggestedXChromaOffset;
+    VkChromaLocation suggestedYChromaOffset;
+
+    safe_VkBufferCollectionPropertiesFUCHSIA(const VkBufferCollectionPropertiesFUCHSIA* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkBufferCollectionPropertiesFUCHSIA(const safe_VkBufferCollectionPropertiesFUCHSIA& copy_src);
+    safe_VkBufferCollectionPropertiesFUCHSIA& operator=(const safe_VkBufferCollectionPropertiesFUCHSIA& copy_src);
+    safe_VkBufferCollectionPropertiesFUCHSIA();
+    ~safe_VkBufferCollectionPropertiesFUCHSIA();
+    void initialize(const VkBufferCollectionPropertiesFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBufferCollectionPropertiesFUCHSIA* copy_src, PNextCopyState* copy_state = {});
+    VkBufferCollectionPropertiesFUCHSIA* ptr() { return reinterpret_cast<VkBufferCollectionPropertiesFUCHSIA*>(this); }
+    VkBufferCollectionPropertiesFUCHSIA const* ptr() const {
+        return reinterpret_cast<VkBufferCollectionPropertiesFUCHSIA const*>(this);
+    }
+};
+struct safe_VkImageFormatConstraintsInfoFUCHSIA {
+    VkStructureType sType;
+    const void* pNext{};
+    safe_VkImageCreateInfo imageCreateInfo;
+    VkFormatFeatureFlags requiredFormatFeatures;
+    VkImageFormatConstraintsFlagsFUCHSIA flags;
+    uint64_t sysmemPixelFormat;
+    uint32_t colorSpaceCount;
+    safe_VkSysmemColorSpaceFUCHSIA* pColorSpaces{};
+
+    safe_VkImageFormatConstraintsInfoFUCHSIA(const VkImageFormatConstraintsInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkImageFormatConstraintsInfoFUCHSIA(const safe_VkImageFormatConstraintsInfoFUCHSIA& copy_src);
+    safe_VkImageFormatConstraintsInfoFUCHSIA& operator=(const safe_VkImageFormatConstraintsInfoFUCHSIA& copy_src);
+    safe_VkImageFormatConstraintsInfoFUCHSIA();
+    ~safe_VkImageFormatConstraintsInfoFUCHSIA();
+    void initialize(const VkImageFormatConstraintsInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageFormatConstraintsInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {});
+    VkImageFormatConstraintsInfoFUCHSIA* ptr() { return reinterpret_cast<VkImageFormatConstraintsInfoFUCHSIA*>(this); }
+    VkImageFormatConstraintsInfoFUCHSIA const* ptr() const {
+        return reinterpret_cast<VkImageFormatConstraintsInfoFUCHSIA const*>(this);
+    }
+};
+struct safe_VkImageConstraintsInfoFUCHSIA {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t formatConstraintsCount;
+    safe_VkImageFormatConstraintsInfoFUCHSIA* pFormatConstraints{};
+    safe_VkBufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints;
+    VkImageConstraintsInfoFlagsFUCHSIA flags;
+
+    safe_VkImageConstraintsInfoFUCHSIA(const VkImageConstraintsInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    safe_VkImageConstraintsInfoFUCHSIA(const safe_VkImageConstraintsInfoFUCHSIA& copy_src);
+    safe_VkImageConstraintsInfoFUCHSIA& operator=(const safe_VkImageConstraintsInfoFUCHSIA& copy_src);
+    safe_VkImageConstraintsInfoFUCHSIA();
+    ~safe_VkImageConstraintsInfoFUCHSIA();
+    void initialize(const VkImageConstraintsInfoFUCHSIA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageConstraintsInfoFUCHSIA* copy_src, PNextCopyState* copy_state = {});
+    VkImageConstraintsInfoFUCHSIA* ptr() { return reinterpret_cast<VkImageConstraintsInfoFUCHSIA*>(this); }
+    VkImageConstraintsInfoFUCHSIA const* ptr() const { return reinterpret_cast<VkImageConstraintsInfoFUCHSIA const*>(this); }
+};
+#endif  // VK_USE_PLATFORM_FUCHSIA
+struct safe_VkSubpassShadingPipelineCreateInfoHUAWEI {
+    VkStructureType sType;
+    void* pNext{};
+    VkRenderPass renderPass;
+    uint32_t subpass;
+
+    safe_VkSubpassShadingPipelineCreateInfoHUAWEI(const VkSubpassShadingPipelineCreateInfoHUAWEI* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSubpassShadingPipelineCreateInfoHUAWEI(const safe_VkSubpassShadingPipelineCreateInfoHUAWEI& copy_src);
+    safe_VkSubpassShadingPipelineCreateInfoHUAWEI& operator=(const safe_VkSubpassShadingPipelineCreateInfoHUAWEI& copy_src);
+    safe_VkSubpassShadingPipelineCreateInfoHUAWEI();
+    ~safe_VkSubpassShadingPipelineCreateInfoHUAWEI();
+    void initialize(const VkSubpassShadingPipelineCreateInfoHUAWEI* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSubpassShadingPipelineCreateInfoHUAWEI* copy_src, PNextCopyState* copy_state = {});
+    VkSubpassShadingPipelineCreateInfoHUAWEI* ptr() { return reinterpret_cast<VkSubpassShadingPipelineCreateInfoHUAWEI*>(this); }
+    VkSubpassShadingPipelineCreateInfoHUAWEI const* ptr() const {
+        return reinterpret_cast<VkSubpassShadingPipelineCreateInfoHUAWEI const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 subpassShading;
+
+    safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(const safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI& copy_src);
+    safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI& operator=(const safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI& copy_src);
+    safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI();
+    ~safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI();
+    void initialize(const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceSubpassShadingFeaturesHUAWEI*>(this);
+    }
+    VkPhysicalDeviceSubpassShadingFeaturesHUAWEI const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceSubpassShadingFeaturesHUAWEI const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxSubpassShadingWorkgroupSizeAspectRatio;
+
+    safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(const safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI& copy_src);
+    safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI& operator=(
+        const safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI& copy_src);
+    safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI();
+    ~safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI();
+    void initialize(const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceSubpassShadingPropertiesHUAWEI*>(this);
+    }
+    VkPhysicalDeviceSubpassShadingPropertiesHUAWEI const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceSubpassShadingPropertiesHUAWEI const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 invocationMask;
+
+    safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(const safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI& copy_src);
+    safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI& operator=(const safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI& copy_src);
+    safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI();
+    ~safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI();
+    void initialize(const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceInvocationMaskFeaturesHUAWEI*>(this);
+    }
+    VkPhysicalDeviceInvocationMaskFeaturesHUAWEI const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceInvocationMaskFeaturesHUAWEI const*>(this);
+    }
+};
+struct safe_VkMemoryGetRemoteAddressInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceMemory memory;
+    VkExternalMemoryHandleTypeFlagBits handleType;
+
+    safe_VkMemoryGetRemoteAddressInfoNV(const VkMemoryGetRemoteAddressInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkMemoryGetRemoteAddressInfoNV(const safe_VkMemoryGetRemoteAddressInfoNV& copy_src);
+    safe_VkMemoryGetRemoteAddressInfoNV& operator=(const safe_VkMemoryGetRemoteAddressInfoNV& copy_src);
+    safe_VkMemoryGetRemoteAddressInfoNV();
+    ~safe_VkMemoryGetRemoteAddressInfoNV();
+    void initialize(const VkMemoryGetRemoteAddressInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMemoryGetRemoteAddressInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryGetRemoteAddressInfoNV* ptr() { return reinterpret_cast<VkMemoryGetRemoteAddressInfoNV*>(this); }
+    VkMemoryGetRemoteAddressInfoNV const* ptr() const { return reinterpret_cast<VkMemoryGetRemoteAddressInfoNV const*>(this); }
+};
+struct safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 externalMemoryRDMA;
+
+    safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(const safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV& operator=(const safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV();
+    ~safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV();
+    void initialize(const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceExternalMemoryRDMAFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceExternalMemoryRDMAFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExternalMemoryRDMAFeaturesNV const*>(this);
+    }
+};
+struct safe_VkPipelinePropertiesIdentifierEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint8_t pipelineIdentifier[VK_UUID_SIZE];
+
+    safe_VkPipelinePropertiesIdentifierEXT(const VkPipelinePropertiesIdentifierEXT* in_struct, PNextCopyState* copy_state = {},
+                                           bool copy_pnext = true);
+    safe_VkPipelinePropertiesIdentifierEXT(const safe_VkPipelinePropertiesIdentifierEXT& copy_src);
+    safe_VkPipelinePropertiesIdentifierEXT& operator=(const safe_VkPipelinePropertiesIdentifierEXT& copy_src);
+    safe_VkPipelinePropertiesIdentifierEXT();
+    ~safe_VkPipelinePropertiesIdentifierEXT();
+    void initialize(const VkPipelinePropertiesIdentifierEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelinePropertiesIdentifierEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPipelinePropertiesIdentifierEXT* ptr() { return reinterpret_cast<VkPipelinePropertiesIdentifierEXT*>(this); }
+    VkPipelinePropertiesIdentifierEXT const* ptr() const {
+        return reinterpret_cast<VkPipelinePropertiesIdentifierEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 pipelinePropertiesIdentifier;
+
+    safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT(const VkPhysicalDevicePipelinePropertiesFeaturesEXT* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT(const safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT& copy_src);
+    safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT& operator=(
+        const safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT& copy_src);
+    safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT();
+    ~safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT();
+    void initialize(const VkPhysicalDevicePipelinePropertiesFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePipelinePropertiesFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePipelinePropertiesFeaturesEXT*>(this);
+    }
+    VkPhysicalDevicePipelinePropertiesFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePipelinePropertiesFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 frameBoundary;
+
+    safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT(const VkPhysicalDeviceFrameBoundaryFeaturesEXT* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT(const safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT& operator=(const safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT();
+    ~safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT();
+    void initialize(const VkPhysicalDeviceFrameBoundaryFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFrameBoundaryFeaturesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceFrameBoundaryFeaturesEXT*>(this); }
+    VkPhysicalDeviceFrameBoundaryFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFrameBoundaryFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkFrameBoundaryEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkFrameBoundaryFlagsEXT flags;
+    uint64_t frameID;
+    uint32_t imageCount;
+    VkImage* pImages{};
+    uint32_t bufferCount;
+    VkBuffer* pBuffers{};
+    uint64_t tagName;
+    size_t tagSize;
+    const void* pTag{};
+
+    safe_VkFrameBoundaryEXT(const VkFrameBoundaryEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkFrameBoundaryEXT(const safe_VkFrameBoundaryEXT& copy_src);
+    safe_VkFrameBoundaryEXT& operator=(const safe_VkFrameBoundaryEXT& copy_src);
+    safe_VkFrameBoundaryEXT();
+    ~safe_VkFrameBoundaryEXT();
+    void initialize(const VkFrameBoundaryEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkFrameBoundaryEXT* copy_src, PNextCopyState* copy_state = {});
+    VkFrameBoundaryEXT* ptr() { return reinterpret_cast<VkFrameBoundaryEXT*>(this); }
+    VkFrameBoundaryEXT const* ptr() const { return reinterpret_cast<VkFrameBoundaryEXT const*>(this); }
+};
+struct safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 multisampledRenderToSingleSampled;
+
+    safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+        const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+        const safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT();
+    ~safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT();
+    void initialize(const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* copy_src,
+                    PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkSubpassResolvePerformanceQueryEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 optimal;
+
+    safe_VkSubpassResolvePerformanceQueryEXT(const VkSubpassResolvePerformanceQueryEXT* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkSubpassResolvePerformanceQueryEXT(const safe_VkSubpassResolvePerformanceQueryEXT& copy_src);
+    safe_VkSubpassResolvePerformanceQueryEXT& operator=(const safe_VkSubpassResolvePerformanceQueryEXT& copy_src);
+    safe_VkSubpassResolvePerformanceQueryEXT();
+    ~safe_VkSubpassResolvePerformanceQueryEXT();
+    void initialize(const VkSubpassResolvePerformanceQueryEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSubpassResolvePerformanceQueryEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSubpassResolvePerformanceQueryEXT* ptr() { return reinterpret_cast<VkSubpassResolvePerformanceQueryEXT*>(this); }
+    VkSubpassResolvePerformanceQueryEXT const* ptr() const {
+        return reinterpret_cast<VkSubpassResolvePerformanceQueryEXT const*>(this);
+    }
+};
+struct safe_VkMultisampledRenderToSingleSampledInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 multisampledRenderToSingleSampledEnable;
+    VkSampleCountFlagBits rasterizationSamples;
+
+    safe_VkMultisampledRenderToSingleSampledInfoEXT(const VkMultisampledRenderToSingleSampledInfoEXT* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkMultisampledRenderToSingleSampledInfoEXT(const safe_VkMultisampledRenderToSingleSampledInfoEXT& copy_src);
+    safe_VkMultisampledRenderToSingleSampledInfoEXT& operator=(const safe_VkMultisampledRenderToSingleSampledInfoEXT& copy_src);
+    safe_VkMultisampledRenderToSingleSampledInfoEXT();
+    ~safe_VkMultisampledRenderToSingleSampledInfoEXT();
+    void initialize(const VkMultisampledRenderToSingleSampledInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMultisampledRenderToSingleSampledInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkMultisampledRenderToSingleSampledInfoEXT* ptr() {
+        return reinterpret_cast<VkMultisampledRenderToSingleSampledInfoEXT*>(this);
+    }
+    VkMultisampledRenderToSingleSampledInfoEXT const* ptr() const {
+        return reinterpret_cast<VkMultisampledRenderToSingleSampledInfoEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 extendedDynamicState2;
+    VkBool32 extendedDynamicState2LogicOp;
+    VkBool32 extendedDynamicState2PatchControlPoints;
+
+    safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* in_struct,
+                                                          PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(const safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT();
+    ~safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT();
+    void initialize(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceExtendedDynamicState2FeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT const*>(this);
+    }
+};
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+struct safe_VkScreenSurfaceCreateInfoQNX {
+    VkStructureType sType;
+    const void* pNext{};
+    VkScreenSurfaceCreateFlagsQNX flags;
+    struct _screen_context* context{};
+    struct _screen_window* window{};
+
+    safe_VkScreenSurfaceCreateInfoQNX(const VkScreenSurfaceCreateInfoQNX* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    safe_VkScreenSurfaceCreateInfoQNX(const safe_VkScreenSurfaceCreateInfoQNX& copy_src);
+    safe_VkScreenSurfaceCreateInfoQNX& operator=(const safe_VkScreenSurfaceCreateInfoQNX& copy_src);
+    safe_VkScreenSurfaceCreateInfoQNX();
+    ~safe_VkScreenSurfaceCreateInfoQNX();
+    void initialize(const VkScreenSurfaceCreateInfoQNX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkScreenSurfaceCreateInfoQNX* copy_src, PNextCopyState* copy_state = {});
+    VkScreenSurfaceCreateInfoQNX* ptr() { return reinterpret_cast<VkScreenSurfaceCreateInfoQNX*>(this); }
+    VkScreenSurfaceCreateInfoQNX const* ptr() const { return reinterpret_cast<VkScreenSurfaceCreateInfoQNX const*>(this); }
+};
+#endif  // VK_USE_PLATFORM_SCREEN_QNX
+struct safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 colorWriteEnable;
+
+    safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT(const VkPhysicalDeviceColorWriteEnableFeaturesEXT* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT(const safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT& operator=(const safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT();
+    ~safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT();
+    void initialize(const VkPhysicalDeviceColorWriteEnableFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceColorWriteEnableFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceColorWriteEnableFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceColorWriteEnableFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceColorWriteEnableFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPipelineColorWriteCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t attachmentCount;
+    const VkBool32* pColorWriteEnables{};
+
+    safe_VkPipelineColorWriteCreateInfoEXT(const VkPipelineColorWriteCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                           bool copy_pnext = true);
+    safe_VkPipelineColorWriteCreateInfoEXT(const safe_VkPipelineColorWriteCreateInfoEXT& copy_src);
+    safe_VkPipelineColorWriteCreateInfoEXT& operator=(const safe_VkPipelineColorWriteCreateInfoEXT& copy_src);
+    safe_VkPipelineColorWriteCreateInfoEXT();
+    ~safe_VkPipelineColorWriteCreateInfoEXT();
+    void initialize(const VkPipelineColorWriteCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineColorWriteCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineColorWriteCreateInfoEXT* ptr() { return reinterpret_cast<VkPipelineColorWriteCreateInfoEXT*>(this); }
+    VkPipelineColorWriteCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkPipelineColorWriteCreateInfoEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 primitivesGeneratedQuery;
+    VkBool32 primitivesGeneratedQueryWithRasterizerDiscard;
+    VkBool32 primitivesGeneratedQueryWithNonZeroStreams;
+
+    safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* in_struct,
+                                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
+        const safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT& copy_src);
+    safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT& operator=(
+        const safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT& copy_src);
+    safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT();
+    ~safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT();
+    void initialize(const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*>(this);
+    }
+    VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 minLod;
+
+    safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT(const VkPhysicalDeviceImageViewMinLodFeaturesEXT* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT(const safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT& operator=(const safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT();
+    ~safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT();
+    void initialize(const VkPhysicalDeviceImageViewMinLodFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceImageViewMinLodFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceImageViewMinLodFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceImageViewMinLodFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceImageViewMinLodFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkImageViewMinLodCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    float minLod;
+
+    safe_VkImageViewMinLodCreateInfoEXT(const VkImageViewMinLodCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkImageViewMinLodCreateInfoEXT(const safe_VkImageViewMinLodCreateInfoEXT& copy_src);
+    safe_VkImageViewMinLodCreateInfoEXT& operator=(const safe_VkImageViewMinLodCreateInfoEXT& copy_src);
+    safe_VkImageViewMinLodCreateInfoEXT();
+    ~safe_VkImageViewMinLodCreateInfoEXT();
+    void initialize(const VkImageViewMinLodCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageViewMinLodCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImageViewMinLodCreateInfoEXT* ptr() { return reinterpret_cast<VkImageViewMinLodCreateInfoEXT*>(this); }
+    VkImageViewMinLodCreateInfoEXT const* ptr() const { return reinterpret_cast<VkImageViewMinLodCreateInfoEXT const*>(this); }
+};
+struct safe_VkPhysicalDeviceMultiDrawFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 multiDraw;
+
+    safe_VkPhysicalDeviceMultiDrawFeaturesEXT(const VkPhysicalDeviceMultiDrawFeaturesEXT* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceMultiDrawFeaturesEXT(const safe_VkPhysicalDeviceMultiDrawFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceMultiDrawFeaturesEXT& operator=(const safe_VkPhysicalDeviceMultiDrawFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceMultiDrawFeaturesEXT();
+    ~safe_VkPhysicalDeviceMultiDrawFeaturesEXT();
+    void initialize(const VkPhysicalDeviceMultiDrawFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMultiDrawFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMultiDrawFeaturesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceMultiDrawFeaturesEXT*>(this); }
+    VkPhysicalDeviceMultiDrawFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMultiDrawFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceMultiDrawPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxMultiDrawCount;
+
+    safe_VkPhysicalDeviceMultiDrawPropertiesEXT(const VkPhysicalDeviceMultiDrawPropertiesEXT* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceMultiDrawPropertiesEXT(const safe_VkPhysicalDeviceMultiDrawPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceMultiDrawPropertiesEXT& operator=(const safe_VkPhysicalDeviceMultiDrawPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceMultiDrawPropertiesEXT();
+    ~safe_VkPhysicalDeviceMultiDrawPropertiesEXT();
+    void initialize(const VkPhysicalDeviceMultiDrawPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMultiDrawPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMultiDrawPropertiesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceMultiDrawPropertiesEXT*>(this); }
+    VkPhysicalDeviceMultiDrawPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMultiDrawPropertiesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 image2DViewOf3D;
+    VkBool32 sampler2DViewOf3D;
+
+    safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(const safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT& operator=(const safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT();
+    ~safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT();
+    void initialize(const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceImage2DViewOf3DFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceShaderTileImageFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderTileImageColorReadAccess;
+    VkBool32 shaderTileImageDepthReadAccess;
+    VkBool32 shaderTileImageStencilReadAccess;
+
+    safe_VkPhysicalDeviceShaderTileImageFeaturesEXT(const VkPhysicalDeviceShaderTileImageFeaturesEXT* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderTileImageFeaturesEXT(const safe_VkPhysicalDeviceShaderTileImageFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceShaderTileImageFeaturesEXT& operator=(const safe_VkPhysicalDeviceShaderTileImageFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceShaderTileImageFeaturesEXT();
+    ~safe_VkPhysicalDeviceShaderTileImageFeaturesEXT();
+    void initialize(const VkPhysicalDeviceShaderTileImageFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderTileImageFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderTileImageFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderTileImageFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceShaderTileImageFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderTileImageFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceShaderTileImagePropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderTileImageCoherentReadAccelerated;
+    VkBool32 shaderTileImageReadSampleFromPixelRateInvocation;
+    VkBool32 shaderTileImageReadFromHelperInvocation;
+
+    safe_VkPhysicalDeviceShaderTileImagePropertiesEXT(const VkPhysicalDeviceShaderTileImagePropertiesEXT* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderTileImagePropertiesEXT(const safe_VkPhysicalDeviceShaderTileImagePropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceShaderTileImagePropertiesEXT& operator=(const safe_VkPhysicalDeviceShaderTileImagePropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceShaderTileImagePropertiesEXT();
+    ~safe_VkPhysicalDeviceShaderTileImagePropertiesEXT();
+    void initialize(const VkPhysicalDeviceShaderTileImagePropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderTileImagePropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderTileImagePropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderTileImagePropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceShaderTileImagePropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderTileImagePropertiesEXT const*>(this);
+    }
+};
+union safe_VkDeviceOrHostAddressKHR {
+    VkDeviceAddress deviceAddress;
+    void* hostAddress{};
+
+    safe_VkDeviceOrHostAddressKHR(const VkDeviceOrHostAddressKHR* in_struct, PNextCopyState* copy_state = {});
+    safe_VkDeviceOrHostAddressKHR(const safe_VkDeviceOrHostAddressKHR& copy_src);
+    safe_VkDeviceOrHostAddressKHR& operator=(const safe_VkDeviceOrHostAddressKHR& copy_src);
+    safe_VkDeviceOrHostAddressKHR();
+    ~safe_VkDeviceOrHostAddressKHR();
+    void initialize(const VkDeviceOrHostAddressKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDeviceOrHostAddressKHR* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceOrHostAddressKHR* ptr() { return reinterpret_cast<VkDeviceOrHostAddressKHR*>(this); }
+    VkDeviceOrHostAddressKHR const* ptr() const { return reinterpret_cast<VkDeviceOrHostAddressKHR const*>(this); }
+};
+struct safe_VkMicromapBuildInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkMicromapTypeEXT type;
+    VkBuildMicromapFlagsEXT flags;
+    VkBuildMicromapModeEXT mode;
+    VkMicromapEXT dstMicromap;
+    uint32_t usageCountsCount;
+    const VkMicromapUsageEXT* pUsageCounts{};
+    const VkMicromapUsageEXT* const* ppUsageCounts{};
+    safe_VkDeviceOrHostAddressConstKHR data;
+    safe_VkDeviceOrHostAddressKHR scratchData;
+    safe_VkDeviceOrHostAddressConstKHR triangleArray;
+    VkDeviceSize triangleArrayStride;
+
+    safe_VkMicromapBuildInfoEXT(const VkMicromapBuildInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkMicromapBuildInfoEXT(const safe_VkMicromapBuildInfoEXT& copy_src);
+    safe_VkMicromapBuildInfoEXT& operator=(const safe_VkMicromapBuildInfoEXT& copy_src);
+    safe_VkMicromapBuildInfoEXT();
+    ~safe_VkMicromapBuildInfoEXT();
+    void initialize(const VkMicromapBuildInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMicromapBuildInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkMicromapBuildInfoEXT* ptr() { return reinterpret_cast<VkMicromapBuildInfoEXT*>(this); }
+    VkMicromapBuildInfoEXT const* ptr() const { return reinterpret_cast<VkMicromapBuildInfoEXT const*>(this); }
+};
+struct safe_VkMicromapCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkMicromapCreateFlagsEXT createFlags;
+    VkBuffer buffer;
+    VkDeviceSize offset;
+    VkDeviceSize size;
+    VkMicromapTypeEXT type;
+    VkDeviceAddress deviceAddress;
+
+    safe_VkMicromapCreateInfoEXT(const VkMicromapCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkMicromapCreateInfoEXT(const safe_VkMicromapCreateInfoEXT& copy_src);
+    safe_VkMicromapCreateInfoEXT& operator=(const safe_VkMicromapCreateInfoEXT& copy_src);
+    safe_VkMicromapCreateInfoEXT();
+    ~safe_VkMicromapCreateInfoEXT();
+    void initialize(const VkMicromapCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMicromapCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkMicromapCreateInfoEXT* ptr() { return reinterpret_cast<VkMicromapCreateInfoEXT*>(this); }
+    VkMicromapCreateInfoEXT const* ptr() const { return reinterpret_cast<VkMicromapCreateInfoEXT const*>(this); }
+};
+struct safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 micromap;
+    VkBool32 micromapCaptureReplay;
+    VkBool32 micromapHostCommands;
+
+    safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT(const VkPhysicalDeviceOpacityMicromapFeaturesEXT* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT(const safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT& operator=(const safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT();
+    ~safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT();
+    void initialize(const VkPhysicalDeviceOpacityMicromapFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceOpacityMicromapFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceOpacityMicromapFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceOpacityMicromapFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceOpacityMicromapFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxOpacity2StateSubdivisionLevel;
+    uint32_t maxOpacity4StateSubdivisionLevel;
+
+    safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT(const VkPhysicalDeviceOpacityMicromapPropertiesEXT* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT(const safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT& operator=(const safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT();
+    ~safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT();
+    void initialize(const VkPhysicalDeviceOpacityMicromapPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceOpacityMicromapPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceOpacityMicromapPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceOpacityMicromapPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceOpacityMicromapPropertiesEXT const*>(this);
+    }
+};
+struct safe_VkMicromapVersionInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    const uint8_t* pVersionData{};
+
+    safe_VkMicromapVersionInfoEXT(const VkMicromapVersionInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    safe_VkMicromapVersionInfoEXT(const safe_VkMicromapVersionInfoEXT& copy_src);
+    safe_VkMicromapVersionInfoEXT& operator=(const safe_VkMicromapVersionInfoEXT& copy_src);
+    safe_VkMicromapVersionInfoEXT();
+    ~safe_VkMicromapVersionInfoEXT();
+    void initialize(const VkMicromapVersionInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMicromapVersionInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkMicromapVersionInfoEXT* ptr() { return reinterpret_cast<VkMicromapVersionInfoEXT*>(this); }
+    VkMicromapVersionInfoEXT const* ptr() const { return reinterpret_cast<VkMicromapVersionInfoEXT const*>(this); }
+};
+struct safe_VkCopyMicromapToMemoryInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkMicromapEXT src;
+    safe_VkDeviceOrHostAddressKHR dst;
+    VkCopyMicromapModeEXT mode;
+
+    safe_VkCopyMicromapToMemoryInfoEXT(const VkCopyMicromapToMemoryInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    safe_VkCopyMicromapToMemoryInfoEXT(const safe_VkCopyMicromapToMemoryInfoEXT& copy_src);
+    safe_VkCopyMicromapToMemoryInfoEXT& operator=(const safe_VkCopyMicromapToMemoryInfoEXT& copy_src);
+    safe_VkCopyMicromapToMemoryInfoEXT();
+    ~safe_VkCopyMicromapToMemoryInfoEXT();
+    void initialize(const VkCopyMicromapToMemoryInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCopyMicromapToMemoryInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkCopyMicromapToMemoryInfoEXT* ptr() { return reinterpret_cast<VkCopyMicromapToMemoryInfoEXT*>(this); }
+    VkCopyMicromapToMemoryInfoEXT const* ptr() const { return reinterpret_cast<VkCopyMicromapToMemoryInfoEXT const*>(this); }
+};
+struct safe_VkCopyMemoryToMicromapInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    safe_VkDeviceOrHostAddressConstKHR src;
+    VkMicromapEXT dst;
+    VkCopyMicromapModeEXT mode;
+
+    safe_VkCopyMemoryToMicromapInfoEXT(const VkCopyMemoryToMicromapInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    safe_VkCopyMemoryToMicromapInfoEXT(const safe_VkCopyMemoryToMicromapInfoEXT& copy_src);
+    safe_VkCopyMemoryToMicromapInfoEXT& operator=(const safe_VkCopyMemoryToMicromapInfoEXT& copy_src);
+    safe_VkCopyMemoryToMicromapInfoEXT();
+    ~safe_VkCopyMemoryToMicromapInfoEXT();
+    void initialize(const VkCopyMemoryToMicromapInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCopyMemoryToMicromapInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkCopyMemoryToMicromapInfoEXT* ptr() { return reinterpret_cast<VkCopyMemoryToMicromapInfoEXT*>(this); }
+    VkCopyMemoryToMicromapInfoEXT const* ptr() const { return reinterpret_cast<VkCopyMemoryToMicromapInfoEXT const*>(this); }
+};
+struct safe_VkCopyMicromapInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkMicromapEXT src;
+    VkMicromapEXT dst;
+    VkCopyMicromapModeEXT mode;
+
+    safe_VkCopyMicromapInfoEXT(const VkCopyMicromapInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkCopyMicromapInfoEXT(const safe_VkCopyMicromapInfoEXT& copy_src);
+    safe_VkCopyMicromapInfoEXT& operator=(const safe_VkCopyMicromapInfoEXT& copy_src);
+    safe_VkCopyMicromapInfoEXT();
+    ~safe_VkCopyMicromapInfoEXT();
+    void initialize(const VkCopyMicromapInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCopyMicromapInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkCopyMicromapInfoEXT* ptr() { return reinterpret_cast<VkCopyMicromapInfoEXT*>(this); }
+    VkCopyMicromapInfoEXT const* ptr() const { return reinterpret_cast<VkCopyMicromapInfoEXT const*>(this); }
+};
+struct safe_VkMicromapBuildSizesInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceSize micromapSize;
+    VkDeviceSize buildScratchSize;
+    VkBool32 discardable;
+
+    safe_VkMicromapBuildSizesInfoEXT(const VkMicromapBuildSizesInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    safe_VkMicromapBuildSizesInfoEXT(const safe_VkMicromapBuildSizesInfoEXT& copy_src);
+    safe_VkMicromapBuildSizesInfoEXT& operator=(const safe_VkMicromapBuildSizesInfoEXT& copy_src);
+    safe_VkMicromapBuildSizesInfoEXT();
+    ~safe_VkMicromapBuildSizesInfoEXT();
+    void initialize(const VkMicromapBuildSizesInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMicromapBuildSizesInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkMicromapBuildSizesInfoEXT* ptr() { return reinterpret_cast<VkMicromapBuildSizesInfoEXT*>(this); }
+    VkMicromapBuildSizesInfoEXT const* ptr() const { return reinterpret_cast<VkMicromapBuildSizesInfoEXT const*>(this); }
+};
+struct safe_VkAccelerationStructureTrianglesOpacityMicromapEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkIndexType indexType;
+    safe_VkDeviceOrHostAddressConstKHR indexBuffer;
+    VkDeviceSize indexStride;
+    uint32_t baseTriangle;
+    uint32_t usageCountsCount;
+    const VkMicromapUsageEXT* pUsageCounts{};
+    const VkMicromapUsageEXT* const* ppUsageCounts{};
+    VkMicromapEXT micromap;
+
+    safe_VkAccelerationStructureTrianglesOpacityMicromapEXT(const VkAccelerationStructureTrianglesOpacityMicromapEXT* in_struct,
+                                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkAccelerationStructureTrianglesOpacityMicromapEXT(
+        const safe_VkAccelerationStructureTrianglesOpacityMicromapEXT& copy_src);
+    safe_VkAccelerationStructureTrianglesOpacityMicromapEXT& operator=(
+        const safe_VkAccelerationStructureTrianglesOpacityMicromapEXT& copy_src);
+    safe_VkAccelerationStructureTrianglesOpacityMicromapEXT();
+    ~safe_VkAccelerationStructureTrianglesOpacityMicromapEXT();
+    void initialize(const VkAccelerationStructureTrianglesOpacityMicromapEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAccelerationStructureTrianglesOpacityMicromapEXT* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureTrianglesOpacityMicromapEXT* ptr() {
+        return reinterpret_cast<VkAccelerationStructureTrianglesOpacityMicromapEXT*>(this);
+    }
+    VkAccelerationStructureTrianglesOpacityMicromapEXT const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureTrianglesOpacityMicromapEXT const*>(this);
+    }
+};
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+struct safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 displacementMicromap;
+
+    safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV(const VkPhysicalDeviceDisplacementMicromapFeaturesNV* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV(const safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV& operator=(
+        const safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV();
+    ~safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV();
+    void initialize(const VkPhysicalDeviceDisplacementMicromapFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDisplacementMicromapFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDisplacementMicromapFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceDisplacementMicromapFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDisplacementMicromapFeaturesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxDisplacementMicromapSubdivisionLevel;
+
+    safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV(const VkPhysicalDeviceDisplacementMicromapPropertiesNV* in_struct,
+                                                          PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV(const safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV& copy_src);
+    safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV& operator=(
+        const safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV& copy_src);
+    safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV();
+    ~safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV();
+    void initialize(const VkPhysicalDeviceDisplacementMicromapPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDisplacementMicromapPropertiesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDisplacementMicromapPropertiesNV*>(this);
+    }
+    VkPhysicalDeviceDisplacementMicromapPropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDisplacementMicromapPropertiesNV const*>(this);
+    }
+};
+struct safe_VkAccelerationStructureTrianglesDisplacementMicromapNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkFormat displacementBiasAndScaleFormat;
+    VkFormat displacementVectorFormat;
+    safe_VkDeviceOrHostAddressConstKHR displacementBiasAndScaleBuffer;
+    VkDeviceSize displacementBiasAndScaleStride;
+    safe_VkDeviceOrHostAddressConstKHR displacementVectorBuffer;
+    VkDeviceSize displacementVectorStride;
+    safe_VkDeviceOrHostAddressConstKHR displacedMicromapPrimitiveFlags;
+    VkDeviceSize displacedMicromapPrimitiveFlagsStride;
+    VkIndexType indexType;
+    safe_VkDeviceOrHostAddressConstKHR indexBuffer;
+    VkDeviceSize indexStride;
+    uint32_t baseTriangle;
+    uint32_t usageCountsCount;
+    const VkMicromapUsageEXT* pUsageCounts{};
+    const VkMicromapUsageEXT* const* ppUsageCounts{};
+    VkMicromapEXT micromap;
+
+    safe_VkAccelerationStructureTrianglesDisplacementMicromapNV(
+        const VkAccelerationStructureTrianglesDisplacementMicromapNV* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkAccelerationStructureTrianglesDisplacementMicromapNV(
+        const safe_VkAccelerationStructureTrianglesDisplacementMicromapNV& copy_src);
+    safe_VkAccelerationStructureTrianglesDisplacementMicromapNV& operator=(
+        const safe_VkAccelerationStructureTrianglesDisplacementMicromapNV& copy_src);
+    safe_VkAccelerationStructureTrianglesDisplacementMicromapNV();
+    ~safe_VkAccelerationStructureTrianglesDisplacementMicromapNV();
+    void initialize(const VkAccelerationStructureTrianglesDisplacementMicromapNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAccelerationStructureTrianglesDisplacementMicromapNV* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureTrianglesDisplacementMicromapNV* ptr() {
+        return reinterpret_cast<VkAccelerationStructureTrianglesDisplacementMicromapNV*>(this);
+    }
+    VkAccelerationStructureTrianglesDisplacementMicromapNV const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureTrianglesDisplacementMicromapNV const*>(this);
+    }
+};
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+struct safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 clustercullingShader;
+    VkBool32 multiviewClusterCullingShader;
+
+    safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* in_struct,
+                                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
+        const safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI& copy_src);
+    safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI& operator=(
+        const safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI& copy_src);
+    safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI();
+    ~safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI();
+    void initialize(const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI*>(this);
+    }
+    VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxWorkGroupCount[3];
+    uint32_t maxWorkGroupSize[3];
+    uint32_t maxOutputClusterCount;
+    VkDeviceSize indirectBufferOffsetAlignment;
+
+    safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* in_struct,
+                                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
+        const safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI& copy_src);
+    safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI& operator=(
+        const safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI& copy_src);
+    safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI();
+    ~safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI();
+    void initialize(const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI*>(this);
+    }
+    VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 clusterShadingRate;
+
+    safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI(
+        const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI(
+        const safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI& copy_src);
+    safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI& operator=(
+        const safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI& copy_src);
+    safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI();
+    ~safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI();
+    void initialize(const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI*>(this);
+    }
+    VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 borderColorSwizzle;
+    VkBool32 borderColorSwizzleFromImage;
+
+    safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(const safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT();
+    ~safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT();
+    void initialize(const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceBorderColorSwizzleFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkSamplerBorderColorComponentMappingCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkComponentMapping components;
+    VkBool32 srgb;
+
+    safe_VkSamplerBorderColorComponentMappingCreateInfoEXT(const VkSamplerBorderColorComponentMappingCreateInfoEXT* in_struct,
+                                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSamplerBorderColorComponentMappingCreateInfoEXT(const safe_VkSamplerBorderColorComponentMappingCreateInfoEXT& copy_src);
+    safe_VkSamplerBorderColorComponentMappingCreateInfoEXT& operator=(
+        const safe_VkSamplerBorderColorComponentMappingCreateInfoEXT& copy_src);
+    safe_VkSamplerBorderColorComponentMappingCreateInfoEXT();
+    ~safe_VkSamplerBorderColorComponentMappingCreateInfoEXT();
+    void initialize(const VkSamplerBorderColorComponentMappingCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSamplerBorderColorComponentMappingCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSamplerBorderColorComponentMappingCreateInfoEXT* ptr() {
+        return reinterpret_cast<VkSamplerBorderColorComponentMappingCreateInfoEXT*>(this);
+    }
+    VkSamplerBorderColorComponentMappingCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkSamplerBorderColorComponentMappingCreateInfoEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 pageableDeviceLocalMemory;
+
+    safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* in_struct,
+                                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
+        const safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT& copy_src);
+    safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT& operator=(
+        const safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT& copy_src);
+    safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT();
+    ~safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT();
+    void initialize(const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*>(this);
+    }
+    VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceShaderCorePropertiesARM {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t pixelRate;
+    uint32_t texelRate;
+    uint32_t fmaRate;
+
+    safe_VkPhysicalDeviceShaderCorePropertiesARM(const VkPhysicalDeviceShaderCorePropertiesARM* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderCorePropertiesARM(const safe_VkPhysicalDeviceShaderCorePropertiesARM& copy_src);
+    safe_VkPhysicalDeviceShaderCorePropertiesARM& operator=(const safe_VkPhysicalDeviceShaderCorePropertiesARM& copy_src);
+    safe_VkPhysicalDeviceShaderCorePropertiesARM();
+    ~safe_VkPhysicalDeviceShaderCorePropertiesARM();
+    void initialize(const VkPhysicalDeviceShaderCorePropertiesARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderCorePropertiesARM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderCorePropertiesARM* ptr() { return reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesARM*>(this); }
+    VkPhysicalDeviceShaderCorePropertiesARM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesARM const*>(this);
+    }
+};
+struct safe_VkDeviceQueueShaderCoreControlCreateInfoARM {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t shaderCoreCount;
+
+    safe_VkDeviceQueueShaderCoreControlCreateInfoARM(const VkDeviceQueueShaderCoreControlCreateInfoARM* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDeviceQueueShaderCoreControlCreateInfoARM(const safe_VkDeviceQueueShaderCoreControlCreateInfoARM& copy_src);
+    safe_VkDeviceQueueShaderCoreControlCreateInfoARM& operator=(const safe_VkDeviceQueueShaderCoreControlCreateInfoARM& copy_src);
+    safe_VkDeviceQueueShaderCoreControlCreateInfoARM();
+    ~safe_VkDeviceQueueShaderCoreControlCreateInfoARM();
+    void initialize(const VkDeviceQueueShaderCoreControlCreateInfoARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDeviceQueueShaderCoreControlCreateInfoARM* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceQueueShaderCoreControlCreateInfoARM* ptr() {
+        return reinterpret_cast<VkDeviceQueueShaderCoreControlCreateInfoARM*>(this);
+    }
+    VkDeviceQueueShaderCoreControlCreateInfoARM const* ptr() const {
+        return reinterpret_cast<VkDeviceQueueShaderCoreControlCreateInfoARM const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceSchedulingControlsFeaturesARM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 schedulingControls;
+
+    safe_VkPhysicalDeviceSchedulingControlsFeaturesARM(const VkPhysicalDeviceSchedulingControlsFeaturesARM* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceSchedulingControlsFeaturesARM(const safe_VkPhysicalDeviceSchedulingControlsFeaturesARM& copy_src);
+    safe_VkPhysicalDeviceSchedulingControlsFeaturesARM& operator=(
+        const safe_VkPhysicalDeviceSchedulingControlsFeaturesARM& copy_src);
+    safe_VkPhysicalDeviceSchedulingControlsFeaturesARM();
+    ~safe_VkPhysicalDeviceSchedulingControlsFeaturesARM();
+    void initialize(const VkPhysicalDeviceSchedulingControlsFeaturesARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceSchedulingControlsFeaturesARM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSchedulingControlsFeaturesARM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceSchedulingControlsFeaturesARM*>(this);
+    }
+    VkPhysicalDeviceSchedulingControlsFeaturesARM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceSchedulingControlsFeaturesARM const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceSchedulingControlsPropertiesARM {
+    VkStructureType sType;
+    void* pNext{};
+    VkPhysicalDeviceSchedulingControlsFlagsARM schedulingControlsFlags;
+
+    safe_VkPhysicalDeviceSchedulingControlsPropertiesARM(const VkPhysicalDeviceSchedulingControlsPropertiesARM* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceSchedulingControlsPropertiesARM(const safe_VkPhysicalDeviceSchedulingControlsPropertiesARM& copy_src);
+    safe_VkPhysicalDeviceSchedulingControlsPropertiesARM& operator=(
+        const safe_VkPhysicalDeviceSchedulingControlsPropertiesARM& copy_src);
+    safe_VkPhysicalDeviceSchedulingControlsPropertiesARM();
+    ~safe_VkPhysicalDeviceSchedulingControlsPropertiesARM();
+    void initialize(const VkPhysicalDeviceSchedulingControlsPropertiesARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceSchedulingControlsPropertiesARM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSchedulingControlsPropertiesARM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceSchedulingControlsPropertiesARM*>(this);
+    }
+    VkPhysicalDeviceSchedulingControlsPropertiesARM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceSchedulingControlsPropertiesARM const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 imageSlicedViewOf3D;
+
+    safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(const safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT();
+    ~safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT();
+    void initialize(const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkImageViewSlicedCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t sliceOffset;
+    uint32_t sliceCount;
+
+    safe_VkImageViewSlicedCreateInfoEXT(const VkImageViewSlicedCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkImageViewSlicedCreateInfoEXT(const safe_VkImageViewSlicedCreateInfoEXT& copy_src);
+    safe_VkImageViewSlicedCreateInfoEXT& operator=(const safe_VkImageViewSlicedCreateInfoEXT& copy_src);
+    safe_VkImageViewSlicedCreateInfoEXT();
+    ~safe_VkImageViewSlicedCreateInfoEXT();
+    void initialize(const VkImageViewSlicedCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageViewSlicedCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImageViewSlicedCreateInfoEXT* ptr() { return reinterpret_cast<VkImageViewSlicedCreateInfoEXT*>(this); }
+    VkImageViewSlicedCreateInfoEXT const* ptr() const { return reinterpret_cast<VkImageViewSlicedCreateInfoEXT const*>(this); }
+};
+struct safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 descriptorSetHostMapping;
+
+    safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
+        const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
+        const safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE& copy_src);
+    safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE& operator=(
+        const safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE& copy_src);
+    safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE();
+    ~safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE();
+    void initialize(const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE*>(this);
+    }
+    VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const*>(this);
+    }
+};
+struct safe_VkDescriptorSetBindingReferenceVALVE {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDescriptorSetLayout descriptorSetLayout;
+    uint32_t binding;
+
+    safe_VkDescriptorSetBindingReferenceVALVE(const VkDescriptorSetBindingReferenceVALVE* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDescriptorSetBindingReferenceVALVE(const safe_VkDescriptorSetBindingReferenceVALVE& copy_src);
+    safe_VkDescriptorSetBindingReferenceVALVE& operator=(const safe_VkDescriptorSetBindingReferenceVALVE& copy_src);
+    safe_VkDescriptorSetBindingReferenceVALVE();
+    ~safe_VkDescriptorSetBindingReferenceVALVE();
+    void initialize(const VkDescriptorSetBindingReferenceVALVE* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDescriptorSetBindingReferenceVALVE* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorSetBindingReferenceVALVE* ptr() { return reinterpret_cast<VkDescriptorSetBindingReferenceVALVE*>(this); }
+    VkDescriptorSetBindingReferenceVALVE const* ptr() const {
+        return reinterpret_cast<VkDescriptorSetBindingReferenceVALVE const*>(this);
+    }
+};
+struct safe_VkDescriptorSetLayoutHostMappingInfoVALVE {
+    VkStructureType sType;
+    void* pNext{};
+    size_t descriptorOffset;
+    uint32_t descriptorSize;
+
+    safe_VkDescriptorSetLayoutHostMappingInfoVALVE(const VkDescriptorSetLayoutHostMappingInfoVALVE* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDescriptorSetLayoutHostMappingInfoVALVE(const safe_VkDescriptorSetLayoutHostMappingInfoVALVE& copy_src);
+    safe_VkDescriptorSetLayoutHostMappingInfoVALVE& operator=(const safe_VkDescriptorSetLayoutHostMappingInfoVALVE& copy_src);
+    safe_VkDescriptorSetLayoutHostMappingInfoVALVE();
+    ~safe_VkDescriptorSetLayoutHostMappingInfoVALVE();
+    void initialize(const VkDescriptorSetLayoutHostMappingInfoVALVE* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDescriptorSetLayoutHostMappingInfoVALVE* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorSetLayoutHostMappingInfoVALVE* ptr() { return reinterpret_cast<VkDescriptorSetLayoutHostMappingInfoVALVE*>(this); }
+    VkDescriptorSetLayoutHostMappingInfoVALVE const* ptr() const {
+        return reinterpret_cast<VkDescriptorSetLayoutHostMappingInfoVALVE const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 depthClampZeroOne;
+
+    safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(const safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT& operator=(const safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT();
+    ~safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT();
+    void initialize(const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDepthClampZeroOneFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceDepthClampZeroOneFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDepthClampZeroOneFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 nonSeamlessCubeMap;
+
+    safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(const safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT();
+    ~safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT();
+    void initialize(const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceRenderPassStripedFeaturesARM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 renderPassStriped;
+
+    safe_VkPhysicalDeviceRenderPassStripedFeaturesARM(const VkPhysicalDeviceRenderPassStripedFeaturesARM* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceRenderPassStripedFeaturesARM(const safe_VkPhysicalDeviceRenderPassStripedFeaturesARM& copy_src);
+    safe_VkPhysicalDeviceRenderPassStripedFeaturesARM& operator=(const safe_VkPhysicalDeviceRenderPassStripedFeaturesARM& copy_src);
+    safe_VkPhysicalDeviceRenderPassStripedFeaturesARM();
+    ~safe_VkPhysicalDeviceRenderPassStripedFeaturesARM();
+    void initialize(const VkPhysicalDeviceRenderPassStripedFeaturesARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceRenderPassStripedFeaturesARM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRenderPassStripedFeaturesARM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceRenderPassStripedFeaturesARM*>(this);
+    }
+    VkPhysicalDeviceRenderPassStripedFeaturesARM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRenderPassStripedFeaturesARM const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceRenderPassStripedPropertiesARM {
+    VkStructureType sType;
+    void* pNext{};
+    VkExtent2D renderPassStripeGranularity;
+    uint32_t maxRenderPassStripes;
+
+    safe_VkPhysicalDeviceRenderPassStripedPropertiesARM(const VkPhysicalDeviceRenderPassStripedPropertiesARM* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceRenderPassStripedPropertiesARM(const safe_VkPhysicalDeviceRenderPassStripedPropertiesARM& copy_src);
+    safe_VkPhysicalDeviceRenderPassStripedPropertiesARM& operator=(
+        const safe_VkPhysicalDeviceRenderPassStripedPropertiesARM& copy_src);
+    safe_VkPhysicalDeviceRenderPassStripedPropertiesARM();
+    ~safe_VkPhysicalDeviceRenderPassStripedPropertiesARM();
+    void initialize(const VkPhysicalDeviceRenderPassStripedPropertiesARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceRenderPassStripedPropertiesARM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRenderPassStripedPropertiesARM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceRenderPassStripedPropertiesARM*>(this);
+    }
+    VkPhysicalDeviceRenderPassStripedPropertiesARM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRenderPassStripedPropertiesARM const*>(this);
+    }
+};
+struct safe_VkRenderPassStripeInfoARM {
+    VkStructureType sType;
+    const void* pNext{};
+    VkRect2D stripeArea;
+
+    safe_VkRenderPassStripeInfoARM(const VkRenderPassStripeInfoARM* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    safe_VkRenderPassStripeInfoARM(const safe_VkRenderPassStripeInfoARM& copy_src);
+    safe_VkRenderPassStripeInfoARM& operator=(const safe_VkRenderPassStripeInfoARM& copy_src);
+    safe_VkRenderPassStripeInfoARM();
+    ~safe_VkRenderPassStripeInfoARM();
+    void initialize(const VkRenderPassStripeInfoARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderPassStripeInfoARM* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassStripeInfoARM* ptr() { return reinterpret_cast<VkRenderPassStripeInfoARM*>(this); }
+    VkRenderPassStripeInfoARM const* ptr() const { return reinterpret_cast<VkRenderPassStripeInfoARM const*>(this); }
+};
+struct safe_VkRenderPassStripeBeginInfoARM {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t stripeInfoCount;
+    safe_VkRenderPassStripeInfoARM* pStripeInfos{};
+
+    safe_VkRenderPassStripeBeginInfoARM(const VkRenderPassStripeBeginInfoARM* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkRenderPassStripeBeginInfoARM(const safe_VkRenderPassStripeBeginInfoARM& copy_src);
+    safe_VkRenderPassStripeBeginInfoARM& operator=(const safe_VkRenderPassStripeBeginInfoARM& copy_src);
+    safe_VkRenderPassStripeBeginInfoARM();
+    ~safe_VkRenderPassStripeBeginInfoARM();
+    void initialize(const VkRenderPassStripeBeginInfoARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderPassStripeBeginInfoARM* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassStripeBeginInfoARM* ptr() { return reinterpret_cast<VkRenderPassStripeBeginInfoARM*>(this); }
+    VkRenderPassStripeBeginInfoARM const* ptr() const { return reinterpret_cast<VkRenderPassStripeBeginInfoARM const*>(this); }
+};
+struct safe_VkRenderPassStripeSubmitInfoARM {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t stripeSemaphoreInfoCount;
+    safe_VkSemaphoreSubmitInfo* pStripeSemaphoreInfos{};
+
+    safe_VkRenderPassStripeSubmitInfoARM(const VkRenderPassStripeSubmitInfoARM* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkRenderPassStripeSubmitInfoARM(const safe_VkRenderPassStripeSubmitInfoARM& copy_src);
+    safe_VkRenderPassStripeSubmitInfoARM& operator=(const safe_VkRenderPassStripeSubmitInfoARM& copy_src);
+    safe_VkRenderPassStripeSubmitInfoARM();
+    ~safe_VkRenderPassStripeSubmitInfoARM();
+    void initialize(const VkRenderPassStripeSubmitInfoARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderPassStripeSubmitInfoARM* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassStripeSubmitInfoARM* ptr() { return reinterpret_cast<VkRenderPassStripeSubmitInfoARM*>(this); }
+    VkRenderPassStripeSubmitInfoARM const* ptr() const { return reinterpret_cast<VkRenderPassStripeSubmitInfoARM const*>(this); }
+};
+struct safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 fragmentDensityMapOffset;
+
+    safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* in_struct,
+                                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+        const safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& copy_src);
+    safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& operator=(
+        const safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& copy_src);
+    safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM();
+    ~safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM();
+    void initialize(const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM*>(this);
+    }
+    VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkExtent2D fragmentDensityOffsetGranularity;
+
+    safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+        const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+        const safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM& copy_src);
+    safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM& operator=(
+        const safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM& copy_src);
+    safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM();
+    ~safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM();
+    void initialize(const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM*>(this);
+    }
+    VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const*>(this);
+    }
+};
+struct safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t fragmentDensityOffsetCount;
+    const VkOffset2D* pFragmentDensityOffsets{};
+
+    safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(const VkSubpassFragmentDensityMapOffsetEndInfoQCOM* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(const safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM& copy_src);
+    safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM& operator=(const safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM& copy_src);
+    safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM();
+    ~safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM();
+    void initialize(const VkSubpassFragmentDensityMapOffsetEndInfoQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkSubpassFragmentDensityMapOffsetEndInfoQCOM* ptr() {
+        return reinterpret_cast<VkSubpassFragmentDensityMapOffsetEndInfoQCOM*>(this);
+    }
+    VkSubpassFragmentDensityMapOffsetEndInfoQCOM const* ptr() const {
+        return reinterpret_cast<VkSubpassFragmentDensityMapOffsetEndInfoQCOM const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 indirectCopy;
+
+    safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(const safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV& operator=(const safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV();
+    ~safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV();
+    void initialize(const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceCopyMemoryIndirectFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceCopyMemoryIndirectFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCopyMemoryIndirectFeaturesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkQueueFlags supportedQueues;
+
+    safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(const safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV& copy_src);
+    safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV& operator=(
+        const safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV& copy_src);
+    safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV();
+    ~safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV();
+    void initialize(const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceCopyMemoryIndirectPropertiesNV*>(this);
+    }
+    VkPhysicalDeviceCopyMemoryIndirectPropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCopyMemoryIndirectPropertiesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 memoryDecompression;
+
+    safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV(const VkPhysicalDeviceMemoryDecompressionFeaturesNV* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV(const safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV& operator=(
+        const safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV();
+    ~safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV();
+    void initialize(const VkPhysicalDeviceMemoryDecompressionFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMemoryDecompressionFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceMemoryDecompressionFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceMemoryDecompressionFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMemoryDecompressionFeaturesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkMemoryDecompressionMethodFlagsNV decompressionMethods;
+    uint64_t maxDecompressionIndirectCount;
+
+    safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV(const VkPhysicalDeviceMemoryDecompressionPropertiesNV* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV(const safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV& copy_src);
+    safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV& operator=(
+        const safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV& copy_src);
+    safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV();
+    ~safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV();
+    void initialize(const VkPhysicalDeviceMemoryDecompressionPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMemoryDecompressionPropertiesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceMemoryDecompressionPropertiesNV*>(this);
+    }
+    VkPhysicalDeviceMemoryDecompressionPropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMemoryDecompressionPropertiesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 deviceGeneratedCompute;
+    VkBool32 deviceGeneratedComputePipelines;
+    VkBool32 deviceGeneratedComputeCaptureReplay;
+
+    safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV(
+        const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV(
+        const safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV& operator=(
+        const safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV();
+    ~safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV();
+    void initialize(const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV const*>(this);
+    }
+};
+struct safe_VkComputePipelineIndirectBufferInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceAddress deviceAddress;
+    VkDeviceSize size;
+    VkDeviceAddress pipelineDeviceAddressCaptureReplay;
+
+    safe_VkComputePipelineIndirectBufferInfoNV(const VkComputePipelineIndirectBufferInfoNV* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkComputePipelineIndirectBufferInfoNV(const safe_VkComputePipelineIndirectBufferInfoNV& copy_src);
+    safe_VkComputePipelineIndirectBufferInfoNV& operator=(const safe_VkComputePipelineIndirectBufferInfoNV& copy_src);
+    safe_VkComputePipelineIndirectBufferInfoNV();
+    ~safe_VkComputePipelineIndirectBufferInfoNV();
+    void initialize(const VkComputePipelineIndirectBufferInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkComputePipelineIndirectBufferInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkComputePipelineIndirectBufferInfoNV* ptr() { return reinterpret_cast<VkComputePipelineIndirectBufferInfoNV*>(this); }
+    VkComputePipelineIndirectBufferInfoNV const* ptr() const {
+        return reinterpret_cast<VkComputePipelineIndirectBufferInfoNV const*>(this);
+    }
+};
+struct safe_VkPipelineIndirectDeviceAddressInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineBindPoint pipelineBindPoint;
+    VkPipeline pipeline;
+
+    safe_VkPipelineIndirectDeviceAddressInfoNV(const VkPipelineIndirectDeviceAddressInfoNV* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineIndirectDeviceAddressInfoNV(const safe_VkPipelineIndirectDeviceAddressInfoNV& copy_src);
+    safe_VkPipelineIndirectDeviceAddressInfoNV& operator=(const safe_VkPipelineIndirectDeviceAddressInfoNV& copy_src);
+    safe_VkPipelineIndirectDeviceAddressInfoNV();
+    ~safe_VkPipelineIndirectDeviceAddressInfoNV();
+    void initialize(const VkPipelineIndirectDeviceAddressInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineIndirectDeviceAddressInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineIndirectDeviceAddressInfoNV* ptr() { return reinterpret_cast<VkPipelineIndirectDeviceAddressInfoNV*>(this); }
+    VkPipelineIndirectDeviceAddressInfoNV const* ptr() const {
+        return reinterpret_cast<VkPipelineIndirectDeviceAddressInfoNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 linearColorAttachment;
+
+    safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(const VkPhysicalDeviceLinearColorAttachmentFeaturesNV* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(const safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV& operator=(
+        const safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV();
+    ~safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV();
+    void initialize(const VkPhysicalDeviceLinearColorAttachmentFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceLinearColorAttachmentFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceLinearColorAttachmentFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceLinearColorAttachmentFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceLinearColorAttachmentFeaturesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 imageCompressionControlSwapchain;
+
+    safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+        const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+        const safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT();
+    ~safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT();
+    void initialize(const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* copy_src,
+                    PNextCopyState* copy_state = {});
+    VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkImageViewSampleWeightCreateInfoQCOM {
+    VkStructureType sType;
+    const void* pNext{};
+    VkOffset2D filterCenter;
+    VkExtent2D filterSize;
+    uint32_t numPhases;
+
+    safe_VkImageViewSampleWeightCreateInfoQCOM(const VkImageViewSampleWeightCreateInfoQCOM* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkImageViewSampleWeightCreateInfoQCOM(const safe_VkImageViewSampleWeightCreateInfoQCOM& copy_src);
+    safe_VkImageViewSampleWeightCreateInfoQCOM& operator=(const safe_VkImageViewSampleWeightCreateInfoQCOM& copy_src);
+    safe_VkImageViewSampleWeightCreateInfoQCOM();
+    ~safe_VkImageViewSampleWeightCreateInfoQCOM();
+    void initialize(const VkImageViewSampleWeightCreateInfoQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageViewSampleWeightCreateInfoQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkImageViewSampleWeightCreateInfoQCOM* ptr() { return reinterpret_cast<VkImageViewSampleWeightCreateInfoQCOM*>(this); }
+    VkImageViewSampleWeightCreateInfoQCOM const* ptr() const {
+        return reinterpret_cast<VkImageViewSampleWeightCreateInfoQCOM const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceImageProcessingFeaturesQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 textureSampleWeighted;
+    VkBool32 textureBoxFilter;
+    VkBool32 textureBlockMatch;
+
+    safe_VkPhysicalDeviceImageProcessingFeaturesQCOM(const VkPhysicalDeviceImageProcessingFeaturesQCOM* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceImageProcessingFeaturesQCOM(const safe_VkPhysicalDeviceImageProcessingFeaturesQCOM& copy_src);
+    safe_VkPhysicalDeviceImageProcessingFeaturesQCOM& operator=(const safe_VkPhysicalDeviceImageProcessingFeaturesQCOM& copy_src);
+    safe_VkPhysicalDeviceImageProcessingFeaturesQCOM();
+    ~safe_VkPhysicalDeviceImageProcessingFeaturesQCOM();
+    void initialize(const VkPhysicalDeviceImageProcessingFeaturesQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceImageProcessingFeaturesQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceImageProcessingFeaturesQCOM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceImageProcessingFeaturesQCOM*>(this);
+    }
+    VkPhysicalDeviceImageProcessingFeaturesQCOM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceImageProcessingFeaturesQCOM const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceImageProcessingPropertiesQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxWeightFilterPhases;
+    VkExtent2D maxWeightFilterDimension;
+    VkExtent2D maxBlockMatchRegion;
+    VkExtent2D maxBoxFilterBlockSize;
+
+    safe_VkPhysicalDeviceImageProcessingPropertiesQCOM(const VkPhysicalDeviceImageProcessingPropertiesQCOM* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceImageProcessingPropertiesQCOM(const safe_VkPhysicalDeviceImageProcessingPropertiesQCOM& copy_src);
+    safe_VkPhysicalDeviceImageProcessingPropertiesQCOM& operator=(
+        const safe_VkPhysicalDeviceImageProcessingPropertiesQCOM& copy_src);
+    safe_VkPhysicalDeviceImageProcessingPropertiesQCOM();
+    ~safe_VkPhysicalDeviceImageProcessingPropertiesQCOM();
+    void initialize(const VkPhysicalDeviceImageProcessingPropertiesQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceImageProcessingPropertiesQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceImageProcessingPropertiesQCOM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceImageProcessingPropertiesQCOM*>(this);
+    }
+    VkPhysicalDeviceImageProcessingPropertiesQCOM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceImageProcessingPropertiesQCOM const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 nestedCommandBuffer;
+    VkBool32 nestedCommandBufferRendering;
+    VkBool32 nestedCommandBufferSimultaneousUse;
+
+    safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT(const VkPhysicalDeviceNestedCommandBufferFeaturesEXT* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT(const safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT();
+    ~safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT();
+    void initialize(const VkPhysicalDeviceNestedCommandBufferFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceNestedCommandBufferFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceNestedCommandBufferFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceNestedCommandBufferFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceNestedCommandBufferFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxCommandBufferNestingLevel;
+
+    safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT(const VkPhysicalDeviceNestedCommandBufferPropertiesEXT* in_struct,
+                                                          PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT(const safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT& operator=(
+        const safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT();
+    ~safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT();
+    void initialize(const VkPhysicalDeviceNestedCommandBufferPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceNestedCommandBufferPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceNestedCommandBufferPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceNestedCommandBufferPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceNestedCommandBufferPropertiesEXT const*>(this);
+    }
+};
+struct safe_VkExternalMemoryAcquireUnmodifiedEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 acquireUnmodifiedMemory;
+
+    safe_VkExternalMemoryAcquireUnmodifiedEXT(const VkExternalMemoryAcquireUnmodifiedEXT* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkExternalMemoryAcquireUnmodifiedEXT(const safe_VkExternalMemoryAcquireUnmodifiedEXT& copy_src);
+    safe_VkExternalMemoryAcquireUnmodifiedEXT& operator=(const safe_VkExternalMemoryAcquireUnmodifiedEXT& copy_src);
+    safe_VkExternalMemoryAcquireUnmodifiedEXT();
+    ~safe_VkExternalMemoryAcquireUnmodifiedEXT();
+    void initialize(const VkExternalMemoryAcquireUnmodifiedEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExternalMemoryAcquireUnmodifiedEXT* copy_src, PNextCopyState* copy_state = {});
+    VkExternalMemoryAcquireUnmodifiedEXT* ptr() { return reinterpret_cast<VkExternalMemoryAcquireUnmodifiedEXT*>(this); }
+    VkExternalMemoryAcquireUnmodifiedEXT const* ptr() const {
+        return reinterpret_cast<VkExternalMemoryAcquireUnmodifiedEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 extendedDynamicState3TessellationDomainOrigin;
+    VkBool32 extendedDynamicState3DepthClampEnable;
+    VkBool32 extendedDynamicState3PolygonMode;
+    VkBool32 extendedDynamicState3RasterizationSamples;
+    VkBool32 extendedDynamicState3SampleMask;
+    VkBool32 extendedDynamicState3AlphaToCoverageEnable;
+    VkBool32 extendedDynamicState3AlphaToOneEnable;
+    VkBool32 extendedDynamicState3LogicOpEnable;
+    VkBool32 extendedDynamicState3ColorBlendEnable;
+    VkBool32 extendedDynamicState3ColorBlendEquation;
+    VkBool32 extendedDynamicState3ColorWriteMask;
+    VkBool32 extendedDynamicState3RasterizationStream;
+    VkBool32 extendedDynamicState3ConservativeRasterizationMode;
+    VkBool32 extendedDynamicState3ExtraPrimitiveOverestimationSize;
+    VkBool32 extendedDynamicState3DepthClipEnable;
+    VkBool32 extendedDynamicState3SampleLocationsEnable;
+    VkBool32 extendedDynamicState3ColorBlendAdvanced;
+    VkBool32 extendedDynamicState3ProvokingVertexMode;
+    VkBool32 extendedDynamicState3LineRasterizationMode;
+    VkBool32 extendedDynamicState3LineStippleEnable;
+    VkBool32 extendedDynamicState3DepthClipNegativeOneToOne;
+    VkBool32 extendedDynamicState3ViewportWScalingEnable;
+    VkBool32 extendedDynamicState3ViewportSwizzle;
+    VkBool32 extendedDynamicState3CoverageToColorEnable;
+    VkBool32 extendedDynamicState3CoverageToColorLocation;
+    VkBool32 extendedDynamicState3CoverageModulationMode;
+    VkBool32 extendedDynamicState3CoverageModulationTableEnable;
+    VkBool32 extendedDynamicState3CoverageModulationTable;
+    VkBool32 extendedDynamicState3CoverageReductionMode;
+    VkBool32 extendedDynamicState3RepresentativeFragmentTestEnable;
+    VkBool32 extendedDynamicState3ShadingRateImageEnable;
+
+    safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* in_struct,
+                                                          PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(const safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT();
+    ~safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT();
+    void initialize(const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceExtendedDynamicState3FeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 dynamicPrimitiveTopologyUnrestricted;
+
+    safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* in_struct,
+                                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
+        const safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT& operator=(
+        const safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT();
+    ~safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT();
+    void initialize(const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceExtendedDynamicState3PropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceExtendedDynamicState3PropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExtendedDynamicState3PropertiesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 subpassMergeFeedback;
+
+    safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(const safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT();
+    ~safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT();
+    void initialize(const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkRenderPassCreationControlEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 disallowMerging;
+
+    safe_VkRenderPassCreationControlEXT(const VkRenderPassCreationControlEXT* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkRenderPassCreationControlEXT(const safe_VkRenderPassCreationControlEXT& copy_src);
+    safe_VkRenderPassCreationControlEXT& operator=(const safe_VkRenderPassCreationControlEXT& copy_src);
+    safe_VkRenderPassCreationControlEXT();
+    ~safe_VkRenderPassCreationControlEXT();
+    void initialize(const VkRenderPassCreationControlEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderPassCreationControlEXT* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassCreationControlEXT* ptr() { return reinterpret_cast<VkRenderPassCreationControlEXT*>(this); }
+    VkRenderPassCreationControlEXT const* ptr() const { return reinterpret_cast<VkRenderPassCreationControlEXT const*>(this); }
+};
+struct safe_VkRenderPassCreationFeedbackCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkRenderPassCreationFeedbackInfoEXT* pRenderPassFeedback{};
+
+    safe_VkRenderPassCreationFeedbackCreateInfoEXT(const VkRenderPassCreationFeedbackCreateInfoEXT* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkRenderPassCreationFeedbackCreateInfoEXT(const safe_VkRenderPassCreationFeedbackCreateInfoEXT& copy_src);
+    safe_VkRenderPassCreationFeedbackCreateInfoEXT& operator=(const safe_VkRenderPassCreationFeedbackCreateInfoEXT& copy_src);
+    safe_VkRenderPassCreationFeedbackCreateInfoEXT();
+    ~safe_VkRenderPassCreationFeedbackCreateInfoEXT();
+    void initialize(const VkRenderPassCreationFeedbackCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderPassCreationFeedbackCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassCreationFeedbackCreateInfoEXT* ptr() { return reinterpret_cast<VkRenderPassCreationFeedbackCreateInfoEXT*>(this); }
+    VkRenderPassCreationFeedbackCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkRenderPassCreationFeedbackCreateInfoEXT const*>(this);
+    }
+};
+struct safe_VkRenderPassSubpassFeedbackCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkRenderPassSubpassFeedbackInfoEXT* pSubpassFeedback{};
+
+    safe_VkRenderPassSubpassFeedbackCreateInfoEXT(const VkRenderPassSubpassFeedbackCreateInfoEXT* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkRenderPassSubpassFeedbackCreateInfoEXT(const safe_VkRenderPassSubpassFeedbackCreateInfoEXT& copy_src);
+    safe_VkRenderPassSubpassFeedbackCreateInfoEXT& operator=(const safe_VkRenderPassSubpassFeedbackCreateInfoEXT& copy_src);
+    safe_VkRenderPassSubpassFeedbackCreateInfoEXT();
+    ~safe_VkRenderPassSubpassFeedbackCreateInfoEXT();
+    void initialize(const VkRenderPassSubpassFeedbackCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderPassSubpassFeedbackCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassSubpassFeedbackCreateInfoEXT* ptr() { return reinterpret_cast<VkRenderPassSubpassFeedbackCreateInfoEXT*>(this); }
+    VkRenderPassSubpassFeedbackCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkRenderPassSubpassFeedbackCreateInfoEXT const*>(this);
+    }
+};
+struct safe_VkDirectDriverLoadingInfoLUNARG {
+    VkStructureType sType;
+    void* pNext{};
+    VkDirectDriverLoadingFlagsLUNARG flags;
+    PFN_vkGetInstanceProcAddrLUNARG pfnGetInstanceProcAddr;
+
+    safe_VkDirectDriverLoadingInfoLUNARG(const VkDirectDriverLoadingInfoLUNARG* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkDirectDriverLoadingInfoLUNARG(const safe_VkDirectDriverLoadingInfoLUNARG& copy_src);
+    safe_VkDirectDriverLoadingInfoLUNARG& operator=(const safe_VkDirectDriverLoadingInfoLUNARG& copy_src);
+    safe_VkDirectDriverLoadingInfoLUNARG();
+    ~safe_VkDirectDriverLoadingInfoLUNARG();
+    void initialize(const VkDirectDriverLoadingInfoLUNARG* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDirectDriverLoadingInfoLUNARG* copy_src, PNextCopyState* copy_state = {});
+    VkDirectDriverLoadingInfoLUNARG* ptr() { return reinterpret_cast<VkDirectDriverLoadingInfoLUNARG*>(this); }
+    VkDirectDriverLoadingInfoLUNARG const* ptr() const { return reinterpret_cast<VkDirectDriverLoadingInfoLUNARG const*>(this); }
+};
+struct safe_VkDirectDriverLoadingListLUNARG {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDirectDriverLoadingModeLUNARG mode;
+    uint32_t driverCount;
+    safe_VkDirectDriverLoadingInfoLUNARG* pDrivers{};
+
+    safe_VkDirectDriverLoadingListLUNARG(const VkDirectDriverLoadingListLUNARG* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkDirectDriverLoadingListLUNARG(const safe_VkDirectDriverLoadingListLUNARG& copy_src);
+    safe_VkDirectDriverLoadingListLUNARG& operator=(const safe_VkDirectDriverLoadingListLUNARG& copy_src);
+    safe_VkDirectDriverLoadingListLUNARG();
+    ~safe_VkDirectDriverLoadingListLUNARG();
+    void initialize(const VkDirectDriverLoadingListLUNARG* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDirectDriverLoadingListLUNARG* copy_src, PNextCopyState* copy_state = {});
+    VkDirectDriverLoadingListLUNARG* ptr() { return reinterpret_cast<VkDirectDriverLoadingListLUNARG*>(this); }
+    VkDirectDriverLoadingListLUNARG const* ptr() const { return reinterpret_cast<VkDirectDriverLoadingListLUNARG const*>(this); }
+};
+struct safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderModuleIdentifier;
+
+    safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* in_struct,
+                                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(const safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT();
+    ~safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT();
+    void initialize(const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint8_t shaderModuleIdentifierAlgorithmUUID[VK_UUID_SIZE];
+
+    safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* in_struct,
+                                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
+        const safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT& operator=(
+        const safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT();
+    ~safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT();
+    void initialize(const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT const*>(this);
+    }
+};
+struct safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t identifierSize;
+    const uint8_t* pIdentifier{};
+
+    safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(const VkPipelineShaderStageModuleIdentifierCreateInfoEXT* in_struct,
+                                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
+        const safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT& copy_src);
+    safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT& operator=(
+        const safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT& copy_src);
+    safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT();
+    ~safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT();
+    void initialize(const VkPipelineShaderStageModuleIdentifierCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineShaderStageModuleIdentifierCreateInfoEXT* ptr() {
+        return reinterpret_cast<VkPipelineShaderStageModuleIdentifierCreateInfoEXT*>(this);
+    }
+    VkPipelineShaderStageModuleIdentifierCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkPipelineShaderStageModuleIdentifierCreateInfoEXT const*>(this);
+    }
+};
+struct safe_VkShaderModuleIdentifierEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t identifierSize;
+    uint8_t identifier[VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT];
+
+    safe_VkShaderModuleIdentifierEXT(const VkShaderModuleIdentifierEXT* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    safe_VkShaderModuleIdentifierEXT(const safe_VkShaderModuleIdentifierEXT& copy_src);
+    safe_VkShaderModuleIdentifierEXT& operator=(const safe_VkShaderModuleIdentifierEXT& copy_src);
+    safe_VkShaderModuleIdentifierEXT();
+    ~safe_VkShaderModuleIdentifierEXT();
+    void initialize(const VkShaderModuleIdentifierEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkShaderModuleIdentifierEXT* copy_src, PNextCopyState* copy_state = {});
+    VkShaderModuleIdentifierEXT* ptr() { return reinterpret_cast<VkShaderModuleIdentifierEXT*>(this); }
+    VkShaderModuleIdentifierEXT const* ptr() const { return reinterpret_cast<VkShaderModuleIdentifierEXT const*>(this); }
+};
+struct safe_VkPhysicalDeviceOpticalFlowFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 opticalFlow;
+
+    safe_VkPhysicalDeviceOpticalFlowFeaturesNV(const VkPhysicalDeviceOpticalFlowFeaturesNV* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceOpticalFlowFeaturesNV(const safe_VkPhysicalDeviceOpticalFlowFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceOpticalFlowFeaturesNV& operator=(const safe_VkPhysicalDeviceOpticalFlowFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceOpticalFlowFeaturesNV();
+    ~safe_VkPhysicalDeviceOpticalFlowFeaturesNV();
+    void initialize(const VkPhysicalDeviceOpticalFlowFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceOpticalFlowFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceOpticalFlowFeaturesNV* ptr() { return reinterpret_cast<VkPhysicalDeviceOpticalFlowFeaturesNV*>(this); }
+    VkPhysicalDeviceOpticalFlowFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceOpticalFlowFeaturesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceOpticalFlowPropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkOpticalFlowGridSizeFlagsNV supportedOutputGridSizes;
+    VkOpticalFlowGridSizeFlagsNV supportedHintGridSizes;
+    VkBool32 hintSupported;
+    VkBool32 costSupported;
+    VkBool32 bidirectionalFlowSupported;
+    VkBool32 globalFlowSupported;
+    uint32_t minWidth;
+    uint32_t minHeight;
+    uint32_t maxWidth;
+    uint32_t maxHeight;
+    uint32_t maxNumRegionsOfInterest;
+
+    safe_VkPhysicalDeviceOpticalFlowPropertiesNV(const VkPhysicalDeviceOpticalFlowPropertiesNV* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceOpticalFlowPropertiesNV(const safe_VkPhysicalDeviceOpticalFlowPropertiesNV& copy_src);
+    safe_VkPhysicalDeviceOpticalFlowPropertiesNV& operator=(const safe_VkPhysicalDeviceOpticalFlowPropertiesNV& copy_src);
+    safe_VkPhysicalDeviceOpticalFlowPropertiesNV();
+    ~safe_VkPhysicalDeviceOpticalFlowPropertiesNV();
+    void initialize(const VkPhysicalDeviceOpticalFlowPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceOpticalFlowPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceOpticalFlowPropertiesNV* ptr() { return reinterpret_cast<VkPhysicalDeviceOpticalFlowPropertiesNV*>(this); }
+    VkPhysicalDeviceOpticalFlowPropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceOpticalFlowPropertiesNV const*>(this);
+    }
+};
+struct safe_VkOpticalFlowImageFormatInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkOpticalFlowUsageFlagsNV usage;
+
+    safe_VkOpticalFlowImageFormatInfoNV(const VkOpticalFlowImageFormatInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkOpticalFlowImageFormatInfoNV(const safe_VkOpticalFlowImageFormatInfoNV& copy_src);
+    safe_VkOpticalFlowImageFormatInfoNV& operator=(const safe_VkOpticalFlowImageFormatInfoNV& copy_src);
+    safe_VkOpticalFlowImageFormatInfoNV();
+    ~safe_VkOpticalFlowImageFormatInfoNV();
+    void initialize(const VkOpticalFlowImageFormatInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkOpticalFlowImageFormatInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkOpticalFlowImageFormatInfoNV* ptr() { return reinterpret_cast<VkOpticalFlowImageFormatInfoNV*>(this); }
+    VkOpticalFlowImageFormatInfoNV const* ptr() const { return reinterpret_cast<VkOpticalFlowImageFormatInfoNV const*>(this); }
+};
+struct safe_VkOpticalFlowImageFormatPropertiesNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkFormat format;
+
+    safe_VkOpticalFlowImageFormatPropertiesNV(const VkOpticalFlowImageFormatPropertiesNV* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkOpticalFlowImageFormatPropertiesNV(const safe_VkOpticalFlowImageFormatPropertiesNV& copy_src);
+    safe_VkOpticalFlowImageFormatPropertiesNV& operator=(const safe_VkOpticalFlowImageFormatPropertiesNV& copy_src);
+    safe_VkOpticalFlowImageFormatPropertiesNV();
+    ~safe_VkOpticalFlowImageFormatPropertiesNV();
+    void initialize(const VkOpticalFlowImageFormatPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkOpticalFlowImageFormatPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkOpticalFlowImageFormatPropertiesNV* ptr() { return reinterpret_cast<VkOpticalFlowImageFormatPropertiesNV*>(this); }
+    VkOpticalFlowImageFormatPropertiesNV const* ptr() const {
+        return reinterpret_cast<VkOpticalFlowImageFormatPropertiesNV const*>(this);
+    }
+};
+struct safe_VkOpticalFlowSessionCreateInfoNV {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t width;
+    uint32_t height;
+    VkFormat imageFormat;
+    VkFormat flowVectorFormat;
+    VkFormat costFormat;
+    VkOpticalFlowGridSizeFlagsNV outputGridSize;
+    VkOpticalFlowGridSizeFlagsNV hintGridSize;
+    VkOpticalFlowPerformanceLevelNV performanceLevel;
+    VkOpticalFlowSessionCreateFlagsNV flags;
+
+    safe_VkOpticalFlowSessionCreateInfoNV(const VkOpticalFlowSessionCreateInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkOpticalFlowSessionCreateInfoNV(const safe_VkOpticalFlowSessionCreateInfoNV& copy_src);
+    safe_VkOpticalFlowSessionCreateInfoNV& operator=(const safe_VkOpticalFlowSessionCreateInfoNV& copy_src);
+    safe_VkOpticalFlowSessionCreateInfoNV();
+    ~safe_VkOpticalFlowSessionCreateInfoNV();
+    void initialize(const VkOpticalFlowSessionCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkOpticalFlowSessionCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkOpticalFlowSessionCreateInfoNV* ptr() { return reinterpret_cast<VkOpticalFlowSessionCreateInfoNV*>(this); }
+    VkOpticalFlowSessionCreateInfoNV const* ptr() const { return reinterpret_cast<VkOpticalFlowSessionCreateInfoNV const*>(this); }
+};
+struct safe_VkOpticalFlowSessionCreatePrivateDataInfoNV {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t id;
+    uint32_t size;
+    const void* pPrivateData{};
+
+    safe_VkOpticalFlowSessionCreatePrivateDataInfoNV(const VkOpticalFlowSessionCreatePrivateDataInfoNV* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkOpticalFlowSessionCreatePrivateDataInfoNV(const safe_VkOpticalFlowSessionCreatePrivateDataInfoNV& copy_src);
+    safe_VkOpticalFlowSessionCreatePrivateDataInfoNV& operator=(const safe_VkOpticalFlowSessionCreatePrivateDataInfoNV& copy_src);
+    safe_VkOpticalFlowSessionCreatePrivateDataInfoNV();
+    ~safe_VkOpticalFlowSessionCreatePrivateDataInfoNV();
+    void initialize(const VkOpticalFlowSessionCreatePrivateDataInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkOpticalFlowSessionCreatePrivateDataInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkOpticalFlowSessionCreatePrivateDataInfoNV* ptr() {
+        return reinterpret_cast<VkOpticalFlowSessionCreatePrivateDataInfoNV*>(this);
+    }
+    VkOpticalFlowSessionCreatePrivateDataInfoNV const* ptr() const {
+        return reinterpret_cast<VkOpticalFlowSessionCreatePrivateDataInfoNV const*>(this);
+    }
+};
+struct safe_VkOpticalFlowExecuteInfoNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkOpticalFlowExecuteFlagsNV flags;
+    uint32_t regionCount;
+    const VkRect2D* pRegions{};
+
+    safe_VkOpticalFlowExecuteInfoNV(const VkOpticalFlowExecuteInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    safe_VkOpticalFlowExecuteInfoNV(const safe_VkOpticalFlowExecuteInfoNV& copy_src);
+    safe_VkOpticalFlowExecuteInfoNV& operator=(const safe_VkOpticalFlowExecuteInfoNV& copy_src);
+    safe_VkOpticalFlowExecuteInfoNV();
+    ~safe_VkOpticalFlowExecuteInfoNV();
+    void initialize(const VkOpticalFlowExecuteInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkOpticalFlowExecuteInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkOpticalFlowExecuteInfoNV* ptr() { return reinterpret_cast<VkOpticalFlowExecuteInfoNV*>(this); }
+    VkOpticalFlowExecuteInfoNV const* ptr() const { return reinterpret_cast<VkOpticalFlowExecuteInfoNV const*>(this); }
+};
+struct safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 legacyDithering;
+
+    safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT(const VkPhysicalDeviceLegacyDitheringFeaturesEXT* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT(const safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT& operator=(const safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT();
+    ~safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT();
+    void initialize(const VkPhysicalDeviceLegacyDitheringFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceLegacyDitheringFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceLegacyDitheringFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceLegacyDitheringFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceLegacyDitheringFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 pipelineProtectedAccess;
+
+    safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* in_struct,
+                                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
+        const safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT& copy_src);
+    safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT& operator=(
+        const safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT& copy_src);
+    safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT();
+    ~safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT();
+    void initialize(const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePipelineProtectedAccessFeaturesEXT*>(this);
+    }
+    VkPhysicalDevicePipelineProtectedAccessFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePipelineProtectedAccessFeaturesEXT const*>(this);
+    }
+};
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+struct safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 externalFormatResolve;
+
+    safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID(const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID* in_struct,
+                                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID(
+        const safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID& copy_src);
+    safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID& operator=(
+        const safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID& copy_src);
+    safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID();
+    ~safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID();
+    void initialize(const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExternalFormatResolveFeaturesANDROID* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceExternalFormatResolveFeaturesANDROID*>(this);
+    }
+    VkPhysicalDeviceExternalFormatResolveFeaturesANDROID const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExternalFormatResolveFeaturesANDROID const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 nullColorAttachmentWithExternalFormatResolve;
+    VkChromaLocation externalFormatResolveChromaOffsetX;
+    VkChromaLocation externalFormatResolveChromaOffsetY;
+
+    safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID(
+        const VkPhysicalDeviceExternalFormatResolvePropertiesANDROID* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID(
+        const safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID& copy_src);
+    safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID& operator=(
+        const safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID& copy_src);
+    safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID();
+    ~safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID();
+    void initialize(const VkPhysicalDeviceExternalFormatResolvePropertiesANDROID* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExternalFormatResolvePropertiesANDROID* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceExternalFormatResolvePropertiesANDROID*>(this);
+    }
+    VkPhysicalDeviceExternalFormatResolvePropertiesANDROID const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExternalFormatResolvePropertiesANDROID const*>(this);
+    }
+};
+struct safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID {
+    VkStructureType sType;
+    void* pNext{};
+    VkFormat colorAttachmentFormat;
+
+    safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID(
+        const VkAndroidHardwareBufferFormatResolvePropertiesANDROID* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID(
+        const safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID& copy_src);
+    safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID& operator=(
+        const safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID& copy_src);
+    safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID();
+    ~safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID();
+    void initialize(const VkAndroidHardwareBufferFormatResolvePropertiesANDROID* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID* copy_src, PNextCopyState* copy_state = {});
+    VkAndroidHardwareBufferFormatResolvePropertiesANDROID* ptr() {
+        return reinterpret_cast<VkAndroidHardwareBufferFormatResolvePropertiesANDROID*>(this);
+    }
+    VkAndroidHardwareBufferFormatResolvePropertiesANDROID const* ptr() const {
+        return reinterpret_cast<VkAndroidHardwareBufferFormatResolvePropertiesANDROID const*>(this);
+    }
+};
+#endif  // VK_USE_PLATFORM_ANDROID_KHR
+struct safe_VkPhysicalDeviceShaderObjectFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderObject;
+
+    safe_VkPhysicalDeviceShaderObjectFeaturesEXT(const VkPhysicalDeviceShaderObjectFeaturesEXT* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderObjectFeaturesEXT(const safe_VkPhysicalDeviceShaderObjectFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceShaderObjectFeaturesEXT& operator=(const safe_VkPhysicalDeviceShaderObjectFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceShaderObjectFeaturesEXT();
+    ~safe_VkPhysicalDeviceShaderObjectFeaturesEXT();
+    void initialize(const VkPhysicalDeviceShaderObjectFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderObjectFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderObjectFeaturesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceShaderObjectFeaturesEXT*>(this); }
+    VkPhysicalDeviceShaderObjectFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderObjectFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceShaderObjectPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint8_t shaderBinaryUUID[VK_UUID_SIZE];
+    uint32_t shaderBinaryVersion;
+
+    safe_VkPhysicalDeviceShaderObjectPropertiesEXT(const VkPhysicalDeviceShaderObjectPropertiesEXT* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderObjectPropertiesEXT(const safe_VkPhysicalDeviceShaderObjectPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceShaderObjectPropertiesEXT& operator=(const safe_VkPhysicalDeviceShaderObjectPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceShaderObjectPropertiesEXT();
+    ~safe_VkPhysicalDeviceShaderObjectPropertiesEXT();
+    void initialize(const VkPhysicalDeviceShaderObjectPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderObjectPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderObjectPropertiesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceShaderObjectPropertiesEXT*>(this); }
+    VkPhysicalDeviceShaderObjectPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderObjectPropertiesEXT const*>(this);
+    }
+};
+struct safe_VkShaderCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkShaderCreateFlagsEXT flags;
+    VkShaderStageFlagBits stage;
+    VkShaderStageFlags nextStage;
+    VkShaderCodeTypeEXT codeType;
+    size_t codeSize;
+    const void* pCode{};
+    const char* pName{};
+    uint32_t setLayoutCount;
+    VkDescriptorSetLayout* pSetLayouts{};
+    uint32_t pushConstantRangeCount;
+    const VkPushConstantRange* pPushConstantRanges{};
+    safe_VkSpecializationInfo* pSpecializationInfo{};
+
+    safe_VkShaderCreateInfoEXT(const VkShaderCreateInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkShaderCreateInfoEXT(const safe_VkShaderCreateInfoEXT& copy_src);
+    safe_VkShaderCreateInfoEXT& operator=(const safe_VkShaderCreateInfoEXT& copy_src);
+    safe_VkShaderCreateInfoEXT();
+    ~safe_VkShaderCreateInfoEXT();
+    void initialize(const VkShaderCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkShaderCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkShaderCreateInfoEXT* ptr() { return reinterpret_cast<VkShaderCreateInfoEXT*>(this); }
+    VkShaderCreateInfoEXT const* ptr() const { return reinterpret_cast<VkShaderCreateInfoEXT const*>(this); }
+};
+struct safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 tileProperties;
+
+    safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM(const VkPhysicalDeviceTilePropertiesFeaturesQCOM* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM(const safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM& copy_src);
+    safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM& operator=(const safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM& copy_src);
+    safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM();
+    ~safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM();
+    void initialize(const VkPhysicalDeviceTilePropertiesFeaturesQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceTilePropertiesFeaturesQCOM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceTilePropertiesFeaturesQCOM*>(this);
+    }
+    VkPhysicalDeviceTilePropertiesFeaturesQCOM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceTilePropertiesFeaturesQCOM const*>(this);
+    }
+};
+struct safe_VkTilePropertiesQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkExtent3D tileSize;
+    VkExtent2D apronSize;
+    VkOffset2D origin;
+
+    safe_VkTilePropertiesQCOM(const VkTilePropertiesQCOM* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkTilePropertiesQCOM(const safe_VkTilePropertiesQCOM& copy_src);
+    safe_VkTilePropertiesQCOM& operator=(const safe_VkTilePropertiesQCOM& copy_src);
+    safe_VkTilePropertiesQCOM();
+    ~safe_VkTilePropertiesQCOM();
+    void initialize(const VkTilePropertiesQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkTilePropertiesQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkTilePropertiesQCOM* ptr() { return reinterpret_cast<VkTilePropertiesQCOM*>(this); }
+    VkTilePropertiesQCOM const* ptr() const { return reinterpret_cast<VkTilePropertiesQCOM const*>(this); }
+};
+struct safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 amigoProfiling;
+
+    safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC(const VkPhysicalDeviceAmigoProfilingFeaturesSEC* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC(const safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC& copy_src);
+    safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC& operator=(const safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC& copy_src);
+    safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC();
+    ~safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC();
+    void initialize(const VkPhysicalDeviceAmigoProfilingFeaturesSEC* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceAmigoProfilingFeaturesSEC* ptr() { return reinterpret_cast<VkPhysicalDeviceAmigoProfilingFeaturesSEC*>(this); }
+    VkPhysicalDeviceAmigoProfilingFeaturesSEC const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceAmigoProfilingFeaturesSEC const*>(this);
+    }
+};
+struct safe_VkAmigoProfilingSubmitInfoSEC {
+    VkStructureType sType;
+    const void* pNext{};
+    uint64_t firstDrawTimestamp;
+    uint64_t swapBufferTimestamp;
+
+    safe_VkAmigoProfilingSubmitInfoSEC(const VkAmigoProfilingSubmitInfoSEC* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    safe_VkAmigoProfilingSubmitInfoSEC(const safe_VkAmigoProfilingSubmitInfoSEC& copy_src);
+    safe_VkAmigoProfilingSubmitInfoSEC& operator=(const safe_VkAmigoProfilingSubmitInfoSEC& copy_src);
+    safe_VkAmigoProfilingSubmitInfoSEC();
+    ~safe_VkAmigoProfilingSubmitInfoSEC();
+    void initialize(const VkAmigoProfilingSubmitInfoSEC* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAmigoProfilingSubmitInfoSEC* copy_src, PNextCopyState* copy_state = {});
+    VkAmigoProfilingSubmitInfoSEC* ptr() { return reinterpret_cast<VkAmigoProfilingSubmitInfoSEC*>(this); }
+    VkAmigoProfilingSubmitInfoSEC const* ptr() const { return reinterpret_cast<VkAmigoProfilingSubmitInfoSEC const*>(this); }
+};
+struct safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 multiviewPerViewViewports;
+
+    safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
+        const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
+        const safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM& copy_src);
+    safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM& operator=(
+        const safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM& copy_src);
+    safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM();
+    ~safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM();
+    void initialize(const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM*>(this);
+    }
+    VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkRayTracingInvocationReorderModeNV rayTracingInvocationReorderReorderingHint;
+
+    safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
+        const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
+        const safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV& copy_src);
+    safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV& operator=(
+        const safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV& copy_src);
+    safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV();
+    ~safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV();
+    void initialize(const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV*>(this);
+    }
+    VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 rayTracingInvocationReorder;
+
+    safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
+        const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
+        const safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV& operator=(
+        const safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV();
+    ~safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV();
+    void initialize(const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 extendedSparseAddressSpace;
+
+    safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV(const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* in_struct,
+                                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV(
+        const safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV& operator=(
+        const safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV();
+    ~safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV();
+    void initialize(const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceSize extendedSparseAddressSpaceSize;
+    VkImageUsageFlags extendedSparseImageUsageFlags;
+    VkBufferUsageFlags extendedSparseBufferUsageFlags;
+
+    safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV(
+        const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV(
+        const safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV& copy_src);
+    safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV& operator=(
+        const safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV& copy_src);
+    safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV();
+    ~safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV();
+    void initialize(const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV*>(this);
+    }
+    VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV const*>(this);
+    }
+};
+struct safe_VkLayerSettingEXT {
+    const char* pLayerName{};
+    const char* pSettingName{};
+    VkLayerSettingTypeEXT type;
+    uint32_t valueCount;
+    const void* pValues{};
+
+    safe_VkLayerSettingEXT(const VkLayerSettingEXT* in_struct, PNextCopyState* copy_state = {});
+    safe_VkLayerSettingEXT(const safe_VkLayerSettingEXT& copy_src);
+    safe_VkLayerSettingEXT& operator=(const safe_VkLayerSettingEXT& copy_src);
+    safe_VkLayerSettingEXT();
+    ~safe_VkLayerSettingEXT();
+    void initialize(const VkLayerSettingEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkLayerSettingEXT* copy_src, PNextCopyState* copy_state = {});
+    VkLayerSettingEXT* ptr() { return reinterpret_cast<VkLayerSettingEXT*>(this); }
+    VkLayerSettingEXT const* ptr() const { return reinterpret_cast<VkLayerSettingEXT const*>(this); }
+};
+struct safe_VkLayerSettingsCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t settingCount;
+    safe_VkLayerSettingEXT* pSettings{};
+
+    safe_VkLayerSettingsCreateInfoEXT(const VkLayerSettingsCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    safe_VkLayerSettingsCreateInfoEXT(const safe_VkLayerSettingsCreateInfoEXT& copy_src);
+    safe_VkLayerSettingsCreateInfoEXT& operator=(const safe_VkLayerSettingsCreateInfoEXT& copy_src);
+    safe_VkLayerSettingsCreateInfoEXT();
+    ~safe_VkLayerSettingsCreateInfoEXT();
+    void initialize(const VkLayerSettingsCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkLayerSettingsCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkLayerSettingsCreateInfoEXT* ptr() { return reinterpret_cast<VkLayerSettingsCreateInfoEXT*>(this); }
+    VkLayerSettingsCreateInfoEXT const* ptr() const { return reinterpret_cast<VkLayerSettingsCreateInfoEXT const*>(this); }
+};
+struct safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderCoreBuiltins;
+
+    safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(const safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM& copy_src);
+    safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM& operator=(
+        const safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM& copy_src);
+    safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM();
+    ~safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM();
+    void initialize(const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM*>(this);
+    }
+    VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM {
+    VkStructureType sType;
+    void* pNext{};
+    uint64_t shaderCoreMask;
+    uint32_t shaderCoreCount;
+    uint32_t shaderWarpsPerCore;
+
+    safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(const safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM& copy_src);
+    safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM& operator=(
+        const safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM& copy_src);
+    safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM();
+    ~safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM();
+    void initialize(const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM*>(this);
+    }
+    VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM const*>(this);
+    }
+};
+struct safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 pipelineLibraryGroupHandles;
+
+    safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
+        const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
+        const safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT& copy_src);
+    safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT& operator=(
+        const safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT& copy_src);
+    safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT();
+    ~safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT();
+    void initialize(const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT*>(this);
+    }
+    VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 dynamicRenderingUnusedAttachments;
+
+    safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(
+        const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(
+        const safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT();
+    ~safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT();
+    void initialize(const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* copy_src,
+                    PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkLatencySleepModeInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 lowLatencyMode;
+    VkBool32 lowLatencyBoost;
+    uint32_t minimumIntervalUs;
+
+    safe_VkLatencySleepModeInfoNV(const VkLatencySleepModeInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    safe_VkLatencySleepModeInfoNV(const safe_VkLatencySleepModeInfoNV& copy_src);
+    safe_VkLatencySleepModeInfoNV& operator=(const safe_VkLatencySleepModeInfoNV& copy_src);
+    safe_VkLatencySleepModeInfoNV();
+    ~safe_VkLatencySleepModeInfoNV();
+    void initialize(const VkLatencySleepModeInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkLatencySleepModeInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkLatencySleepModeInfoNV* ptr() { return reinterpret_cast<VkLatencySleepModeInfoNV*>(this); }
+    VkLatencySleepModeInfoNV const* ptr() const { return reinterpret_cast<VkLatencySleepModeInfoNV const*>(this); }
+};
+struct safe_VkLatencySleepInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkSemaphore signalSemaphore;
+    uint64_t value;
+
+    safe_VkLatencySleepInfoNV(const VkLatencySleepInfoNV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkLatencySleepInfoNV(const safe_VkLatencySleepInfoNV& copy_src);
+    safe_VkLatencySleepInfoNV& operator=(const safe_VkLatencySleepInfoNV& copy_src);
+    safe_VkLatencySleepInfoNV();
+    ~safe_VkLatencySleepInfoNV();
+    void initialize(const VkLatencySleepInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkLatencySleepInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkLatencySleepInfoNV* ptr() { return reinterpret_cast<VkLatencySleepInfoNV*>(this); }
+    VkLatencySleepInfoNV const* ptr() const { return reinterpret_cast<VkLatencySleepInfoNV const*>(this); }
+};
+struct safe_VkSetLatencyMarkerInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    uint64_t presentID;
+    VkLatencyMarkerNV marker;
+
+    safe_VkSetLatencyMarkerInfoNV(const VkSetLatencyMarkerInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    safe_VkSetLatencyMarkerInfoNV(const safe_VkSetLatencyMarkerInfoNV& copy_src);
+    safe_VkSetLatencyMarkerInfoNV& operator=(const safe_VkSetLatencyMarkerInfoNV& copy_src);
+    safe_VkSetLatencyMarkerInfoNV();
+    ~safe_VkSetLatencyMarkerInfoNV();
+    void initialize(const VkSetLatencyMarkerInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSetLatencyMarkerInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkSetLatencyMarkerInfoNV* ptr() { return reinterpret_cast<VkSetLatencyMarkerInfoNV*>(this); }
+    VkSetLatencyMarkerInfoNV const* ptr() const { return reinterpret_cast<VkSetLatencyMarkerInfoNV const*>(this); }
+};
+struct safe_VkLatencyTimingsFrameReportNV {
+    VkStructureType sType;
+    const void* pNext{};
+    uint64_t presentID;
+    uint64_t inputSampleTimeUs;
+    uint64_t simStartTimeUs;
+    uint64_t simEndTimeUs;
+    uint64_t renderSubmitStartTimeUs;
+    uint64_t renderSubmitEndTimeUs;
+    uint64_t presentStartTimeUs;
+    uint64_t presentEndTimeUs;
+    uint64_t driverStartTimeUs;
+    uint64_t driverEndTimeUs;
+    uint64_t osRenderQueueStartTimeUs;
+    uint64_t osRenderQueueEndTimeUs;
+    uint64_t gpuRenderStartTimeUs;
+    uint64_t gpuRenderEndTimeUs;
+
+    safe_VkLatencyTimingsFrameReportNV(const VkLatencyTimingsFrameReportNV* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    safe_VkLatencyTimingsFrameReportNV(const safe_VkLatencyTimingsFrameReportNV& copy_src);
+    safe_VkLatencyTimingsFrameReportNV& operator=(const safe_VkLatencyTimingsFrameReportNV& copy_src);
+    safe_VkLatencyTimingsFrameReportNV();
+    ~safe_VkLatencyTimingsFrameReportNV();
+    void initialize(const VkLatencyTimingsFrameReportNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkLatencyTimingsFrameReportNV* copy_src, PNextCopyState* copy_state = {});
+    VkLatencyTimingsFrameReportNV* ptr() { return reinterpret_cast<VkLatencyTimingsFrameReportNV*>(this); }
+    VkLatencyTimingsFrameReportNV const* ptr() const { return reinterpret_cast<VkLatencyTimingsFrameReportNV const*>(this); }
+};
+struct safe_VkGetLatencyMarkerInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t timingCount;
+    safe_VkLatencyTimingsFrameReportNV* pTimings{};
+
+    safe_VkGetLatencyMarkerInfoNV(const VkGetLatencyMarkerInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    safe_VkGetLatencyMarkerInfoNV(const safe_VkGetLatencyMarkerInfoNV& copy_src);
+    safe_VkGetLatencyMarkerInfoNV& operator=(const safe_VkGetLatencyMarkerInfoNV& copy_src);
+    safe_VkGetLatencyMarkerInfoNV();
+    ~safe_VkGetLatencyMarkerInfoNV();
+    void initialize(const VkGetLatencyMarkerInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkGetLatencyMarkerInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkGetLatencyMarkerInfoNV* ptr() { return reinterpret_cast<VkGetLatencyMarkerInfoNV*>(this); }
+    VkGetLatencyMarkerInfoNV const* ptr() const { return reinterpret_cast<VkGetLatencyMarkerInfoNV const*>(this); }
+};
+struct safe_VkLatencySubmissionPresentIdNV {
+    VkStructureType sType;
+    const void* pNext{};
+    uint64_t presentID;
+
+    safe_VkLatencySubmissionPresentIdNV(const VkLatencySubmissionPresentIdNV* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkLatencySubmissionPresentIdNV(const safe_VkLatencySubmissionPresentIdNV& copy_src);
+    safe_VkLatencySubmissionPresentIdNV& operator=(const safe_VkLatencySubmissionPresentIdNV& copy_src);
+    safe_VkLatencySubmissionPresentIdNV();
+    ~safe_VkLatencySubmissionPresentIdNV();
+    void initialize(const VkLatencySubmissionPresentIdNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkLatencySubmissionPresentIdNV* copy_src, PNextCopyState* copy_state = {});
+    VkLatencySubmissionPresentIdNV* ptr() { return reinterpret_cast<VkLatencySubmissionPresentIdNV*>(this); }
+    VkLatencySubmissionPresentIdNV const* ptr() const { return reinterpret_cast<VkLatencySubmissionPresentIdNV const*>(this); }
+};
+struct safe_VkSwapchainLatencyCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 latencyModeEnable;
+
+    safe_VkSwapchainLatencyCreateInfoNV(const VkSwapchainLatencyCreateInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkSwapchainLatencyCreateInfoNV(const safe_VkSwapchainLatencyCreateInfoNV& copy_src);
+    safe_VkSwapchainLatencyCreateInfoNV& operator=(const safe_VkSwapchainLatencyCreateInfoNV& copy_src);
+    safe_VkSwapchainLatencyCreateInfoNV();
+    ~safe_VkSwapchainLatencyCreateInfoNV();
+    void initialize(const VkSwapchainLatencyCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSwapchainLatencyCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkSwapchainLatencyCreateInfoNV* ptr() { return reinterpret_cast<VkSwapchainLatencyCreateInfoNV*>(this); }
+    VkSwapchainLatencyCreateInfoNV const* ptr() const { return reinterpret_cast<VkSwapchainLatencyCreateInfoNV const*>(this); }
+};
+struct safe_VkOutOfBandQueueTypeInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkOutOfBandQueueTypeNV queueType;
+
+    safe_VkOutOfBandQueueTypeInfoNV(const VkOutOfBandQueueTypeInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    safe_VkOutOfBandQueueTypeInfoNV(const safe_VkOutOfBandQueueTypeInfoNV& copy_src);
+    safe_VkOutOfBandQueueTypeInfoNV& operator=(const safe_VkOutOfBandQueueTypeInfoNV& copy_src);
+    safe_VkOutOfBandQueueTypeInfoNV();
+    ~safe_VkOutOfBandQueueTypeInfoNV();
+    void initialize(const VkOutOfBandQueueTypeInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkOutOfBandQueueTypeInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkOutOfBandQueueTypeInfoNV* ptr() { return reinterpret_cast<VkOutOfBandQueueTypeInfoNV*>(this); }
+    VkOutOfBandQueueTypeInfoNV const* ptr() const { return reinterpret_cast<VkOutOfBandQueueTypeInfoNV const*>(this); }
+};
+struct safe_VkLatencySurfaceCapabilitiesNV {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t presentModeCount;
+    VkPresentModeKHR* pPresentModes{};
+
+    safe_VkLatencySurfaceCapabilitiesNV(const VkLatencySurfaceCapabilitiesNV* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkLatencySurfaceCapabilitiesNV(const safe_VkLatencySurfaceCapabilitiesNV& copy_src);
+    safe_VkLatencySurfaceCapabilitiesNV& operator=(const safe_VkLatencySurfaceCapabilitiesNV& copy_src);
+    safe_VkLatencySurfaceCapabilitiesNV();
+    ~safe_VkLatencySurfaceCapabilitiesNV();
+    void initialize(const VkLatencySurfaceCapabilitiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkLatencySurfaceCapabilitiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkLatencySurfaceCapabilitiesNV* ptr() { return reinterpret_cast<VkLatencySurfaceCapabilitiesNV*>(this); }
+    VkLatencySurfaceCapabilitiesNV const* ptr() const { return reinterpret_cast<VkLatencySurfaceCapabilitiesNV const*>(this); }
+};
+struct safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 multiviewPerViewRenderAreas;
+
+    safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
+        const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
+        const safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM& copy_src);
+    safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM& operator=(
+        const safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM& copy_src);
+    safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM();
+    ~safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM();
+    void initialize(const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM*>(this);
+    }
+    VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const*>(this);
+    }
+};
+struct safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t perViewRenderAreaCount;
+    const VkRect2D* pPerViewRenderAreas{};
+
+    safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* in_struct,
+                                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
+        const safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM& copy_src);
+    safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM& operator=(
+        const safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM& copy_src);
+    safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM();
+    ~safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM();
+    void initialize(const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* ptr() {
+        return reinterpret_cast<VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM*>(this);
+    }
+    VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const* ptr() const {
+        return reinterpret_cast<VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const*>(this);
+    }
+};
+struct safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 perStageDescriptorSet;
+    VkBool32 dynamicPipelineLayout;
+
+    safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV(const VkPhysicalDevicePerStageDescriptorSetFeaturesNV* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV(const safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV& copy_src);
+    safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV& operator=(
+        const safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV& copy_src);
+    safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV();
+    ~safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV();
+    void initialize(const VkPhysicalDevicePerStageDescriptorSetFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePerStageDescriptorSetFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePerStageDescriptorSetFeaturesNV*>(this);
+    }
+    VkPhysicalDevicePerStageDescriptorSetFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePerStageDescriptorSetFeaturesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 textureBlockMatch2;
+
+    safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM(const VkPhysicalDeviceImageProcessing2FeaturesQCOM* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM(const safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM& copy_src);
+    safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM& operator=(const safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM& copy_src);
+    safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM();
+    ~safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM();
+    void initialize(const VkPhysicalDeviceImageProcessing2FeaturesQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceImageProcessing2FeaturesQCOM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceImageProcessing2FeaturesQCOM*>(this);
+    }
+    VkPhysicalDeviceImageProcessing2FeaturesQCOM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceImageProcessing2FeaturesQCOM const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkExtent2D maxBlockMatchWindow;
+
+    safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM(const VkPhysicalDeviceImageProcessing2PropertiesQCOM* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM(const safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM& copy_src);
+    safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM& operator=(
+        const safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM& copy_src);
+    safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM();
+    ~safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM();
+    void initialize(const VkPhysicalDeviceImageProcessing2PropertiesQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceImageProcessing2PropertiesQCOM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceImageProcessing2PropertiesQCOM*>(this);
+    }
+    VkPhysicalDeviceImageProcessing2PropertiesQCOM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceImageProcessing2PropertiesQCOM const*>(this);
+    }
+};
+struct safe_VkSamplerBlockMatchWindowCreateInfoQCOM {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExtent2D windowExtent;
+    VkBlockMatchWindowCompareModeQCOM windowCompareMode;
+
+    safe_VkSamplerBlockMatchWindowCreateInfoQCOM(const VkSamplerBlockMatchWindowCreateInfoQCOM* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSamplerBlockMatchWindowCreateInfoQCOM(const safe_VkSamplerBlockMatchWindowCreateInfoQCOM& copy_src);
+    safe_VkSamplerBlockMatchWindowCreateInfoQCOM& operator=(const safe_VkSamplerBlockMatchWindowCreateInfoQCOM& copy_src);
+    safe_VkSamplerBlockMatchWindowCreateInfoQCOM();
+    ~safe_VkSamplerBlockMatchWindowCreateInfoQCOM();
+    void initialize(const VkSamplerBlockMatchWindowCreateInfoQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSamplerBlockMatchWindowCreateInfoQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkSamplerBlockMatchWindowCreateInfoQCOM* ptr() { return reinterpret_cast<VkSamplerBlockMatchWindowCreateInfoQCOM*>(this); }
+    VkSamplerBlockMatchWindowCreateInfoQCOM const* ptr() const {
+        return reinterpret_cast<VkSamplerBlockMatchWindowCreateInfoQCOM const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 selectableCubicWeights;
+
+    safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM(const VkPhysicalDeviceCubicWeightsFeaturesQCOM* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM(const safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM& copy_src);
+    safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM& operator=(const safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM& copy_src);
+    safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM();
+    ~safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM();
+    void initialize(const VkPhysicalDeviceCubicWeightsFeaturesQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCubicWeightsFeaturesQCOM* ptr() { return reinterpret_cast<VkPhysicalDeviceCubicWeightsFeaturesQCOM*>(this); }
+    VkPhysicalDeviceCubicWeightsFeaturesQCOM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCubicWeightsFeaturesQCOM const*>(this);
+    }
+};
+struct safe_VkSamplerCubicWeightsCreateInfoQCOM {
+    VkStructureType sType;
+    const void* pNext{};
+    VkCubicFilterWeightsQCOM cubicWeights;
+
+    safe_VkSamplerCubicWeightsCreateInfoQCOM(const VkSamplerCubicWeightsCreateInfoQCOM* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkSamplerCubicWeightsCreateInfoQCOM(const safe_VkSamplerCubicWeightsCreateInfoQCOM& copy_src);
+    safe_VkSamplerCubicWeightsCreateInfoQCOM& operator=(const safe_VkSamplerCubicWeightsCreateInfoQCOM& copy_src);
+    safe_VkSamplerCubicWeightsCreateInfoQCOM();
+    ~safe_VkSamplerCubicWeightsCreateInfoQCOM();
+    void initialize(const VkSamplerCubicWeightsCreateInfoQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSamplerCubicWeightsCreateInfoQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkSamplerCubicWeightsCreateInfoQCOM* ptr() { return reinterpret_cast<VkSamplerCubicWeightsCreateInfoQCOM*>(this); }
+    VkSamplerCubicWeightsCreateInfoQCOM const* ptr() const {
+        return reinterpret_cast<VkSamplerCubicWeightsCreateInfoQCOM const*>(this);
+    }
+};
+struct safe_VkBlitImageCubicWeightsInfoQCOM {
+    VkStructureType sType;
+    const void* pNext{};
+    VkCubicFilterWeightsQCOM cubicWeights;
+
+    safe_VkBlitImageCubicWeightsInfoQCOM(const VkBlitImageCubicWeightsInfoQCOM* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkBlitImageCubicWeightsInfoQCOM(const safe_VkBlitImageCubicWeightsInfoQCOM& copy_src);
+    safe_VkBlitImageCubicWeightsInfoQCOM& operator=(const safe_VkBlitImageCubicWeightsInfoQCOM& copy_src);
+    safe_VkBlitImageCubicWeightsInfoQCOM();
+    ~safe_VkBlitImageCubicWeightsInfoQCOM();
+    void initialize(const VkBlitImageCubicWeightsInfoQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBlitImageCubicWeightsInfoQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkBlitImageCubicWeightsInfoQCOM* ptr() { return reinterpret_cast<VkBlitImageCubicWeightsInfoQCOM*>(this); }
+    VkBlitImageCubicWeightsInfoQCOM const* ptr() const { return reinterpret_cast<VkBlitImageCubicWeightsInfoQCOM const*>(this); }
+};
+struct safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 ycbcrDegamma;
+
+    safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM(const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM(const safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM& copy_src);
+    safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM& operator=(const safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM& copy_src);
+    safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM();
+    ~safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM();
+    void initialize(const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceYcbcrDegammaFeaturesQCOM* ptr() { return reinterpret_cast<VkPhysicalDeviceYcbcrDegammaFeaturesQCOM*>(this); }
+    VkPhysicalDeviceYcbcrDegammaFeaturesQCOM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceYcbcrDegammaFeaturesQCOM const*>(this);
+    }
+};
+struct safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 enableYDegamma;
+    VkBool32 enableCbCrDegamma;
+
+    safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM(const VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM* in_struct,
+                                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM(
+        const safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM& copy_src);
+    safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM& operator=(
+        const safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM& copy_src);
+    safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM();
+    ~safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM();
+    void initialize(const VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM* ptr() {
+        return reinterpret_cast<VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM*>(this);
+    }
+    VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const* ptr() const {
+        return reinterpret_cast<VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceCubicClampFeaturesQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 cubicRangeClamp;
+
+    safe_VkPhysicalDeviceCubicClampFeaturesQCOM(const VkPhysicalDeviceCubicClampFeaturesQCOM* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceCubicClampFeaturesQCOM(const safe_VkPhysicalDeviceCubicClampFeaturesQCOM& copy_src);
+    safe_VkPhysicalDeviceCubicClampFeaturesQCOM& operator=(const safe_VkPhysicalDeviceCubicClampFeaturesQCOM& copy_src);
+    safe_VkPhysicalDeviceCubicClampFeaturesQCOM();
+    ~safe_VkPhysicalDeviceCubicClampFeaturesQCOM();
+    void initialize(const VkPhysicalDeviceCubicClampFeaturesQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceCubicClampFeaturesQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCubicClampFeaturesQCOM* ptr() { return reinterpret_cast<VkPhysicalDeviceCubicClampFeaturesQCOM*>(this); }
+    VkPhysicalDeviceCubicClampFeaturesQCOM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCubicClampFeaturesQCOM const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 attachmentFeedbackLoopDynamicState;
+
+    safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+        const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+        const safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT();
+    ~safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT();
+    void initialize(const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* in_struct,
+                    PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* copy_src,
+                    PNextCopyState* copy_state = {});
+    VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT const*>(this);
+    }
+};
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+struct safe_VkScreenBufferPropertiesQNX {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceSize allocationSize;
+    uint32_t memoryTypeBits;
+
+    safe_VkScreenBufferPropertiesQNX(const VkScreenBufferPropertiesQNX* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    safe_VkScreenBufferPropertiesQNX(const safe_VkScreenBufferPropertiesQNX& copy_src);
+    safe_VkScreenBufferPropertiesQNX& operator=(const safe_VkScreenBufferPropertiesQNX& copy_src);
+    safe_VkScreenBufferPropertiesQNX();
+    ~safe_VkScreenBufferPropertiesQNX();
+    void initialize(const VkScreenBufferPropertiesQNX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkScreenBufferPropertiesQNX* copy_src, PNextCopyState* copy_state = {});
+    VkScreenBufferPropertiesQNX* ptr() { return reinterpret_cast<VkScreenBufferPropertiesQNX*>(this); }
+    VkScreenBufferPropertiesQNX const* ptr() const { return reinterpret_cast<VkScreenBufferPropertiesQNX const*>(this); }
+};
+struct safe_VkScreenBufferFormatPropertiesQNX {
+    VkStructureType sType;
+    void* pNext{};
+    VkFormat format;
+    uint64_t externalFormat;
+    uint64_t screenUsage;
+    VkFormatFeatureFlags formatFeatures;
+    VkComponentMapping samplerYcbcrConversionComponents;
+    VkSamplerYcbcrModelConversion suggestedYcbcrModel;
+    VkSamplerYcbcrRange suggestedYcbcrRange;
+    VkChromaLocation suggestedXChromaOffset;
+    VkChromaLocation suggestedYChromaOffset;
+
+    safe_VkScreenBufferFormatPropertiesQNX(const VkScreenBufferFormatPropertiesQNX* in_struct, PNextCopyState* copy_state = {},
+                                           bool copy_pnext = true);
+    safe_VkScreenBufferFormatPropertiesQNX(const safe_VkScreenBufferFormatPropertiesQNX& copy_src);
+    safe_VkScreenBufferFormatPropertiesQNX& operator=(const safe_VkScreenBufferFormatPropertiesQNX& copy_src);
+    safe_VkScreenBufferFormatPropertiesQNX();
+    ~safe_VkScreenBufferFormatPropertiesQNX();
+    void initialize(const VkScreenBufferFormatPropertiesQNX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkScreenBufferFormatPropertiesQNX* copy_src, PNextCopyState* copy_state = {});
+    VkScreenBufferFormatPropertiesQNX* ptr() { return reinterpret_cast<VkScreenBufferFormatPropertiesQNX*>(this); }
+    VkScreenBufferFormatPropertiesQNX const* ptr() const {
+        return reinterpret_cast<VkScreenBufferFormatPropertiesQNX const*>(this);
+    }
+};
+struct safe_VkImportScreenBufferInfoQNX {
+    VkStructureType sType;
+    const void* pNext{};
+    struct _screen_buffer* buffer{};
+
+    safe_VkImportScreenBufferInfoQNX(const VkImportScreenBufferInfoQNX* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    safe_VkImportScreenBufferInfoQNX(const safe_VkImportScreenBufferInfoQNX& copy_src);
+    safe_VkImportScreenBufferInfoQNX& operator=(const safe_VkImportScreenBufferInfoQNX& copy_src);
+    safe_VkImportScreenBufferInfoQNX();
+    ~safe_VkImportScreenBufferInfoQNX();
+    void initialize(const VkImportScreenBufferInfoQNX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImportScreenBufferInfoQNX* copy_src, PNextCopyState* copy_state = {});
+    VkImportScreenBufferInfoQNX* ptr() { return reinterpret_cast<VkImportScreenBufferInfoQNX*>(this); }
+    VkImportScreenBufferInfoQNX const* ptr() const { return reinterpret_cast<VkImportScreenBufferInfoQNX const*>(this); }
+};
+struct safe_VkExternalFormatQNX {
+    VkStructureType sType;
+    void* pNext{};
+    uint64_t externalFormat;
+
+    safe_VkExternalFormatQNX(const VkExternalFormatQNX* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkExternalFormatQNX(const safe_VkExternalFormatQNX& copy_src);
+    safe_VkExternalFormatQNX& operator=(const safe_VkExternalFormatQNX& copy_src);
+    safe_VkExternalFormatQNX();
+    ~safe_VkExternalFormatQNX();
+    void initialize(const VkExternalFormatQNX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExternalFormatQNX* copy_src, PNextCopyState* copy_state = {});
+    VkExternalFormatQNX* ptr() { return reinterpret_cast<VkExternalFormatQNX*>(this); }
+    VkExternalFormatQNX const* ptr() const { return reinterpret_cast<VkExternalFormatQNX const*>(this); }
+};
+struct safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 screenBufferImport;
+
+    safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX(
+        const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX(
+        const safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX& copy_src);
+    safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX& operator=(
+        const safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX& copy_src);
+    safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX();
+    ~safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX();
+    void initialize(const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX*>(this);
+    }
+    VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX const*>(this);
+    }
+};
+#endif  // VK_USE_PLATFORM_SCREEN_QNX
+struct safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT {
+    VkStructureType sType;
+    void* pNext{};
+    VkLayeredDriverUnderlyingApiMSFT underlyingAPI;
+
+    safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT(const VkPhysicalDeviceLayeredDriverPropertiesMSFT* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT(const safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT& copy_src);
+    safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT& operator=(const safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT& copy_src);
+    safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT();
+    ~safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT();
+    void initialize(const VkPhysicalDeviceLayeredDriverPropertiesMSFT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceLayeredDriverPropertiesMSFT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceLayeredDriverPropertiesMSFT*>(this);
+    }
+    VkPhysicalDeviceLayeredDriverPropertiesMSFT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceLayeredDriverPropertiesMSFT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 descriptorPoolOverallocation;
+
+    safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV(
+        const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV(
+        const safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV& operator=(
+        const safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV();
+    ~safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV();
+    void initialize(const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceRawAccessChainsFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderRawAccessChains;
+
+    safe_VkPhysicalDeviceRawAccessChainsFeaturesNV(const VkPhysicalDeviceRawAccessChainsFeaturesNV* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceRawAccessChainsFeaturesNV(const safe_VkPhysicalDeviceRawAccessChainsFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceRawAccessChainsFeaturesNV& operator=(const safe_VkPhysicalDeviceRawAccessChainsFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceRawAccessChainsFeaturesNV();
+    ~safe_VkPhysicalDeviceRawAccessChainsFeaturesNV();
+    void initialize(const VkPhysicalDeviceRawAccessChainsFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceRawAccessChainsFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRawAccessChainsFeaturesNV* ptr() { return reinterpret_cast<VkPhysicalDeviceRawAccessChainsFeaturesNV*>(this); }
+    VkPhysicalDeviceRawAccessChainsFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRawAccessChainsFeaturesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderFloat16VectorAtomics;
+
+    safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV(const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* in_struct,
+                                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV(
+        const safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV& operator=(
+        const safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV();
+    ~safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV();
+    void initialize(const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceRayTracingValidationFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 rayTracingValidation;
+
+    safe_VkPhysicalDeviceRayTracingValidationFeaturesNV(const VkPhysicalDeviceRayTracingValidationFeaturesNV* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceRayTracingValidationFeaturesNV(const safe_VkPhysicalDeviceRayTracingValidationFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceRayTracingValidationFeaturesNV& operator=(
+        const safe_VkPhysicalDeviceRayTracingValidationFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceRayTracingValidationFeaturesNV();
+    ~safe_VkPhysicalDeviceRayTracingValidationFeaturesNV();
+    void initialize(const VkPhysicalDeviceRayTracingValidationFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceRayTracingValidationFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRayTracingValidationFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingValidationFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceRayTracingValidationFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingValidationFeaturesNV const*>(this);
+    }
+};
+struct safe_VkAccelerationStructureGeometryTrianglesDataKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkFormat vertexFormat;
+    safe_VkDeviceOrHostAddressConstKHR vertexData;
+    VkDeviceSize vertexStride;
+    uint32_t maxVertex;
+    VkIndexType indexType;
+    safe_VkDeviceOrHostAddressConstKHR indexData;
+    safe_VkDeviceOrHostAddressConstKHR transformData;
+
+    safe_VkAccelerationStructureGeometryTrianglesDataKHR(const VkAccelerationStructureGeometryTrianglesDataKHR* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkAccelerationStructureGeometryTrianglesDataKHR(const safe_VkAccelerationStructureGeometryTrianglesDataKHR& copy_src);
+    safe_VkAccelerationStructureGeometryTrianglesDataKHR& operator=(
+        const safe_VkAccelerationStructureGeometryTrianglesDataKHR& copy_src);
+    safe_VkAccelerationStructureGeometryTrianglesDataKHR();
+    ~safe_VkAccelerationStructureGeometryTrianglesDataKHR();
+    void initialize(const VkAccelerationStructureGeometryTrianglesDataKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAccelerationStructureGeometryTrianglesDataKHR* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureGeometryTrianglesDataKHR* ptr() {
+        return reinterpret_cast<VkAccelerationStructureGeometryTrianglesDataKHR*>(this);
+    }
+    VkAccelerationStructureGeometryTrianglesDataKHR const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureGeometryTrianglesDataKHR const*>(this);
+    }
+};
+struct safe_VkAccelerationStructureGeometryAabbsDataKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    safe_VkDeviceOrHostAddressConstKHR data;
+    VkDeviceSize stride;
+
+    safe_VkAccelerationStructureGeometryAabbsDataKHR(const VkAccelerationStructureGeometryAabbsDataKHR* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkAccelerationStructureGeometryAabbsDataKHR(const safe_VkAccelerationStructureGeometryAabbsDataKHR& copy_src);
+    safe_VkAccelerationStructureGeometryAabbsDataKHR& operator=(const safe_VkAccelerationStructureGeometryAabbsDataKHR& copy_src);
+    safe_VkAccelerationStructureGeometryAabbsDataKHR();
+    ~safe_VkAccelerationStructureGeometryAabbsDataKHR();
+    void initialize(const VkAccelerationStructureGeometryAabbsDataKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAccelerationStructureGeometryAabbsDataKHR* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureGeometryAabbsDataKHR* ptr() {
+        return reinterpret_cast<VkAccelerationStructureGeometryAabbsDataKHR*>(this);
+    }
+    VkAccelerationStructureGeometryAabbsDataKHR const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureGeometryAabbsDataKHR const*>(this);
+    }
+};
+struct safe_VkAccelerationStructureGeometryInstancesDataKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 arrayOfPointers;
+    safe_VkDeviceOrHostAddressConstKHR data;
+
+    safe_VkAccelerationStructureGeometryInstancesDataKHR(const VkAccelerationStructureGeometryInstancesDataKHR* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkAccelerationStructureGeometryInstancesDataKHR(const safe_VkAccelerationStructureGeometryInstancesDataKHR& copy_src);
+    safe_VkAccelerationStructureGeometryInstancesDataKHR& operator=(
+        const safe_VkAccelerationStructureGeometryInstancesDataKHR& copy_src);
+    safe_VkAccelerationStructureGeometryInstancesDataKHR();
+    ~safe_VkAccelerationStructureGeometryInstancesDataKHR();
+    void initialize(const VkAccelerationStructureGeometryInstancesDataKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAccelerationStructureGeometryInstancesDataKHR* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureGeometryInstancesDataKHR* ptr() {
+        return reinterpret_cast<VkAccelerationStructureGeometryInstancesDataKHR*>(this);
+    }
+    VkAccelerationStructureGeometryInstancesDataKHR const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureGeometryInstancesDataKHR const*>(this);
+    }
+};
+struct safe_VkAccelerationStructureGeometryKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkGeometryTypeKHR geometryType;
+    VkAccelerationStructureGeometryDataKHR geometry;
+    VkGeometryFlagsKHR flags;
+
+    safe_VkAccelerationStructureGeometryKHR(const VkAccelerationStructureGeometryKHR* in_struct, const bool is_host,
+                                            const VkAccelerationStructureBuildRangeInfoKHR* build_range_info,
+                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkAccelerationStructureGeometryKHR(const safe_VkAccelerationStructureGeometryKHR& copy_src);
+    safe_VkAccelerationStructureGeometryKHR& operator=(const safe_VkAccelerationStructureGeometryKHR& copy_src);
+    safe_VkAccelerationStructureGeometryKHR();
+    ~safe_VkAccelerationStructureGeometryKHR();
+    void initialize(const VkAccelerationStructureGeometryKHR* in_struct, const bool is_host,
+                    const VkAccelerationStructureBuildRangeInfoKHR* build_range_info, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAccelerationStructureGeometryKHR* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureGeometryKHR* ptr() { return reinterpret_cast<VkAccelerationStructureGeometryKHR*>(this); }
+    VkAccelerationStructureGeometryKHR const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureGeometryKHR const*>(this);
+    }
+};
+struct safe_VkAccelerationStructureBuildGeometryInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAccelerationStructureTypeKHR type;
+    VkBuildAccelerationStructureFlagsKHR flags;
+    VkBuildAccelerationStructureModeKHR mode;
+    VkAccelerationStructureKHR srcAccelerationStructure;
+    VkAccelerationStructureKHR dstAccelerationStructure;
+    uint32_t geometryCount;
+    safe_VkAccelerationStructureGeometryKHR* pGeometries{};
+    safe_VkAccelerationStructureGeometryKHR** ppGeometries{};
+    safe_VkDeviceOrHostAddressKHR scratchData;
+
+    safe_VkAccelerationStructureBuildGeometryInfoKHR(const VkAccelerationStructureBuildGeometryInfoKHR* in_struct,
+                                                     const bool is_host,
+                                                     const VkAccelerationStructureBuildRangeInfoKHR* build_range_infos,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkAccelerationStructureBuildGeometryInfoKHR(const safe_VkAccelerationStructureBuildGeometryInfoKHR& copy_src);
+    safe_VkAccelerationStructureBuildGeometryInfoKHR& operator=(const safe_VkAccelerationStructureBuildGeometryInfoKHR& copy_src);
+    safe_VkAccelerationStructureBuildGeometryInfoKHR();
+    ~safe_VkAccelerationStructureBuildGeometryInfoKHR();
+    void initialize(const VkAccelerationStructureBuildGeometryInfoKHR* in_struct, const bool is_host,
+                    const VkAccelerationStructureBuildRangeInfoKHR* build_range_infos, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAccelerationStructureBuildGeometryInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureBuildGeometryInfoKHR* ptr() {
+        return reinterpret_cast<VkAccelerationStructureBuildGeometryInfoKHR*>(this);
+    }
+    VkAccelerationStructureBuildGeometryInfoKHR const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureBuildGeometryInfoKHR const*>(this);
+    }
+};
+struct safe_VkAccelerationStructureCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAccelerationStructureCreateFlagsKHR createFlags;
+    VkBuffer buffer;
+    VkDeviceSize offset;
+    VkDeviceSize size;
+    VkAccelerationStructureTypeKHR type;
+    VkDeviceAddress deviceAddress;
+
+    safe_VkAccelerationStructureCreateInfoKHR(const VkAccelerationStructureCreateInfoKHR* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkAccelerationStructureCreateInfoKHR(const safe_VkAccelerationStructureCreateInfoKHR& copy_src);
+    safe_VkAccelerationStructureCreateInfoKHR& operator=(const safe_VkAccelerationStructureCreateInfoKHR& copy_src);
+    safe_VkAccelerationStructureCreateInfoKHR();
+    ~safe_VkAccelerationStructureCreateInfoKHR();
+    void initialize(const VkAccelerationStructureCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAccelerationStructureCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureCreateInfoKHR* ptr() { return reinterpret_cast<VkAccelerationStructureCreateInfoKHR*>(this); }
+    VkAccelerationStructureCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureCreateInfoKHR const*>(this);
+    }
+};
+struct safe_VkWriteDescriptorSetAccelerationStructureKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t accelerationStructureCount;
+    VkAccelerationStructureKHR* pAccelerationStructures{};
+
+    safe_VkWriteDescriptorSetAccelerationStructureKHR(const VkWriteDescriptorSetAccelerationStructureKHR* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkWriteDescriptorSetAccelerationStructureKHR(const safe_VkWriteDescriptorSetAccelerationStructureKHR& copy_src);
+    safe_VkWriteDescriptorSetAccelerationStructureKHR& operator=(const safe_VkWriteDescriptorSetAccelerationStructureKHR& copy_src);
+    safe_VkWriteDescriptorSetAccelerationStructureKHR();
+    ~safe_VkWriteDescriptorSetAccelerationStructureKHR();
+    void initialize(const VkWriteDescriptorSetAccelerationStructureKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkWriteDescriptorSetAccelerationStructureKHR* copy_src, PNextCopyState* copy_state = {});
+    VkWriteDescriptorSetAccelerationStructureKHR* ptr() {
+        return reinterpret_cast<VkWriteDescriptorSetAccelerationStructureKHR*>(this);
+    }
+    VkWriteDescriptorSetAccelerationStructureKHR const* ptr() const {
+        return reinterpret_cast<VkWriteDescriptorSetAccelerationStructureKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 accelerationStructure;
+    VkBool32 accelerationStructureCaptureReplay;
+    VkBool32 accelerationStructureIndirectBuild;
+    VkBool32 accelerationStructureHostCommands;
+    VkBool32 descriptorBindingAccelerationStructureUpdateAfterBind;
+
+    safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR(const VkPhysicalDeviceAccelerationStructureFeaturesKHR* in_struct,
+                                                          PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR(const safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR& operator=(
+        const safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR();
+    ~safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR();
+    void initialize(const VkPhysicalDeviceAccelerationStructureFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceAccelerationStructureFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceAccelerationStructureFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    uint64_t maxGeometryCount;
+    uint64_t maxInstanceCount;
+    uint64_t maxPrimitiveCount;
+    uint32_t maxPerStageDescriptorAccelerationStructures;
+    uint32_t maxPerStageDescriptorUpdateAfterBindAccelerationStructures;
+    uint32_t maxDescriptorSetAccelerationStructures;
+    uint32_t maxDescriptorSetUpdateAfterBindAccelerationStructures;
+    uint32_t minAccelerationStructureScratchOffsetAlignment;
+
+    safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR(const VkPhysicalDeviceAccelerationStructurePropertiesKHR* in_struct,
+                                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
+        const safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR& copy_src);
+    safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR& operator=(
+        const safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR& copy_src);
+    safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR();
+    ~safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR();
+    void initialize(const VkPhysicalDeviceAccelerationStructurePropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceAccelerationStructurePropertiesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceAccelerationStructurePropertiesKHR*>(this);
+    }
+    VkPhysicalDeviceAccelerationStructurePropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceAccelerationStructurePropertiesKHR const*>(this);
+    }
+};
+struct safe_VkAccelerationStructureDeviceAddressInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAccelerationStructureKHR accelerationStructure;
+
+    safe_VkAccelerationStructureDeviceAddressInfoKHR(const VkAccelerationStructureDeviceAddressInfoKHR* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkAccelerationStructureDeviceAddressInfoKHR(const safe_VkAccelerationStructureDeviceAddressInfoKHR& copy_src);
+    safe_VkAccelerationStructureDeviceAddressInfoKHR& operator=(const safe_VkAccelerationStructureDeviceAddressInfoKHR& copy_src);
+    safe_VkAccelerationStructureDeviceAddressInfoKHR();
+    ~safe_VkAccelerationStructureDeviceAddressInfoKHR();
+    void initialize(const VkAccelerationStructureDeviceAddressInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAccelerationStructureDeviceAddressInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureDeviceAddressInfoKHR* ptr() {
+        return reinterpret_cast<VkAccelerationStructureDeviceAddressInfoKHR*>(this);
+    }
+    VkAccelerationStructureDeviceAddressInfoKHR const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureDeviceAddressInfoKHR const*>(this);
+    }
+};
+struct safe_VkAccelerationStructureVersionInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    const uint8_t* pVersionData{};
+
+    safe_VkAccelerationStructureVersionInfoKHR(const VkAccelerationStructureVersionInfoKHR* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkAccelerationStructureVersionInfoKHR(const safe_VkAccelerationStructureVersionInfoKHR& copy_src);
+    safe_VkAccelerationStructureVersionInfoKHR& operator=(const safe_VkAccelerationStructureVersionInfoKHR& copy_src);
+    safe_VkAccelerationStructureVersionInfoKHR();
+    ~safe_VkAccelerationStructureVersionInfoKHR();
+    void initialize(const VkAccelerationStructureVersionInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAccelerationStructureVersionInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureVersionInfoKHR* ptr() { return reinterpret_cast<VkAccelerationStructureVersionInfoKHR*>(this); }
+    VkAccelerationStructureVersionInfoKHR const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureVersionInfoKHR const*>(this);
+    }
+};
+struct safe_VkCopyAccelerationStructureToMemoryInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAccelerationStructureKHR src;
+    safe_VkDeviceOrHostAddressKHR dst;
+    VkCopyAccelerationStructureModeKHR mode;
+
+    safe_VkCopyAccelerationStructureToMemoryInfoKHR(const VkCopyAccelerationStructureToMemoryInfoKHR* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkCopyAccelerationStructureToMemoryInfoKHR(const safe_VkCopyAccelerationStructureToMemoryInfoKHR& copy_src);
+    safe_VkCopyAccelerationStructureToMemoryInfoKHR& operator=(const safe_VkCopyAccelerationStructureToMemoryInfoKHR& copy_src);
+    safe_VkCopyAccelerationStructureToMemoryInfoKHR();
+    ~safe_VkCopyAccelerationStructureToMemoryInfoKHR();
+    void initialize(const VkCopyAccelerationStructureToMemoryInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCopyAccelerationStructureToMemoryInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkCopyAccelerationStructureToMemoryInfoKHR* ptr() {
+        return reinterpret_cast<VkCopyAccelerationStructureToMemoryInfoKHR*>(this);
+    }
+    VkCopyAccelerationStructureToMemoryInfoKHR const* ptr() const {
+        return reinterpret_cast<VkCopyAccelerationStructureToMemoryInfoKHR const*>(this);
+    }
+};
+struct safe_VkCopyMemoryToAccelerationStructureInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    safe_VkDeviceOrHostAddressConstKHR src;
+    VkAccelerationStructureKHR dst;
+    VkCopyAccelerationStructureModeKHR mode;
+
+    safe_VkCopyMemoryToAccelerationStructureInfoKHR(const VkCopyMemoryToAccelerationStructureInfoKHR* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkCopyMemoryToAccelerationStructureInfoKHR(const safe_VkCopyMemoryToAccelerationStructureInfoKHR& copy_src);
+    safe_VkCopyMemoryToAccelerationStructureInfoKHR& operator=(const safe_VkCopyMemoryToAccelerationStructureInfoKHR& copy_src);
+    safe_VkCopyMemoryToAccelerationStructureInfoKHR();
+    ~safe_VkCopyMemoryToAccelerationStructureInfoKHR();
+    void initialize(const VkCopyMemoryToAccelerationStructureInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCopyMemoryToAccelerationStructureInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkCopyMemoryToAccelerationStructureInfoKHR* ptr() {
+        return reinterpret_cast<VkCopyMemoryToAccelerationStructureInfoKHR*>(this);
+    }
+    VkCopyMemoryToAccelerationStructureInfoKHR const* ptr() const {
+        return reinterpret_cast<VkCopyMemoryToAccelerationStructureInfoKHR const*>(this);
+    }
+};
+struct safe_VkCopyAccelerationStructureInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAccelerationStructureKHR src;
+    VkAccelerationStructureKHR dst;
+    VkCopyAccelerationStructureModeKHR mode;
+
+    safe_VkCopyAccelerationStructureInfoKHR(const VkCopyAccelerationStructureInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                            bool copy_pnext = true);
+    safe_VkCopyAccelerationStructureInfoKHR(const safe_VkCopyAccelerationStructureInfoKHR& copy_src);
+    safe_VkCopyAccelerationStructureInfoKHR& operator=(const safe_VkCopyAccelerationStructureInfoKHR& copy_src);
+    safe_VkCopyAccelerationStructureInfoKHR();
+    ~safe_VkCopyAccelerationStructureInfoKHR();
+    void initialize(const VkCopyAccelerationStructureInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCopyAccelerationStructureInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkCopyAccelerationStructureInfoKHR* ptr() { return reinterpret_cast<VkCopyAccelerationStructureInfoKHR*>(this); }
+    VkCopyAccelerationStructureInfoKHR const* ptr() const {
+        return reinterpret_cast<VkCopyAccelerationStructureInfoKHR const*>(this);
+    }
+};
+struct safe_VkAccelerationStructureBuildSizesInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceSize accelerationStructureSize;
+    VkDeviceSize updateScratchSize;
+    VkDeviceSize buildScratchSize;
+
+    safe_VkAccelerationStructureBuildSizesInfoKHR(const VkAccelerationStructureBuildSizesInfoKHR* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkAccelerationStructureBuildSizesInfoKHR(const safe_VkAccelerationStructureBuildSizesInfoKHR& copy_src);
+    safe_VkAccelerationStructureBuildSizesInfoKHR& operator=(const safe_VkAccelerationStructureBuildSizesInfoKHR& copy_src);
+    safe_VkAccelerationStructureBuildSizesInfoKHR();
+    ~safe_VkAccelerationStructureBuildSizesInfoKHR();
+    void initialize(const VkAccelerationStructureBuildSizesInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAccelerationStructureBuildSizesInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureBuildSizesInfoKHR* ptr() { return reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR*>(this); }
+    VkAccelerationStructureBuildSizesInfoKHR const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR const*>(this);
+    }
+};
+struct safe_VkRayTracingShaderGroupCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkRayTracingShaderGroupTypeKHR type;
+    uint32_t generalShader;
+    uint32_t closestHitShader;
+    uint32_t anyHitShader;
+    uint32_t intersectionShader;
+    const void* pShaderGroupCaptureReplayHandle{};
+
+    safe_VkRayTracingShaderGroupCreateInfoKHR(const VkRayTracingShaderGroupCreateInfoKHR* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkRayTracingShaderGroupCreateInfoKHR(const safe_VkRayTracingShaderGroupCreateInfoKHR& copy_src);
+    safe_VkRayTracingShaderGroupCreateInfoKHR& operator=(const safe_VkRayTracingShaderGroupCreateInfoKHR& copy_src);
+    safe_VkRayTracingShaderGroupCreateInfoKHR();
+    ~safe_VkRayTracingShaderGroupCreateInfoKHR();
+    void initialize(const VkRayTracingShaderGroupCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRayTracingShaderGroupCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkRayTracingShaderGroupCreateInfoKHR* ptr() { return reinterpret_cast<VkRayTracingShaderGroupCreateInfoKHR*>(this); }
+    VkRayTracingShaderGroupCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkRayTracingShaderGroupCreateInfoKHR const*>(this);
+    }
+};
+struct safe_VkRayTracingPipelineInterfaceCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t maxPipelineRayPayloadSize;
+    uint32_t maxPipelineRayHitAttributeSize;
+
+    safe_VkRayTracingPipelineInterfaceCreateInfoKHR(const VkRayTracingPipelineInterfaceCreateInfoKHR* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkRayTracingPipelineInterfaceCreateInfoKHR(const safe_VkRayTracingPipelineInterfaceCreateInfoKHR& copy_src);
+    safe_VkRayTracingPipelineInterfaceCreateInfoKHR& operator=(const safe_VkRayTracingPipelineInterfaceCreateInfoKHR& copy_src);
+    safe_VkRayTracingPipelineInterfaceCreateInfoKHR();
+    ~safe_VkRayTracingPipelineInterfaceCreateInfoKHR();
+    void initialize(const VkRayTracingPipelineInterfaceCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRayTracingPipelineInterfaceCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkRayTracingPipelineInterfaceCreateInfoKHR* ptr() {
+        return reinterpret_cast<VkRayTracingPipelineInterfaceCreateInfoKHR*>(this);
+    }
+    VkRayTracingPipelineInterfaceCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkRayTracingPipelineInterfaceCreateInfoKHR const*>(this);
+    }
+};
+struct safe_VkRayTracingPipelineCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineCreateFlags flags;
+    uint32_t stageCount;
+    safe_VkPipelineShaderStageCreateInfo* pStages{};
+    uint32_t groupCount;
+    safe_VkRayTracingShaderGroupCreateInfoKHR* pGroups{};
+    uint32_t maxPipelineRayRecursionDepth;
+    safe_VkPipelineLibraryCreateInfoKHR* pLibraryInfo{};
+    safe_VkRayTracingPipelineInterfaceCreateInfoKHR* pLibraryInterface{};
+    safe_VkPipelineDynamicStateCreateInfo* pDynamicState{};
+    VkPipelineLayout layout;
+    VkPipeline basePipelineHandle;
+    int32_t basePipelineIndex;
+
+    safe_VkRayTracingPipelineCreateInfoKHR(const VkRayTracingPipelineCreateInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                           bool copy_pnext = true);
+    safe_VkRayTracingPipelineCreateInfoKHR(const safe_VkRayTracingPipelineCreateInfoKHR& copy_src);
+    safe_VkRayTracingPipelineCreateInfoKHR& operator=(const safe_VkRayTracingPipelineCreateInfoKHR& copy_src);
+    safe_VkRayTracingPipelineCreateInfoKHR();
+    ~safe_VkRayTracingPipelineCreateInfoKHR();
+    void initialize(const VkRayTracingPipelineCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRayTracingPipelineCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkRayTracingPipelineCreateInfoKHR* ptr() { return reinterpret_cast<VkRayTracingPipelineCreateInfoKHR*>(this); }
+    VkRayTracingPipelineCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkRayTracingPipelineCreateInfoKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 rayTracingPipeline;
+    VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplay;
+    VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
+    VkBool32 rayTracingPipelineTraceRaysIndirect;
+    VkBool32 rayTraversalPrimitiveCulling;
+
+    safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(const safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR& operator=(
+        const safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR();
+    ~safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR();
+    void initialize(const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRayTracingPipelineFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceRayTracingPipelineFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t shaderGroupHandleSize;
+    uint32_t maxRayRecursionDepth;
+    uint32_t maxShaderGroupStride;
+    uint32_t shaderGroupBaseAlignment;
+    uint32_t shaderGroupHandleCaptureReplaySize;
+    uint32_t maxRayDispatchInvocationCount;
+    uint32_t shaderGroupHandleAlignment;
+    uint32_t maxRayHitAttributeSize;
+
+    safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(const safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR& copy_src);
+    safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR& operator=(
+        const safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR& copy_src);
+    safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR();
+    ~safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR();
+    void initialize(const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRayTracingPipelinePropertiesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingPipelinePropertiesKHR*>(this);
+    }
+    VkPhysicalDeviceRayTracingPipelinePropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingPipelinePropertiesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceRayQueryFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 rayQuery;
+
+    safe_VkPhysicalDeviceRayQueryFeaturesKHR(const VkPhysicalDeviceRayQueryFeaturesKHR* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkPhysicalDeviceRayQueryFeaturesKHR(const safe_VkPhysicalDeviceRayQueryFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceRayQueryFeaturesKHR& operator=(const safe_VkPhysicalDeviceRayQueryFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceRayQueryFeaturesKHR();
+    ~safe_VkPhysicalDeviceRayQueryFeaturesKHR();
+    void initialize(const VkPhysicalDeviceRayQueryFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceRayQueryFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRayQueryFeaturesKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceRayQueryFeaturesKHR*>(this); }
+    VkPhysicalDeviceRayQueryFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRayQueryFeaturesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceMeshShaderFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 taskShader;
+    VkBool32 meshShader;
+    VkBool32 multiviewMeshShader;
+    VkBool32 primitiveFragmentShadingRateMeshShader;
+    VkBool32 meshShaderQueries;
+
+    safe_VkPhysicalDeviceMeshShaderFeaturesEXT(const VkPhysicalDeviceMeshShaderFeaturesEXT* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceMeshShaderFeaturesEXT(const safe_VkPhysicalDeviceMeshShaderFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceMeshShaderFeaturesEXT& operator=(const safe_VkPhysicalDeviceMeshShaderFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceMeshShaderFeaturesEXT();
+    ~safe_VkPhysicalDeviceMeshShaderFeaturesEXT();
+    void initialize(const VkPhysicalDeviceMeshShaderFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMeshShaderFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMeshShaderFeaturesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesEXT*>(this); }
+    VkPhysicalDeviceMeshShaderFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceMeshShaderPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxTaskWorkGroupTotalCount;
+    uint32_t maxTaskWorkGroupCount[3];
+    uint32_t maxTaskWorkGroupInvocations;
+    uint32_t maxTaskWorkGroupSize[3];
+    uint32_t maxTaskPayloadSize;
+    uint32_t maxTaskSharedMemorySize;
+    uint32_t maxTaskPayloadAndSharedMemorySize;
+    uint32_t maxMeshWorkGroupTotalCount;
+    uint32_t maxMeshWorkGroupCount[3];
+    uint32_t maxMeshWorkGroupInvocations;
+    uint32_t maxMeshWorkGroupSize[3];
+    uint32_t maxMeshSharedMemorySize;
+    uint32_t maxMeshPayloadAndSharedMemorySize;
+    uint32_t maxMeshOutputMemorySize;
+    uint32_t maxMeshPayloadAndOutputMemorySize;
+    uint32_t maxMeshOutputComponents;
+    uint32_t maxMeshOutputVertices;
+    uint32_t maxMeshOutputPrimitives;
+    uint32_t maxMeshOutputLayers;
+    uint32_t maxMeshMultiviewViewCount;
+    uint32_t meshOutputPerVertexGranularity;
+    uint32_t meshOutputPerPrimitiveGranularity;
+    uint32_t maxPreferredTaskWorkGroupInvocations;
+    uint32_t maxPreferredMeshWorkGroupInvocations;
+    VkBool32 prefersLocalInvocationVertexOutput;
+    VkBool32 prefersLocalInvocationPrimitiveOutput;
+    VkBool32 prefersCompactVertexOutput;
+    VkBool32 prefersCompactPrimitiveOutput;
+
+    safe_VkPhysicalDeviceMeshShaderPropertiesEXT(const VkPhysicalDeviceMeshShaderPropertiesEXT* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceMeshShaderPropertiesEXT(const safe_VkPhysicalDeviceMeshShaderPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceMeshShaderPropertiesEXT& operator=(const safe_VkPhysicalDeviceMeshShaderPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceMeshShaderPropertiesEXT();
+    ~safe_VkPhysicalDeviceMeshShaderPropertiesEXT();
+    void initialize(const VkPhysicalDeviceMeshShaderPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMeshShaderPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMeshShaderPropertiesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesEXT*>(this); }
+    VkPhysicalDeviceMeshShaderPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesEXT const*>(this);
+    }
+};
+
+// Safe struct that spans NV and KHR VkRayTracingPipelineCreateInfo structures.
+// It is a VkRayTracingPipelineCreateInfoKHR and supports construction from
+// a VkRayTracingPipelineCreateInfoNV.
+class safe_VkRayTracingPipelineCreateInfoCommon : public safe_VkRayTracingPipelineCreateInfoKHR {
+  public:
+    safe_VkRayTracingPipelineCreateInfoCommon() : safe_VkRayTracingPipelineCreateInfoKHR() {}
+    safe_VkRayTracingPipelineCreateInfoCommon(const VkRayTracingPipelineCreateInfoNV* pCreateInfo)
+        : safe_VkRayTracingPipelineCreateInfoKHR() {
+        initialize(pCreateInfo);
+    }
+    safe_VkRayTracingPipelineCreateInfoCommon(const VkRayTracingPipelineCreateInfoKHR* pCreateInfo)
+        : safe_VkRayTracingPipelineCreateInfoKHR(pCreateInfo) {}
+
+    void initialize(const VkRayTracingPipelineCreateInfoNV* pCreateInfo);
+    void initialize(const VkRayTracingPipelineCreateInfoKHR* pCreateInfo);
+    uint32_t maxRecursionDepth = 0;  // NV specific
+};
+
+}  // namespace vku
+
+// NOLINTEND
diff --git a/include/vulkan/utility/vk_safe_struct_utils.hpp b/include/vulkan/utility/vk_safe_struct_utils.hpp
new file mode 100644
index 0000000..9606df4
--- /dev/null
+++ b/include/vulkan/utility/vk_safe_struct_utils.hpp
@@ -0,0 +1,128 @@
+/***************************************************************************
+ *
+ * Copyright (c) 2015-2024 The Khronos Group Inc.
+ * Copyright (c) 2015-2024 Valve Corporation
+ * Copyright (c) 2015-2024 LunarG, Inc.
+ * Copyright (c) 2015-2024 Google Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ ****************************************************************************/
+
+#pragma once
+#include <vulkan/vulkan.h>
+#include <cassert>
+#include <cstdlib>
+#include <cstring>
+#include <functional>
+#include <vector>
+
+namespace vku {
+
+// Mapping of unknown stype codes to structure lengths. This should be set up by the application
+// before vkCreateInstance() and not modified afterwards.
+extern std::vector<std::pair<uint32_t, uint32_t>> custom_stype_info;
+
+// State that elements in a pNext chain may need to be aware of
+struct PNextCopyState {
+    // Custom initialization function. Returns true if the structure passed to init was initialized, false otherwise
+    std::function<bool(VkBaseOutStructure* /* safe_sruct */, const VkBaseOutStructure* /* in_struct */)> init;
+};
+
+void* SafePnextCopy(const void* pNext, PNextCopyState* copy_state = {});
+void FreePnextChain(const void* pNext);
+char* SafeStringCopy(const char* in_string);
+
+template <typename Base, typename T>
+bool AddToPnext(Base& base, const T& data) {
+    assert(base.ptr());  // All safe struct have a ptr() method. Prevent use with non-safe structs.
+    auto** prev = reinterpret_cast<VkBaseOutStructure**>(const_cast<void**>(&base.pNext));
+    auto* current = *prev;
+    while (current) {
+        if (data.sType == current->sType) {
+            return false;
+        }
+        prev = reinterpret_cast<VkBaseOutStructure**>(&current->pNext);
+        current = *prev;
+    }
+    *prev = reinterpret_cast<VkBaseOutStructure*>(SafePnextCopy(&data));
+    return true;
+}
+
+template <typename Base>
+bool RemoveFromPnext(Base& base, VkStructureType t) {
+    assert(base.ptr());  // All safe struct have a ptr() method. Prevent use with non-safe structs.
+    auto** prev = reinterpret_cast<VkBaseOutStructure**>(const_cast<void**>(&base.pNext));
+    auto* current = *prev;
+    while (current) {
+        if (t == current->sType) {
+            *prev = current->pNext;
+            current->pNext = nullptr;
+            FreePnextChain(current);
+            return true;
+        }
+        prev = reinterpret_cast<VkBaseOutStructure**>(&current->pNext);
+        current = *prev;
+    }
+    return false;
+}
+
+template <typename CreateInfo>
+uint32_t FindExtension(CreateInfo& ci, const char* extension_name) {
+    assert(ci.ptr());  // All safe struct have a ptr() method. Prevent use with non-safe structs.
+    for (uint32_t i = 0; i < ci.enabledExtensionCount; i++) {
+        if (strcmp(ci.ppEnabledExtensionNames[i], extension_name) == 0) {
+            return i;
+        }
+    }
+    return ci.enabledExtensionCount;
+}
+
+template <typename CreateInfo>
+bool AddExtension(CreateInfo& ci, const char* extension_name) {
+    assert(ci.ptr());  // All safe struct have a ptr() method. Prevent use with non-safe structs.
+    uint32_t pos = FindExtension(ci, extension_name);
+    if (pos < ci.enabledExtensionCount) {
+        // already present
+        return false;
+    }
+    char** exts = new char*[ci.enabledExtensionCount + 1];
+    memcpy(exts, ci.ppEnabledExtensionNames, sizeof(char*) * ci.enabledExtensionCount);
+    exts[ci.enabledExtensionCount] = SafeStringCopy(extension_name);
+    delete[] ci.ppEnabledExtensionNames;
+    ci.ppEnabledExtensionNames = exts;
+    ci.enabledExtensionCount++;
+    return true;
+}
+
+template <typename CreateInfo>
+bool RemoveExtension(CreateInfo& ci, const char* extension_name) {
+    assert(ci.ptr());  // All safe struct have a ptr() method. Prevent use with non-safe structs.
+    uint32_t pos = FindExtension(ci, extension_name);
+    if (pos >= ci.enabledExtensionCount) {
+        // not present
+        return false;
+    }
+    if (ci.enabledExtensionCount == 1) {
+        delete[] ci.ppEnabledExtensionNames[0];
+        delete[] ci.ppEnabledExtensionNames;
+        ci.ppEnabledExtensionNames = nullptr;
+        ci.enabledExtensionCount = 0;
+        return true;
+    }
+    uint32_t out_pos = 0;
+    char** exts = new char*[ci.enabledExtensionCount - 1];
+    for (uint32_t i = 0; i < ci.enabledExtensionCount; i++) {
+        if (i == pos) {
+            delete[] ci.ppEnabledExtensionNames[i];
+        } else {
+            exts[out_pos++] = const_cast<char*>(ci.ppEnabledExtensionNames[i]);
+        }
+    }
+    delete[] ci.ppEnabledExtensionNames;
+    ci.ppEnabledExtensionNames = exts;
+    ci.enabledExtensionCount--;
+    return true;
+}
+
+}  // namespace vku
diff --git a/scripts/common_ci.py b/scripts/common_ci.py
new file mode 100644
index 0000000..32a8ec7
--- /dev/null
+++ b/scripts/common_ci.py
@@ -0,0 +1,54 @@
+#!/usr/bin/python3 -i
+#
+# Copyright (c) 2015-2024 The Khronos Group Inc.
+# Copyright (c) 2015-2024 Valve Corporation
+# Copyright (c) 2015-2024 LunarG, Inc.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+import sys
+import subprocess
+import platform
+
+# Use Ninja for all platforms for performance/simplicity
+os.environ['CMAKE_GENERATOR'] = "Ninja"
+
+# helper to define paths relative to the repo root
+def RepoRelative(path):
+    return os.path.abspath(os.path.join(os.path.dirname(__file__), '..', path))
+
+# Points to the directory containing the top level CMakeLists.txt
+PROJECT_SRC_DIR = os.path.abspath(os.path.join(os.path.split(os.path.abspath(__file__))[0], '..'))
+if not os.path.isfile(f'{PROJECT_SRC_DIR}/CMakeLists.txt'):
+    print(f'PROJECT_SRC_DIR invalid! {PROJECT_SRC_DIR}')
+    sys.exit(1)
+
+# Returns true if we are running in GitHub actions
+# https://docs.github.com/en/actions/learn-github-actions/variables#default-environment-variables
+def IsGHA():
+    if 'GITHUB_ACTION' in os.environ:
+        return True
+    return False
+
+# Runs a command in a directory and returns its return code.
+# Directory is project root by default, or a relative path from project root
+def RunShellCmd(command, start_dir = PROJECT_SRC_DIR, env=None, verbose=False):
+    # Flush stdout here. Helps when debugging on CI.
+    sys.stdout.flush()
+
+    if start_dir != PROJECT_SRC_DIR:
+        start_dir = RepoRelative(start_dir)
+    cmd_list = command.split(" ")
+
+    # Helps a lot when debugging CI issues
+    if IsGHA():
+        verbose = True
+
+    if verbose:
+        print(f'CICMD({cmd_list}, env={env})')
+    subprocess.check_call(cmd_list, cwd=start_dir, env=env)
+
+#
+# Check if the system is Windows
+def IsWindows(): return 'windows' == platform.system().lower()
diff --git a/scripts/generate_source.py b/scripts/generate_source.py
index 3abecea..8be15a0 100755
--- a/scripts/generate_source.py
+++ b/scripts/generate_source.py
@@ -8,10 +8,16 @@
 import argparse
 import os
 import sys
+import shutil
+import common_ci
 from xml.etree import ElementTree
 
 def RunGenerators(api: str, registry: str, targetFilter: str) -> None:
 
+    has_clang_format = shutil.which('clang-format') is not None
+    if not has_clang_format:
+        print("WARNING: Unable to find clang-format!")
+
     # These live in the Vulkan-Docs repo, but are pulled in via the
     # Vulkan-Headers/registry folder
     # At runtime we inject python path to find these helper scripts
@@ -26,6 +32,7 @@ def RunGenerators(api: str, registry: str, targetFilter: str) -> None:
     from generators.enum_string_helper_generator import EnumStringHelperOutputGenerator
     from generators.format_utils_generator import FormatUtilsOutputGenerator
     from generators.struct_helper_generator import StructHelperOutputGenerator
+    from generators.safe_struct_generator import SafeStructOutputGenerator
 
     # These set fields that are needed by both OutputGenerator and BaseGenerator,
     # but are uniform and don't need to be set at a per-generated file level
@@ -54,6 +61,37 @@ def RunGenerators(api: str, registry: str, targetFilter: str) -> None:
             'genCombined': True,
             'directory' : f'include/{api}/utility',
         },
+        'vk_safe_struct.hpp' : {
+            'generator' : SafeStructOutputGenerator,
+            'genCombined': True,
+            'directory' : f'include/{api}/utility',
+        },
+        'vk_safe_struct_utils.cpp' : {
+            'generator' : SafeStructOutputGenerator,
+            'genCombined': True,
+            'directory' : f'src/{api}',
+        },
+        'vk_safe_struct_core.cpp' : {
+            'generator' : SafeStructOutputGenerator,
+            'genCombined': True,
+            'regenerate' : True,
+            'directory' : f'src/{api}',
+        },
+        'vk_safe_struct_khr.cpp' : {
+            'generator' : SafeStructOutputGenerator,
+            'genCombined': True,
+            'directory' : f'src/{api}',
+        },
+        'vk_safe_struct_ext.cpp' : {
+            'generator' : SafeStructOutputGenerator,
+            'genCombined': True,
+            'directory' : f'src/{api}',
+        },
+        'vk_safe_struct_vendor.cpp' : {
+            'generator' : SafeStructOutputGenerator,
+            'genCombined': True,
+            'directory' : f'src/{api}',
+        },
     }
 
     if (targetFilter and targetFilter not in generators.keys()):
@@ -102,6 +140,9 @@ def RunGenerators(api: str, registry: str, targetFilter: str) -> None:
         # Finally, use the output generator to create the requested target
         reg.apiGen()
 
+        # Run clang-format on the file
+        if has_clang_format:
+            common_ci.RunShellCmd(f'clang-format -i {os.path.join(outDirectory, target)}')
 
 def main(argv):
     parser = argparse.ArgumentParser(description='Generate source code for this repository')
diff --git a/scripts/generators/base_generator.py b/scripts/generators/base_generator.py
index 2d8635e..639acfe 100644
--- a/scripts/generators/base_generator.py
+++ b/scripts/generators/base_generator.py
@@ -1,12 +1,14 @@
 #!/usr/bin/python3 -i
 #
-# Copyright 2023-2024 The Khronos Group Inc.
-# Copyright 2023-2024 Valve Corporation
-# Copyright 2023-2024 LunarG, Inc.
-# Copyright 2023-2024 RasterGrid Kft.
+# Copyright (c) 2023-2024 Valve Corporation
+# Copyright (c) 2023-2024 LunarG, Inc.
+# Copyright (c) 2023-2024 RasterGrid Kft.
 #
 # SPDX-License-Identifier: Apache-2.0
 
+import pickle
+import os
+import tempfile
 from generators.vulkan_object import (VulkanObject,
     Extension, Version, Handle, Param, Queues, CommandScope, Command,
     EnumField, Enum, Flag, Bitmask, Member, Struct,
@@ -70,6 +72,11 @@ def SetMergedApiNames(names: str) -> None:
     global mergedApiNames
     mergedApiNames = names
 
+cachingEnabled = False
+def EnableCaching() -> None:
+    global cachingEnabled
+    cachingEnabled = True
+
 # This class is a container for any source code, data, or other behavior that is necessary to
 # customize the generator script for a specific target API variant (e.g. Vulkan SC). As such,
 # all of these API-specific interfaces and their use in the generator script are part of the
@@ -111,7 +118,7 @@ class BaseGeneratorOptions(GeneratorOptions):
         self.apicall         = 'VKAPI_ATTR '
         self.apientry        = 'VKAPI_CALL '
         self.apientryp       = 'VKAPI_PTR *'
-        self.alignFuncParam   = 48
+        self.alignFuncParam  = 48
 
 #
 # This object handles all the parsing from reg.py generator scripts in the Vulkan-Headers
@@ -219,7 +226,6 @@ class BaseGenerator(OutputGenerator):
                             enum.fieldExtensions.extend([extension] if extension not in enum.fieldExtensions else [])
                             enumField.extensions.extend([extension] if extension not in enumField.extensions else [])
                             extension.enumFields[group].extend([enumField] if enumField not in extension.enumFields[group] else [])
-
                     if group in self.vk.bitmasks:
                         if group not in extension.flags:
                             extension.flags[group] = [] # Dict needs init
@@ -229,11 +235,10 @@ class BaseGenerator(OutputGenerator):
 
                         for flags in [x for x in bitmask.flags if x.name in flagList]:
                             # Make sure list is unique
-                            bitmask.extensions.extend([extension] if extension not in bitmask.extensions else [])
+                            bitmask.flagExtensions.extend([extension] if extension not in bitmask.flagExtensions else [])
                             flags.extensions.extend([extension] if extension not in flags.extensions else [])
                             extension.flags[group].extend([flags] if flags not in extension.flags[group] else [])
 
-
         # Need to do 'enum'/'bitmask' after 'enumconstant' has applied everything so we can add implicit extensions
         #
         # Sometimes two extensions enable an Enum, but the newer extension version has extra flags allowed
@@ -267,17 +272,18 @@ class BaseGenerator(OutputGenerator):
             for required in dict:
                 for group in dict[required]:
                     for bitmaskName in dict[required][group]:
-                        isAlias = bitmaskName in self.enumAliasMap
+                        bitmaskName = bitmaskName.replace('Flags', 'FlagBits') # Works since Flags isn't repeated in name
+                        isAlias = bitmaskName in self.bitmaskAliasMap
                         bitmaskName = self.bitmaskAliasMap[bitmaskName] if isAlias else bitmaskName
                         if bitmaskName in self.vk.bitmasks:
                             bitmask = self.vk.bitmasks[bitmaskName]
                             bitmask.extensions.extend([extension] if extension not in bitmask.extensions else [])
-                            extension.bitmask.extend([bitmask] if bitmask not in extension.bitmasks else [])
+                            extension.bitmasks.extend([bitmask] if bitmask not in extension.bitmasks else [])
                             # Update flags with implicit base extension
                             if isAlias:
                                 continue
-                            bitmask.flagExtensions.extend([extension] if extension not in enum.flagExtensions else [])
-                            for flag in [x for x in enum.flags if (not x.extensions or (x.extensions and all(e in enum.extensions for e in x.extensions)))]:
+                            bitmask.flagExtensions.extend([extension] if extension not in bitmask.flagExtensions else [])
+                            for flag in [x for x in bitmask.flags if (not x.extensions or (x.extensions and all(e in bitmask.extensions for e in x.extensions)))]:
                                 flag.extensions.extend([extension] if extension not in flag.extensions else [])
                                 if bitmaskName not in extension.flags:
                                     extension.flags[bitmaskName] = [] # Dict needs init
@@ -304,9 +310,17 @@ class BaseGenerator(OutputGenerator):
         for struct in [x for x in self.vk.structs.values() if not x.returnedOnly]:
             for enum in [self.vk.enums[x.type] for x in struct.members if x.type in self.vk.enums]:
                 enum.returnedOnly = False
+            for bitmask in [self.vk.bitmasks[x.type] for x in struct.members if x.type in self.vk.bitmasks]:
+                bitmask.returnedOnly = False
+            for bitmask in [self.vk.bitmasks[x.type.replace('Flags', 'FlagBits')] for x in struct.members if x.type.replace('Flags', 'FlagBits') in self.vk.bitmasks]:
+                bitmask.returnedOnly = False
         for command in self.vk.commands.values():
             for enum in [self.vk.enums[x.type] for x in command.params if x.type in self.vk.enums]:
                 enum.returnedOnly = False
+            for bitmask in [self.vk.bitmasks[x.type] for x in command.params if x.type in self.vk.bitmasks]:
+                bitmask.returnedOnly = False
+            for bitmask in [self.vk.bitmasks[x.type.replace('Flags', 'FlagBits')] for x in command.params if x.type.replace('Flags', 'FlagBits') in self.vk.bitmasks]:
+                bitmask.returnedOnly = False
 
         # Turn handle parents into pointers to classess
         for handle in [x for x in self.vk.handles.values() if x.parent is not None]:
@@ -327,9 +341,26 @@ class BaseGenerator(OutputGenerator):
         # All inherited generators should run from here
         self.generate()
 
+        if cachingEnabled:
+            cachePath = os.path.join(tempfile.gettempdir(), f'vkobject_{os.getpid()}')
+            if not os.path.isfile(cachePath):
+                cacheFile = open(cachePath, 'wb')
+                pickle.dump(self.vk, cacheFile)
+                cacheFile.close()
+
         # This should not have to do anything but call into OutputGenerator
         OutputGenerator.endFile(self)
 
+    #
+    # Bypass the entire processing and load in the VkObject data
+    # Still need to handle the beingFile/endFile for reg.py
+    def generateFromCache(self, cacheVkObjectData, genOpts):
+        OutputGenerator.beginFile(self, genOpts)
+        self.filename = genOpts.filename
+        self.vk = cacheVkObjectData
+        self.generate()
+        OutputGenerator.endFile(self)
+
     #
     # Processing point at beginning of each extension definition
     def beginFeature(self, interface, emit):
@@ -337,7 +368,6 @@ class BaseGenerator(OutputGenerator):
         platform = interface.get('platform')
         self.featureExtraProtec = self.vk.platforms[platform] if platform in self.vk.platforms else None
         protect = self.vk.platforms[platform] if platform in self.vk.platforms else None
-
         name = interface.get('name')
 
         if interface.tag == 'extension':
@@ -463,7 +493,7 @@ class BaseGenerator(OutputGenerator):
         # fields also have their own protect
         groupProtect = self.currentExtension.protect if hasattr(self.currentExtension, 'protect') and self.currentExtension.protect is not None else None
         enumElem = groupinfo.elem
-        bitwidth = 32 if enumElem.get('bitwidth') is None else enumElem.get('bitwidth')
+        bitwidth = 32 if enumElem.get('bitwidth') is None else int(enumElem.get('bitwidth'))
         fields = []
         if enumElem.get('type') == "enum":
             if alias is not None:
@@ -514,7 +544,7 @@ class BaseGenerator(OutputGenerator):
                     fields.append(Flag(flagName, protect, flagValue, flagMultiBit, flagZero, []))
 
             flagName = groupName.replace('FlagBits', 'Flags')
-            self.vk.bitmasks[groupName] = Bitmask(groupName, flagName, groupProtect, bitwidth, fields, [], [])
+            self.vk.bitmasks[groupName] = Bitmask(groupName, flagName, groupProtect, bitwidth, True, fields, [], [])
 
     def genType(self, typeInfo, typeName, alias):
         OutputGenerator.genType(self, typeInfo, typeName, alias)
diff --git a/scripts/generators/dispatch_table_generator.py b/scripts/generators/dispatch_table_generator.py
index 3edaacf..ebab6ea 100644
--- a/scripts/generators/dispatch_table_generator.py
+++ b/scripts/generators/dispatch_table_generator.py
@@ -44,9 +44,9 @@ typedef struct VkuInstanceDispatchTable_ {
 ''')
         guard_helper = PlatformGuardHelper()
         for command in [x for x in self.vk.commands.values() if x.instance]:
-            out.extend(guard_helper.addGuard(command.protect))
+            out.extend(guard_helper.add_guard(command.protect))
             out.append(f'    PFN_{command.name} {command.name[2:]};\n')
-        out.extend(guard_helper.addGuard(None))
+        out.extend(guard_helper.add_guard(None))
         out.append('} VkuInstanceDispatchTable;\n')
 
         out.append('''
@@ -54,9 +54,9 @@ typedef struct VkuInstanceDispatchTable_ {
 typedef struct VkuDeviceDispatchTable_ {
 ''')
         for command in [x for x in self.vk.commands.values() if x.device]:
-            out.extend(guard_helper.addGuard(command.protect))
+            out.extend(guard_helper.add_guard(command.protect))
             out.append(f'    PFN_{command.name} {command.name[2:]};\n')
-        out.extend(guard_helper.addGuard(None))
+        out.extend(guard_helper.add_guard(None))
         out.append('} VkuDeviceDispatchTable;\n')
 
         out.append('''
@@ -67,9 +67,9 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
 ''')
 
         for command in [x for x in self.vk.commands.values() if x.device and x.name != 'vkGetDeviceProcAddr']:
-            out.extend(guard_helper.addGuard(command.protect))
+            out.extend(guard_helper.add_guard(command.protect))
             out.append(f'    table->{command.name[2:]} = (PFN_{command.name})gdpa(device, "{command.name}");\n')
-        out.extend(guard_helper.addGuard(None))
+        out.extend(guard_helper.add_guard(None))
         out.append('}\n')
 
         out.append('''
@@ -89,9 +89,9 @@ static inline void vkuInitInstanceDispatchTable(VkInstance instance, VkuInstance
                 'vkEnumerateInstanceVersion',
                 'vkGetInstanceProcAddr',
         ]]:
-            out.extend(guard_helper.addGuard(command.protect))
+            out.extend(guard_helper.add_guard(command.protect))
             out.append(f'    table->{command.name[2:]} = (PFN_{command.name})gipa(instance, "{command.name}");\n')
-        out.extend(guard_helper.addGuard(None))
+        out.extend(guard_helper.add_guard(None))
         out.append('}\n')
 
         out.append('// clang-format on')
diff --git a/scripts/generators/enum_string_helper_generator.py b/scripts/generators/enum_string_helper_generator.py
index 5c45b55..33a0a2a 100644
--- a/scripts/generators/enum_string_helper_generator.py
+++ b/scripts/generators/enum_string_helper_generator.py
@@ -39,20 +39,20 @@ class EnumStringHelperOutputGenerator(BaseGenerator):
         # If there are no fields (empty enum) ignore
         for enum in [x for x in self.vk.enums.values() if len(x.fields) > 0]:
             groupType = enum.name if enum.bitWidth == 32 else 'uint64_t'
-            out.extend(guard_helper.addGuard(enum.protect))
+            out.extend(guard_helper.add_guard(enum.protect))
             out.append(f'static inline const char* string_{enum.name}({groupType} input_value) {{\n')
             out.append('    switch (input_value) {\n')
             enum_field_guard_helper = PlatformGuardHelper()
             for field in enum.fields:
-                out.extend(enum_field_guard_helper.addGuard(field.protect))
+                out.extend(enum_field_guard_helper.add_guard(field.protect))
                 out.append(f'        case {field.name}:\n')
                 out.append(f'            return "{field.name}";\n')
-            out.extend(enum_field_guard_helper.addGuard(None))
+            out.extend(enum_field_guard_helper.add_guard(None))
             out.append('        default:\n')
             out.append(f'            return "Unhandled {enum.name}";\n')
             out.append('    }\n')
             out.append('}\n')
-        out.extend(guard_helper.addGuard(None))
+        out.extend(guard_helper.add_guard(None))
         out.append('\n')
 
         # For bitmask, first create a string for FlagBits, then a Flags version that calls into it
@@ -65,26 +65,26 @@ class EnumStringHelperOutputGenerator(BaseGenerator):
             if groupType == 'uint64_t':
                 use_switch_statement = False
 
-            out.extend(guard_helper.addGuard(bitmask.protect))
+            out.extend(guard_helper.add_guard(bitmask.protect))
             out.append(f'static inline const char* string_{bitmask.name}({groupType} input_value) {{\n')
 
             bitmask_field_guard_helper = PlatformGuardHelper()
             if use_switch_statement:
                 out.append('    switch (input_value) {\n')
                 for flag in [x for x in bitmask.flags if not x.multiBit]:
-                    out.extend(bitmask_field_guard_helper.addGuard(flag.protect))
+                    out.extend(bitmask_field_guard_helper.add_guard(flag.protect))
                     out.append(f'        case {flag.name}:\n')
                     out.append(f'            return "{flag.name}";\n')
-                out.extend(bitmask_field_guard_helper.addGuard(None))
+                out.extend(bitmask_field_guard_helper.add_guard(None))
                 out.append('        default:\n')
                 out.append(f'            return "Unhandled {bitmask.name}";\n')
                 out.append('    }\n')
             else:
                 # We need to use if statements
                 for flag in [x for x in bitmask.flags if not x.multiBit]:
-                    out.extend(bitmask_field_guard_helper.addGuard(flag.protect))
+                    out.extend(bitmask_field_guard_helper.add_guard(flag.protect))
                     out.append(f'    if (input_value == {flag.name}) return "{flag.name}";\n')
-                out.extend(bitmask_field_guard_helper.addGuard(None))
+                out.extend(bitmask_field_guard_helper.add_guard(None))
                 out.append(f'    return "Unhandled {bitmask.name}";\n')
             out.append('}\n')
 
@@ -110,6 +110,6 @@ static inline std::string string_{bitmask.flagName}({bitmask.flagName} input_val
     return ret;
 }}\n''')
             out.append('#endif // __cplusplus\n')
-        out.extend(guard_helper.addGuard(None))
+        out.extend(guard_helper.add_guard(None))
         out.append('// clang-format on')
         self.write("".join(out))
diff --git a/scripts/generators/generator_utils.py b/scripts/generators/generator_utils.py
index 387812e..e3e499d 100644
--- a/scripts/generators/generator_utils.py
+++ b/scripts/generators/generator_utils.py
@@ -1,25 +1,148 @@
 #!/usr/bin/python3 -i
 #
-# Copyright 2023 The Khronos Group Inc.
-# Copyright 2023 Valve Corporation
-# Copyright 2023 LunarG, Inc.
-# Copyright 2023 RasterGrid Kft.
+# Copyright (c) 2023-2024 Valve Corporation
+# Copyright (c) 2023-2024 LunarG, Inc.
 #
 # SPDX-License-Identifier: Apache-2.0
 
+import os
+import sys
+import json
+
+# Build a set of all vuid text strings found in validusage.json
+def buildListVUID(valid_usage_file: str) -> set:
+
+    # Walk the JSON-derived dict and find all "vuid" key values
+    def ExtractVUIDs(vuid_dict):
+        if hasattr(vuid_dict, 'items'):
+            for key, value in vuid_dict.items():
+                if key == "vuid":
+                    yield value
+                elif isinstance(value, dict):
+                    for vuid in ExtractVUIDs(value):
+                        yield vuid
+                elif isinstance (value, list):
+                    for listValue in value:
+                        for vuid in ExtractVUIDs(listValue):
+                            yield vuid
+
+    valid_vuids = set()
+    if not os.path.isfile(valid_usage_file):
+        print(f'Error: Could not find, or error loading {valid_usage_file}')
+        sys.exit(1)
+    json_file = open(valid_usage_file, 'r', encoding='utf-8')
+    vuid_dict = json.load(json_file)
+    json_file.close()
+    if len(vuid_dict) == 0:
+        print(f'Error: Failed to load {valid_usage_file}')
+        sys.exit(1)
+    for json_vuid_string in ExtractVUIDs(vuid_dict):
+        valid_vuids.add(json_vuid_string)
+
+    # List of VUs that should exists, but have a spec bug
+    for vuid in [
+        # https://gitlab.khronos.org/vulkan/vulkan/-/issues/3582
+        "VUID-VkCopyImageToImageInfoEXT-commonparent",
+        "VUID-vkUpdateDescriptorSetWithTemplate-descriptorSet-parent",
+        "VUID-vkUpdateVideoSessionParametersKHR-videoSessionParameters-parent",
+        "VUID-vkDestroyVideoSessionParametersKHR-videoSessionParameters-parent",
+        "VUID-vkGetDescriptorSetHostMappingVALVE-descriptorSet-parent",
+        ]:
+        valid_vuids.add(vuid)
+
+    return valid_vuids
+
+# Will do a sanity check the VUID exists
+def getVUID(valid_vuids: set, vuid: str, quotes: bool = True) -> str:
+    if vuid not in valid_vuids:
+        print(f'Warning: Could not find {vuid} in validusage.json')
+        vuid = vuid.replace('VUID-', 'UNASSIGNED-')
+    return vuid if not quotes else f'"{vuid}"'
+
 class PlatformGuardHelper():
     """Used to elide platform guards together, so redundant #endif then #ifdefs are removed
-    Note - be sure to call addGuard(None) when done to add a trailing #endif if needed
+    Note - be sure to call add_guard(None) when done to add a trailing #endif if needed
     """
     def __init__(self):
-        self.currentGuard = None
+        self.current_guard = None
 
-    def addGuard(self, guard):
+    def add_guard(self, guard, extra_newline = False):
         out = []
-        if self.currentGuard != guard:
-            if self.currentGuard != None:
-                out.append(f'#endif  // {self.currentGuard}\n')
-            if guard != None:
-                out.append(f'#ifdef {guard}\n')
-            self.currentGuard = guard
+        if self.current_guard != guard and self.current_guard is not None:
+            out.append(f'#endif  // {self.current_guard}\n')
+        if extra_newline:
+            out.append('\n')
+        if self.current_guard != guard and guard is not None:
+            out.append(f'#ifdef {guard}\n')
+        self.current_guard = guard
         return out
+
+# The SPIR-V grammar json doesn't have an easy way to detect these, so have listed by hand
+# If we are missing one, its not critical, the goal of this list is to reduce the generated output size
+def IsNonVulkanSprivCapability(capability):
+    return capability in [
+        'Kernel',
+        'Vector16',
+        'Float16Buffer',
+        'ImageBasic',
+        'ImageReadWrite',
+        'ImageMipmap',
+        'DeviceEnqueue',
+        'SubgroupDispatch',
+        'Pipes',
+        'LiteralSampler',
+        'NamedBarrier',
+        'PipeStorage',
+        'SubgroupShuffleINTEL',
+        'SubgroupShuffleINTEL',
+        'SubgroupBufferBlockIOINTEL',
+        'SubgroupImageBlockIOINTEL',
+        'SubgroupImageMediaBlockIOINTEL',
+        'RoundToInfinityINTEL',
+        'FloatingPointModeINTEL',
+        'IndirectReferencesINTEL',
+        'AsmINTEL',
+        'VectorComputeINTEL',
+        'VectorAnyINTEL',
+        'SubgroupAvcMotionEstimationINTEL',
+        'SubgroupAvcMotionEstimationIntraINTEL',
+        'SubgroupAvcMotionEstimationChromaINTEL',
+        'VariableLengthArrayINTEL',
+        'FunctionFloatControlINTEL',
+        'FPGAMemoryAttributesINTEL',
+        'FPFastMathModeINTEL',
+        'ArbitraryPrecisionIntegersINTEL',
+        'ArbitraryPrecisionFloatingPointINTEL',
+        'UnstructuredLoopControlsINTEL',
+        'FPGALoopControlsINTEL',
+        'KernelAttributesINTEL',
+        'FPGAKernelAttributesINTEL',
+        'FPGAMemoryAccessesINTEL',
+        'FPGAClusterAttributesINTEL',
+        'LoopFuseINTEL',
+        'FPGADSPControlINTEL',
+        'MemoryAccessAliasingINTEL',
+        'FPGAInvocationPipeliningAttributesINTEL',
+        'FPGABufferLocationINTEL',
+        'ArbitraryPrecisionFixedPointINTEL',
+        'USMStorageClassesINTEL',
+        'RuntimeAlignedAttributeINTEL',
+        'IOPipesINTEL',
+        'BlockingPipesINTEL',
+        'FPGARegINTEL',
+        'LongCompositesINTEL',
+        'OptNoneINTEL',
+        'DebugInfoModuleINTEL',
+        'BFloat16ConversionINTEL',
+        'SplitBarrierINTEL',
+        'FPGAClusterAttributesV2INTEL',
+        'FPGAKernelAttributesv2INTEL',
+        'FPMaxErrorINTEL',
+        'FPGALatencyControlINTEL',
+        'FPGAArgumentInterfacesINTEL',
+        'GlobalVariableHostAccessINTEL',
+        'GlobalVariableFPGADecorationsINTEL',
+        'MaskedGatherScatterINTEL',
+        'CacheControlsINTEL',
+        'RegisterLimitsINTEL'
+    ]
diff --git a/scripts/generators/safe_struct_generator.py b/scripts/generators/safe_struct_generator.py
new file mode 100644
index 0000000..b9e0de4
--- /dev/null
+++ b/scripts/generators/safe_struct_generator.py
@@ -0,0 +1,797 @@
+#!/usr/bin/python3 -i
+#
+# Copyright (c) 2015-2024 The Khronos Group Inc.
+# Copyright (c) 2015-2024 Valve Corporation
+# Copyright (c) 2015-2024 LunarG, Inc.
+# Copyright (c) 2015-2024 Google Inc.
+# Copyright (c) 2023-2024 RasterGrid Kft.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+import re
+from generators.vulkan_object import Struct, Member
+from generators.base_generator import BaseGenerator
+from generators.generator_utils import PlatformGuardHelper
+
+class SafeStructOutputGenerator(BaseGenerator):
+    def __init__(self):
+        BaseGenerator.__init__(self)
+
+        # Will skip completly, mainly used for things that have no one consuming the safe struct
+        self.no_autogen = [
+            # These WSI struct have nothing deep to copy, except the WSI releated field which we can't make a copy
+            'VkXlibSurfaceCreateInfoKHR',
+            'VkXcbSurfaceCreateInfoKHR',
+            'VkWaylandSurfaceCreateInfoKHR',
+            'VkAndroidSurfaceCreateInfoKHR',
+            'VkWin32SurfaceCreateInfoKHR',
+            'VkIOSSurfaceCreateInfoMVK',
+            'VkMacOSSurfaceCreateInfoMVK',
+            'VkMetalSurfaceCreateInfoEXT'
+        ]
+
+        # Will skip generating the source logic (to be implemented in vk_safe_struct_manual.cpp)
+        # The header will still be generated
+        self.manual_source = [
+            # This needs to know if we're doing a host or device build, logic becomes complex and very specialized
+            'VkAccelerationStructureBuildGeometryInfoKHR',
+            'VkAccelerationStructureGeometryKHR',
+            # Have a pUsageCounts and ppUsageCounts that is not currently handled in the generated code
+            'VkMicromapBuildInfoEXT',
+            'VkAccelerationStructureTrianglesOpacityMicromapEXT',
+            'VkAccelerationStructureTrianglesDisplacementMicromapNV',
+            # The VkDescriptorType field needs to handle every type which is something best done manually
+            'VkDescriptorDataEXT',
+             # Special case because its pointers may be non-null but ignored
+            'VkGraphicsPipelineCreateInfo',
+            # Special case because it has custom construct parameters
+            'VkPipelineViewportStateCreateInfo',
+        ]
+
+        # For abstract types just want to save the pointer away
+        # since we cannot make a copy.
+        self.abstract_types = [
+            'AHardwareBuffer',
+        ]
+
+        # These 'data' union are decided by the 'type' in the same parent struct
+        self.union_of_pointers = [
+            'VkDescriptorDataEXT',
+        ]
+        self.union_of_pointer_callers = [
+            'VkDescriptorGetInfoEXT',
+        ]
+
+        # Will update the the function interface
+        self.custom_construct_params = {
+            # vku::safe::GraphicsPipelineCreateInfo needs to know if subpass has color and\or depth\stencil attachments to use its pointers
+            'VkGraphicsPipelineCreateInfo' :
+                ', const bool uses_color_attachment, const bool uses_depthstencil_attachment',
+            # vku::safe::PipelineViewportStateCreateInfo needs to know if viewport and scissor is dynamic to use its pointers
+            'VkPipelineViewportStateCreateInfo' :
+                ', const bool is_dynamic_viewports, const bool is_dynamic_scissors',
+            # vku::safe::AccelerationStructureBuildGeometryInfoKHR needs to know if we're doing a host or device build
+            'VkAccelerationStructureBuildGeometryInfoKHR' :
+                ', const bool is_host, const VkAccelerationStructureBuildRangeInfoKHR *build_range_infos',
+            # vku::safe::AccelerationStructureGeometryKHR needs to know if we're doing a host or device build
+            'VkAccelerationStructureGeometryKHR' :
+                ', const bool is_host, const VkAccelerationStructureBuildRangeInfoKHR *build_range_info',
+            # vku::safe::DescriptorDataEXT needs to know what field of union is intialized
+            'VkDescriptorDataEXT' :
+                ', const VkDescriptorType type',
+        }
+
+    # Determine if a structure needs a safe_struct helper function
+    # That is, it has an sType or one of its members is a pointer
+    def needSafeStruct(self, struct: Struct) -> bool:
+        if struct.name in self.no_autogen:
+            return False
+        if 'VkBase' in struct.name:
+            return False #  Ingore structs like VkBaseOutStructure
+        if struct.sType is not None:
+            return True
+        for member in struct.members:
+            if member.pointer:
+                return True
+        return False
+
+    def containsObjectHandle(self, member: Member) -> bool:
+        if member.type in self.vk.handles:
+            return True
+        if member.type in self.vk.structs:
+            for subMember in self.vk.structs[member.type].members:
+                if self.containsObjectHandle(subMember):
+                    return True
+        return False
+
+    def typeContainsObjectHandle(self, handle_type: str, dispatchable: bool) -> bool:
+        if handle_type in self.vk.handles:
+            if dispatchable == self.vk.handles[handle_type].dispatchable:
+                return True
+        # if handle_type is a struct, search its members
+        if handle_type in self.vk.structs:
+            struct = self.vk.structs[handle_type]
+            for member in [x for x in struct.members if x.type in self.vk.handles]:
+                if dispatchable == self.vk.handles[member.type].dispatchable:
+                    return True
+        return False
+
+    def generate(self):
+        self.write(f'''// *** THIS FILE IS GENERATED - DO NOT EDIT ***
+            // See {os.path.basename(__file__)} for modifications
+
+            /***************************************************************************
+            *
+            * Copyright (c) 2015-2024 The Khronos Group Inc.
+            * Copyright (c) 2015-2024 Valve Corporation
+            * Copyright (c) 2015-2024 LunarG, Inc.
+            * Copyright (c) 2015-2024 Google Inc.
+            *
+            * SPDX-License-Identifier: Apache-2.0
+            *
+            ****************************************************************************/\n''')
+        self.write('// NOLINTBEGIN') # Wrap for clang-tidy to ignore
+
+        if self.filename == 'vk_safe_struct.hpp':
+            self.generateHeader()
+        elif self.filename == 'vk_safe_struct_utils.cpp':
+            self.generateUtil()
+        elif self.filename.startswith('vk_safe_struct_'):
+            self.generateSource()
+        else:
+            self.write(f'\nFile name {self.filename} has no code to generate\n')
+
+        self.write('// NOLINTEND') # Wrap for clang-tidy to ignore
+
+    def convertName(self, vk_name):
+        return "safe_" + vk_name
+
+    def generateHeader(self):
+        out = []
+        out.append('''
+            #pragma once
+            #include <vulkan/vulkan.h>
+            #include <algorithm>
+
+            #include <vulkan/utility/vk_safe_struct_utils.hpp>
+
+            namespace vku {
+            \n''')
+
+        guard_helper = PlatformGuardHelper()
+        for struct in [x for x in self.vk.structs.values() if self.needSafeStruct(x)]:
+            safe_name = self.convertName(struct.name)
+            out.extend(guard_helper.add_guard(struct.protect))
+            out.append(f'{"union" if struct.union else "struct"} {safe_name} {{\n')
+            # Can only initialize first member of an Union
+            canInitialize = True
+            copy_pnext = ', bool copy_pnext = true' if struct.sType is not None else ''
+            for member in struct.members:
+                if member.type in self.vk.structs:
+                    if self.needSafeStruct(self.vk.structs[member.type]):
+                        safe_member_type = self.convertName(member.type)
+                        if member.pointer:
+                            pointer = '*' * member.cDeclaration.count('*')
+                            brackets = '' if struct.union else '{}'
+                            out.append(f'{safe_member_type}{pointer} {member.name}{brackets};\n')
+                        else:
+                            out.append(f'{safe_member_type} {member.name};\n')
+                        continue
+
+                explicitInitialize = member.pointer  and 'PFN_' not in member.type and canInitialize
+                initialize = '{}' if explicitInitialize else ''
+                # Prevents union from initializing agian
+                canInitialize = not struct.union if explicitInitialize else canInitialize
+
+                if member.length and self.containsObjectHandle(member) and not member.fixedSizeArray:
+                    out.append(f'    {member.type}* {member.name}{initialize};\n')
+                else:
+                    out.append(f'{member.cDeclaration}{initialize};\n')
+
+            if (struct.name == 'VkDescriptorDataEXT'):
+                out.append('char type_at_end[sizeof(VkDescriptorDataEXT)+sizeof(VkDescriptorGetInfoEXT::type)];')
+
+            constructParam = self.custom_construct_params.get(struct.name, '')
+            out.append(f'''
+                {safe_name}(const {struct.name}* in_struct{constructParam}, PNextCopyState* copy_state = {{}}{copy_pnext});
+                {safe_name}(const {safe_name}& copy_src);
+                {safe_name}& operator=(const {safe_name}& copy_src);
+                {safe_name}();
+                ~{safe_name}();
+                void initialize(const {struct.name}* in_struct{constructParam}, PNextCopyState* copy_state = {{}});
+                void initialize(const {safe_name}* copy_src, PNextCopyState* copy_state = {{}});
+                {struct.name} *ptr() {{ return reinterpret_cast<{struct.name} *>(this); }}
+                {struct.name} const *ptr() const {{ return reinterpret_cast<{struct.name} const *>(this); }}
+                ''')
+
+            if struct.name == 'VkShaderModuleCreateInfo':
+                out.append('''
+                    // Primarily intended for use by GPUAV when replacing shader module code with instrumented code
+                    template<typename Container>
+                    void SetCode(const Container &code) {
+                        delete[] pCode;
+                        codeSize = static_cast<uint32_t>(code.size() * sizeof(uint32_t));
+                        pCode = new uint32_t[code.size()];
+                        std::copy(&code.front(), &code.back() + 1, const_cast<uint32_t*>(pCode));
+                    }
+                    ''')
+            out.append('};\n')
+        out.extend(guard_helper.add_guard(None))
+
+        out.append('''
+                // Safe struct that spans NV and KHR VkRayTracingPipelineCreateInfo structures.
+                // It is a VkRayTracingPipelineCreateInfoKHR and supports construction from
+                // a VkRayTracingPipelineCreateInfoNV.
+                class safe_VkRayTracingPipelineCreateInfoCommon : public safe_VkRayTracingPipelineCreateInfoKHR {
+                public:
+                    safe_VkRayTracingPipelineCreateInfoCommon() : safe_VkRayTracingPipelineCreateInfoKHR() {}
+                    safe_VkRayTracingPipelineCreateInfoCommon(const VkRayTracingPipelineCreateInfoNV *pCreateInfo)
+                        : safe_VkRayTracingPipelineCreateInfoKHR() {
+                        initialize(pCreateInfo);
+                    }
+                    safe_VkRayTracingPipelineCreateInfoCommon(const VkRayTracingPipelineCreateInfoKHR *pCreateInfo)
+                        : safe_VkRayTracingPipelineCreateInfoKHR(pCreateInfo) {}
+
+                    void initialize(const VkRayTracingPipelineCreateInfoNV *pCreateInfo);
+                    void initialize(const VkRayTracingPipelineCreateInfoKHR *pCreateInfo);
+                    uint32_t maxRecursionDepth = 0;  // NV specific
+                };
+                ''')
+        out.append('''
+            } // namespace vku
+        ''')
+        self.write("".join(out))
+
+    def generateUtil(self):
+        out = []
+        out.append('''
+            #include <vulkan/vk_layer.h>
+            #include <vulkan/utility/vk_safe_struct.hpp>
+
+            #include <vector>
+            #include <cstring>
+
+            extern std::vector<std::pair<uint32_t, uint32_t>> custom_stype_info;
+
+            namespace vku {
+            char *SafeStringCopy(const char *in_string) {
+                if (nullptr == in_string) return nullptr;
+                size_t len = std::strlen(in_string);
+                char* dest = new char[len + 1];
+                dest[len] = '\\0';
+                std::memcpy(dest, in_string, len);
+                return dest;
+            }
+
+            ''')
+        out.append('''
+// clang-format off
+void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
+    void *first_pNext{};
+    VkBaseOutStructure *prev_pNext{};
+    void *safe_pNext{};
+
+    while (pNext) {
+        const VkBaseOutStructure *header = reinterpret_cast<const VkBaseOutStructure *>(pNext);
+
+        switch (header->sType) {
+            // Add special-case code to copy beloved secret loader structs
+            // Special-case Loader Instance Struct passed to/from layer in pNext chain
+            case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO: {
+                VkLayerInstanceCreateInfo *struct_copy = new VkLayerInstanceCreateInfo;
+                // TODO: Uses original VkLayerInstanceLink* chain, which should be okay for our uses
+                memcpy(struct_copy, pNext, sizeof(VkLayerInstanceCreateInfo));
+                safe_pNext = struct_copy;
+                break;
+            }
+            // Special-case Loader Device Struct passed to/from layer in pNext chain
+            case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO: {
+                VkLayerDeviceCreateInfo *struct_copy = new VkLayerDeviceCreateInfo;
+                // TODO: Uses original VkLayerDeviceLink*, which should be okay for our uses
+                memcpy(struct_copy, pNext, sizeof(VkLayerDeviceCreateInfo));
+                safe_pNext = struct_copy;
+                break;
+            }
+''')
+        guard_helper = PlatformGuardHelper()
+        for struct in [x for x in self.vk.structs.values() if x.extends]:
+            safe_name = self.convertName(struct.name)
+            out.extend(guard_helper.add_guard(struct.protect))
+            out.append(f'            case {struct.sType}:\n')
+            out.append(f'                safe_pNext = new {safe_name}(reinterpret_cast<const {struct.name} *>(pNext), copy_state, false);\n')
+            out.append('                break;\n')
+        out.extend(guard_helper.add_guard(None))
+
+        out.append('''
+            default: // Encountered an unknown sType -- skip (do not copy) this entry in the chain
+                // If sType is in custom list, construct blind copy
+                for (auto item : custom_stype_info) {
+                    if (item.first == static_cast<uint32_t>(header->sType)) {
+                        safe_pNext = malloc(item.second);
+                        memcpy(safe_pNext, header, item.second);
+                    }
+                }
+                break;
+        }
+        if (!first_pNext) {
+            first_pNext = safe_pNext;
+        }
+        pNext = header->pNext;
+        if (prev_pNext && safe_pNext) {
+            prev_pNext->pNext = (VkBaseOutStructure*)safe_pNext;
+        }
+        if (safe_pNext) {
+            prev_pNext = (VkBaseOutStructure*)safe_pNext;
+        }
+        safe_pNext = nullptr;
+    }
+
+    return first_pNext;
+}
+
+void FreePnextChain(const void *pNext) {
+    if (!pNext) return;
+
+    auto header = reinterpret_cast<const VkBaseOutStructure *>(pNext);
+
+    switch (header->sType) {
+        // Special-case Loader Instance Struct passed to/from layer in pNext chain
+        case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:
+            FreePnextChain(header->pNext);
+            delete reinterpret_cast<const VkLayerInstanceCreateInfo *>(pNext);
+            break;
+        // Special-case Loader Device Struct passed to/from layer in pNext chain
+        case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:
+            FreePnextChain(header->pNext);
+            delete reinterpret_cast<const VkLayerDeviceCreateInfo *>(pNext);
+            break;
+''')
+
+        for struct in [x for x in self.vk.structs.values() if x.extends]:
+            safe_name = self.convertName(struct.name)
+            out.extend(guard_helper.add_guard(struct.protect))
+            out.append(f'        case {struct.sType}:\n')
+            out.append(f'            delete reinterpret_cast<const {safe_name} *>(header);\n')
+            out.append('            break;\n')
+        out.extend(guard_helper.add_guard(None))
+
+        out.append('''
+        default: // Encountered an unknown sType
+            // If sType is in custom list, free custom struct memory and clean up
+            for (auto item : custom_stype_info) {
+                if (item.first == static_cast<uint32_t>(header->sType)) {
+                    if (header->pNext) {
+                        FreePnextChain(header->pNext);
+                    }
+                    free(const_cast<void *>(pNext));
+                    pNext = nullptr;
+                    break;
+                }
+            }
+            if (pNext) {
+                FreePnextChain(header->pNext);
+            }
+            break;
+    }
+}''')
+        out.append('// clang-format on\n')
+        out.append('''
+            } // namespace vku
+        ''')
+        self.write("".join(out))
+
+    def generateSource(self):
+        out = []
+        out.append('''
+            #include <vulkan/utility/vk_safe_struct.hpp>
+            #include <vulkan/utility/vk_struct_helper.hpp>
+
+            #include <cstring>
+
+            namespace vku {
+            ''')
+
+        custom_defeault_construct_txt = {}
+
+        custom_construct_txt = {
+                # VkWriteDescriptorSet is special case because pointers may be non-null but ignored
+                'VkWriteDescriptorSet' : '''
+                    switch (descriptorType) {
+                        case VK_DESCRIPTOR_TYPE_SAMPLER:
+                        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+                        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+                        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+                        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+                        case VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM:
+                        case VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM:
+                        if (descriptorCount && in_struct->pImageInfo) {
+                            pImageInfo = new VkDescriptorImageInfo[descriptorCount];
+                            for (uint32_t i = 0; i < descriptorCount; ++i) {
+                                pImageInfo[i] = in_struct->pImageInfo[i];
+                            }
+                        }
+                        break;
+                        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+                        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+                        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+                        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+                        if (descriptorCount && in_struct->pBufferInfo) {
+                            pBufferInfo = new VkDescriptorBufferInfo[descriptorCount];
+                            for (uint32_t i = 0; i < descriptorCount; ++i) {
+                                pBufferInfo[i] = in_struct->pBufferInfo[i];
+                            }
+                        }
+                        break;
+                        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+                        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+                        if (descriptorCount && in_struct->pTexelBufferView) {
+                            pTexelBufferView = new VkBufferView[descriptorCount];
+                            for (uint32_t i = 0; i < descriptorCount; ++i) {
+                                pTexelBufferView[i] = in_struct->pTexelBufferView[i];
+                            }
+                        }
+                        break;
+                        default:
+                        break;
+                    }
+                ''',
+                'VkShaderModuleCreateInfo' : '''
+                    if (in_struct->pCode) {
+                        pCode = reinterpret_cast<uint32_t *>(new uint8_t[codeSize]);
+                        memcpy((void *)pCode, (void *)in_struct->pCode, codeSize);
+                    }
+                ''',
+                # VkFrameBufferCreateInfo is special case because its pAttachments pointer may be non-null but ignored
+                'VkFramebufferCreateInfo' : '''
+                    if (attachmentCount && in_struct->pAttachments && !(flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT)) {
+                        pAttachments = new VkImageView[attachmentCount];
+                        for (uint32_t i = 0; i < attachmentCount; ++i) {
+                            pAttachments[i] = in_struct->pAttachments[i];
+                        }
+                    }
+                ''',
+                # VkDescriptorSetLayoutBinding is special case because its pImmutableSamplers pointer may be non-null but ignored
+                'VkDescriptorSetLayoutBinding' : '''
+                    const bool sampler_type = in_struct->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || in_struct->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+                    if (descriptorCount && in_struct->pImmutableSamplers && sampler_type) {
+                        pImmutableSamplers = new VkSampler[descriptorCount];
+                        for (uint32_t i = 0; i < descriptorCount; ++i) {
+                            pImmutableSamplers[i] = in_struct->pImmutableSamplers[i];
+                        }
+                    }
+                ''',
+                'VkPipelineRenderingCreateInfo': '''
+                    bool custom_init = copy_state && copy_state->init;
+                    if (custom_init) {
+                        custom_init = copy_state->init(reinterpret_cast<VkBaseOutStructure*>(this), reinterpret_cast<const VkBaseOutStructure*>(in_struct));
+                    }
+                    if (!custom_init) {
+                        // The custom iniitalization was not used, so do the regular initialization
+                        if (in_struct->pColorAttachmentFormats) {
+                            pColorAttachmentFormats = new VkFormat[in_struct->colorAttachmentCount];
+                            memcpy ((void *)pColorAttachmentFormats, (void *)in_struct->pColorAttachmentFormats, sizeof(VkFormat)*in_struct->colorAttachmentCount);
+                        }
+                    }
+                ''',
+                # TODO: VkPushDescriptorSetWithTemplateInfoKHR needs a custom constructor to handle pData
+                # https://github.com/KhronosGroup/Vulkan-ValidationLayers/issues/7169
+                'VkPushDescriptorSetWithTemplateInfoKHR': '''
+                ''',
+            }
+
+        custom_copy_txt = {
+                'VkFramebufferCreateInfo' : '''
+                    pNext = SafePnextCopy(copy_src.pNext);
+                    if (attachmentCount && copy_src.pAttachments && !(flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT)) {
+                        pAttachments = new VkImageView[attachmentCount];
+                        for (uint32_t i = 0; i < attachmentCount; ++i) {
+                            pAttachments[i] = copy_src.pAttachments[i];
+                        }
+                    }
+                ''',
+                'VkPipelineRenderingCreateInfo': '''
+                    if (copy_src.pColorAttachmentFormats) {
+                        pColorAttachmentFormats = new VkFormat[copy_src.colorAttachmentCount];
+                        memcpy ((void *)pColorAttachmentFormats, (void *)copy_src.pColorAttachmentFormats, sizeof(VkFormat)*copy_src.colorAttachmentCount);
+                    }
+                '''
+            }
+
+        custom_destruct_txt = {
+                'VkShaderModuleCreateInfo' : '''
+                    if (pCode)
+                        delete[] reinterpret_cast<const uint8_t *>(pCode);
+                ''',
+            }
+
+        member_init_transforms = {
+            'queueFamilyIndexCount': lambda m: f'{m.name}(0)'
+        }
+
+        def qfi_construct(item, member):
+            true_index_setter = lambda i: f'{i}queueFamilyIndexCount = in_struct->queueFamilyIndexCount;\n'
+            false_index_setter = lambda i: f'{i}queueFamilyIndexCount = 0;\n'
+            if item.name == 'VkSwapchainCreateInfoKHR':
+                return (f'(in_struct->imageSharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->{member.name}', true_index_setter, false_index_setter)
+            else:
+                return (f'(in_struct->sharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->{member.name}', true_index_setter, false_index_setter)
+
+        # map of:
+        #  <member name>: function(item, member) -> (condition, true statement, false statement)
+        member_construct_conditions = {
+            'pQueueFamilyIndices': qfi_construct
+        }
+
+        # Find what types of safe structs need to be generated based on output file name
+        splitRegex = r'.*';
+        if self.filename.endswith('_khr.cpp'):
+            splitRegex = r'.*KHR$'
+        elif self.filename.endswith('_ext.cpp'):
+            splitRegex = r'.*EXT$'
+        elif self.filename.endswith('_vendor.cpp'):
+            splitRegex = r'^(?!.*(KHR|EXT)$).*[A-Z]$' # Matches all words finishing with an upper case letter, but not ending with KHRor EXT
+        else: # elif self.filename.endswith('_core.cpp'):
+            splitRegex = r'.*[a-z0-9]$'
+
+        guard_helper = PlatformGuardHelper()
+
+        for struct in [x for x in self.vk.structs.values() if self.needSafeStruct(x) and x.name not in self.manual_source and re.match(splitRegex, x.name)]:
+            out.extend(guard_helper.add_guard(struct.protect))
+
+            init_list = ''          # list of members in struct constructor initializer
+            default_init_list = ''  # Default constructor just inits ptrs to nullptr in initializer
+            init_func_txt = ''      # Txt for initialize() function that takes struct ptr and inits members
+            construct_txt = ''      # Body of constuctor as well as body of initialize() func following init_func_txt
+            destruct_txt = ''
+
+            has_pnext = struct.sType is not None
+            copy_pnext = ''
+            copy_pnext_if = ''
+            copy_strings = ''
+            for member in struct.members:
+                m_type = member.type
+                m_type_safe = False
+                if member.name == 'pNext':
+                    copy_pnext = 'pNext = SafePnextCopy(in_struct->pNext, copy_state);\n'
+                    copy_pnext_if = '''
+                    if (copy_pnext) {
+                        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+                    }'''
+                if member.type in self.vk.structs and self.needSafeStruct(self.vk.structs[member.type]):
+                    m_type = self.convertName(member.type)
+                    m_type_safe = True;
+
+                if member.pointer and not m_type_safe and 'PFN_' not in member.type and not self.typeContainsObjectHandle(member.type, False):
+                    # Ptr types w/o a safe_struct, for non-null case need to allocate new ptr and copy data in
+                    if m_type in ['void', 'char']:
+                        if member.name != 'pNext':
+                            if m_type == 'char':
+                                # Create deep copies of strings
+                                if member.length:
+                                    copy_strings += f'''
+                                        char **tmp_{member.name} = new char *[in_struct->{member.length}];
+                                        for (uint32_t i = 0; i < {member.length}; ++i) {{
+                                            tmp_{member.name}[i] = SafeStringCopy(in_struct->{member.name}[i]);
+                                        }}
+                                        {member.name} = tmp_{member.name};'''
+
+                                    destruct_txt += f'''
+                                        if ({member.name}) {{
+                                            for (uint32_t i = 0; i < {member.length}; ++i) {{
+                                                delete [] {member.name}[i];
+                                            }}
+                                            delete [] {member.name};
+                                        }}'''
+                                else:
+                                    copy_strings += f'{member.name} = SafeStringCopy(in_struct->{member.name});\n'
+                                    destruct_txt += f'if ({member.name}) delete [] {member.name};\n'
+                            else:
+                                # We need a deep copy of pData / dataSize combos
+                                if member.name == 'pData':
+                                    init_list += f'\n    {member.name}(nullptr),'
+                                    construct_txt += '''
+                                        if (in_struct->pData != nullptr) {
+                                            auto temp = new std::byte[in_struct->dataSize];
+                                            std::memcpy(temp, in_struct->pData, in_struct->dataSize);
+                                            pData = temp;
+                                        }
+                                        '''
+
+                                    destruct_txt  += '''
+                                        if (pData != nullptr) {
+                                            auto temp = reinterpret_cast<const std::byte*>(pData);
+                                            delete [] temp;
+                                        }
+                                        '''
+                                else:
+                                    init_list += f'\n{member.name}(in_struct->{member.name}),'
+                                    init_func_txt += f'{member.name} = in_struct->{member.name};\n'
+                        default_init_list += f'\n{member.name}(nullptr),'
+                    else:
+                        default_init_list += f'\n{member.name}(nullptr),'
+                        init_list += f'\n{member.name}(nullptr),'
+                        if m_type in self.abstract_types:
+                            construct_txt += f'{member.name} = in_struct->{member.name};\n'
+                        else:
+                            init_func_txt += f'{member.name} = nullptr;\n'
+                            if not member.fixedSizeArray and (member.length is None or '/' in member.length):
+                                construct_txt += f'''
+                                    if (in_struct->{member.name}) {{
+                                            {member.name} = new {m_type}(*in_struct->{member.name});
+                                        }}
+                                    '''
+                                destruct_txt += f'if ({member.name})\n'
+                                destruct_txt += f'    delete {member.name};\n'
+                            else:
+                                # Prepend struct members with struct name
+                                decorated_length = member.length
+                                for other_member in struct.members:
+                                    decorated_length = re.sub(r'\b({})\b'.format(other_member.name), r'in_struct->\1', decorated_length)
+                                try:
+                                    concurrent_clause = member_construct_conditions[member.name](struct, member)
+                                except:
+                                    concurrent_clause = (f'in_struct->{member.name}', lambda x: '')
+                                construct_txt += f'''
+                                    if ({concurrent_clause[0]}) {{
+                                        {member.name} = new {m_type}[{decorated_length}];
+                                        memcpy ((void *){member.name}, (void *)in_struct->{member.name}, sizeof({m_type})*{decorated_length});
+                                        {concurrent_clause[1]('        ')}'''
+                                if len(concurrent_clause) > 2:
+                                    construct_txt += '} else {\n'
+                                    construct_txt += concurrent_clause[2]('        ')
+                                construct_txt += '}\n'
+                                destruct_txt += f'if ({member.name})\n'
+                                destruct_txt += f'    delete[] {member.name};\n'
+                elif member.fixedSizeArray or member.length is not None:
+                    if member.fixedSizeArray:
+                        construct_txt += f'''
+                            for (uint32_t i = 0; i < {member.fixedSizeArray[0]}; ++i) {{
+                                    {member.name}[i] = in_struct->{member.name}[i];
+                                }}
+                            '''
+                    else:
+                        # Init array ptr to NULL
+                        default_init_list += f'\n{member.name}(nullptr),'
+                        init_list += f'\n{member.name}(nullptr),'
+                        init_func_txt += f'{member.name} = nullptr;\n'
+                        array_element = f'in_struct->{member.name}[i]'
+                        if member.type in self.vk.structs and self.needSafeStruct(self.vk.structs[member.type]):
+                            array_element = f'{member.type}(&in_struct->safe_{member.name}[i])'
+                        construct_txt += f'if ({member.length} && in_struct->{member.name}) {{\n'
+                        construct_txt += f'    {member.name} = new {m_type}[{member.length}];\n'
+                        destruct_txt += f'if ({member.name})\n'
+                        destruct_txt += f'    delete[] {member.name};\n'
+                        construct_txt += f'for (uint32_t i = 0; i < {member.length}; ++i) {{\n'
+                        if m_type_safe:
+                            construct_txt += f'{member.name}[i].initialize(&in_struct->{member.name}[i]);\n'
+                        else:
+                            construct_txt += f'{member.name}[i] = {array_element};\n'
+                        construct_txt += '}\n'
+                        construct_txt += '}\n'
+                elif member.pointer and 'PFN_' not in member.type:
+                    default_init_list += f'\n{member.name}(nullptr),'
+                    init_list += f'\n{member.name}(nullptr),'
+                    init_func_txt += f'{member.name} = nullptr;\n'
+                    construct_txt += f'if (in_struct->{member.name})\n'
+                    construct_txt += f'    {member.name} = new {m_type}(in_struct->{member.name});\n'
+                    destruct_txt += f'if ({member.name})\n'
+                    destruct_txt += f'    delete {member.name};\n'
+                elif m_type_safe and member.type in self.union_of_pointers:
+                    init_list += f'\n{member.name}(&in_struct->{member.name}, in_struct->type),'
+                    init_func_txt += f'{member.name}.initialize(&in_struct->{member.name}, in_struct->type);\n'
+                elif m_type_safe:
+                    init_list += f'\n{member.name}(&in_struct->{member.name}),'
+                    init_func_txt += f'{member.name}.initialize(&in_struct->{member.name});\n'
+                else:
+                    try:
+                        init_list += f'\n{member_init_transforms[member.name](member)},'
+                    except:
+                        init_list += f'\n{member.name}(in_struct->{member.name}),'
+                        init_func_txt += f'{member.name} = in_struct->{member.name};\n'
+                    if not struct.union:
+                        if member.name == 'sType' and struct.sType:
+                            default_init_list += f'\n{member.name}({struct.sType}),'
+                        else:
+                            default_init_list += f'\n{member.name}(),'
+            if '' != init_list:
+                init_list = init_list[:-1] # hack off final comma
+
+            if struct.name in custom_construct_txt:
+                construct_txt = custom_construct_txt[struct.name]
+
+            construct_txt = copy_strings + construct_txt
+
+            if struct.name in custom_destruct_txt:
+                destruct_txt = custom_destruct_txt[struct.name]
+
+            copy_pnext_param = ''
+            if has_pnext:
+                copy_pnext_param = ', bool copy_pnext'
+                destruct_txt += '    FreePnextChain(pNext);\n'
+
+            safe_name = self.convertName(struct.name)
+            if struct.union:
+                if struct.name in self.union_of_pointers:
+                    default_init_list = ' type_at_end {0},'
+                    out.append(f'''
+                        {safe_name}::{safe_name}(const {struct.name}* in_struct{self.custom_construct_params.get(struct.name, '')}, [[maybe_unused]] PNextCopyState* copy_state{copy_pnext_param})
+                        {{
+                        {copy_pnext + construct_txt}}}
+                        ''')
+                else:
+                    # Unions don't allow multiple members in the initialization list, so just call initialize
+                    out.append(f'''
+                        {safe_name}::{safe_name}(const {struct.name}* in_struct{self.custom_construct_params.get(struct.name, '')}, PNextCopyState*)
+                        {{
+                            initialize(in_struct);
+                        }}
+                        ''')
+            else:
+                out.append(f'''
+                    {safe_name}::{safe_name}(const {struct.name}* in_struct{self.custom_construct_params.get(struct.name, '')}, [[maybe_unused]] PNextCopyState* copy_state{copy_pnext_param}) :{init_list}
+                    {{
+                    {copy_pnext_if + construct_txt}}}
+                    ''')
+            if '' != default_init_list:
+                default_init_list = f' :{default_init_list[:-1]}'
+            default_init_body = '\n' + custom_defeault_construct_txt[struct.name] if struct.name in custom_defeault_construct_txt else ''
+            out.append(f'''
+                {safe_name}::{safe_name}(){default_init_list}
+                {{{default_init_body}}}
+                ''')
+            # Create slight variation of init and construct txt for copy constructor that takes a copy_src object reference vs. struct ptr
+            construct_txt = copy_pnext + construct_txt
+            copy_construct_init = init_func_txt.replace('in_struct->', 'copy_src.')
+            copy_construct_init = copy_construct_init.replace(', copy_state', '')
+            if struct.name in self.union_of_pointer_callers:
+                copy_construct_init = copy_construct_init.replace(', copy_src.type', '')
+            # Pass object to copy constructors
+            copy_construct_txt = re.sub('(new \\w+)\\(in_struct->', '\\1(*copy_src.', construct_txt)
+            # Modify remaining struct refs for copy_src object
+            copy_construct_txt = copy_construct_txt.replace('in_struct->', 'copy_src.')
+            # Modify remaining struct refs for copy_src object
+            copy_construct_txt = copy_construct_txt .replace(', copy_state', '')
+            if struct.name in custom_copy_txt:
+                copy_construct_txt = custom_copy_txt[struct.name]
+            copy_assign_txt = '    if (&copy_src == this) return *this;\n\n' + destruct_txt + '\n' + copy_construct_init + copy_construct_txt + '\n    return *this;'
+            # Copy constructor
+            out.append(f'''
+                {safe_name}::{safe_name}(const {safe_name}& copy_src)
+                {{
+                {copy_construct_init}{copy_construct_txt}}}
+                ''')
+            # Copy assignment operator
+            out.append(f'''
+                {safe_name}& {safe_name}::operator=(const {safe_name}& copy_src)\n{{
+                {copy_assign_txt}
+                }}
+                ''')
+            out.append(f'''
+                {safe_name}::~{safe_name}()
+                {{
+                {destruct_txt}}}
+                ''')
+            out.append(f'''
+                void {safe_name}::initialize(const {struct.name}* in_struct{self.custom_construct_params.get(struct.name, '')}, [[maybe_unused]] PNextCopyState* copy_state)
+                {{
+                {destruct_txt}{init_func_txt}{construct_txt}}}
+                ''')
+            # Copy initializer uses same txt as copy constructor but has a ptr and not a reference
+            init_copy = copy_construct_init.replace('copy_src.', 'copy_src->')
+            # Replace '&copy_src' with 'copy_src' unless it's followed by a dereference
+            init_copy = re.sub(r'&copy_src(?!->)', 'copy_src', init_copy)
+            init_construct = copy_construct_txt.replace('copy_src.', 'copy_src->')
+            # Replace '&copy_src' with 'copy_src' unless it's followed by a dereference
+            init_construct = re.sub(r'&copy_src(?!->)', 'copy_src', init_construct)
+            out.append(f'''
+                void {safe_name}::initialize(const {safe_name}* copy_src, [[maybe_unused]] PNextCopyState* copy_state)
+                {{
+                {init_copy}{init_construct}}}
+                ''')
+        out.extend(guard_helper.add_guard(None))
+        out.append('''
+            } // namespace vku
+        ''')
+
+        self.write("".join(out))
diff --git a/scripts/generators/struct_helper_generator.py b/scripts/generators/struct_helper_generator.py
index 44bc563..b84a1ca 100644
--- a/scripts/generators/struct_helper_generator.py
+++ b/scripts/generators/struct_helper_generator.py
@@ -53,9 +53,9 @@ VkStructureType GetSType() {
         guard_helper = PlatformGuardHelper()
 
         for struct in [x for x in self.vk.structs.values() if x.sType]:
-            out.extend(guard_helper.addGuard(struct.protect))
+            out.extend(guard_helper.add_guard(struct.protect))
             out.append(f'template <> inline VkStructureType GetSType<{struct.name}>() {{ return {struct.sType}; }}\n')
-        out.extend(guard_helper.addGuard(None))
+        out.extend(guard_helper.add_guard(None))
         out.append('''
 // Find an entry of the given type in the const pNext chain
 // returns nullptr if the entry is not found
@@ -132,9 +132,9 @@ template<typename T> VkObjectType GetObjectType() {
 #if VK_USE_64_BIT_PTR_DEFINES == 1
 ''')
         for handle in self.vk.handles.values():
-            out.extend(guard_helper.addGuard(handle.protect))
+            out.extend(guard_helper.add_guard(handle.protect))
             out.append(f'template<> inline VkObjectType GetObjectType<{handle.name}>() {{ return {handle.type}; }}\n')
-        out.extend(guard_helper.addGuard(None))
+        out.extend(guard_helper.add_guard(None))
         out.append('''
 #endif // VK_USE_64_BIT_PTR_DEFINES == 1
 } // namespace vku
diff --git a/scripts/generators/vulkan_object.py b/scripts/generators/vulkan_object.py
index b5741e6..642e817 100644
--- a/scripts/generators/vulkan_object.py
+++ b/scripts/generators/vulkan_object.py
@@ -1,8 +1,7 @@
 #!/usr/bin/python3 -i
 #
-# Copyright 2023 The Khronos Group Inc.
-# Copyright 2023 Valve Corporation
-# Copyright 2023 LunarG, Inc.
+# Copyright (c) 2023-2024 Valve Corporation
+# Copyright (c) 2023-2024 LunarG, Inc.
 #
 # SPDX-License-Identifier: Apache-2.0
 
@@ -33,7 +32,7 @@ class Extension:
     # Quotes allow us to forward declare the dataclass
     commands: list['Command'] = field(default_factory=list, init=False)
     enums:    list['Enum']    = field(default_factory=list, init=False)
-    bitmask:  list['Bitmask'] = field(default_factory=list, init=False)
+    bitmasks: list['Bitmask'] = field(default_factory=list, init=False)
     # Use the Enum name to see what fields are extended
     enumFields: dict[str, list['EnumField']] = field(default_factory=dict, init=False)
     # Use the Bitmaks name to see what flags are extended
@@ -65,6 +64,9 @@ class Handle:
 
     dispatchable: bool
 
+    def __lt__(self, other):
+        return self.name < other.name
+
 @dataclass
 class Param:
     """<command/param>"""
@@ -92,6 +94,9 @@ class Param:
     #   - VkStructureType sType
     cDeclaration: str
 
+    def __lt__(self, other):
+        return self.name < other.name
+
 class Queues(IntFlag):
     TRANSFER       = auto() # VK_QUEUE_TRANSFER_BIT
     GRAPHICS       = auto() # VK_QUEUE_GRAPHICS_BIT
@@ -153,6 +158,9 @@ class Command:
     #   (const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
     cFunctionPointer: str
 
+    def __lt__(self, other):
+        return self.name < other.name
+
 @dataclass
 class Member:
     """<member>"""
@@ -179,6 +187,9 @@ class Member:
     #   - VkStructureType sType
     cDeclaration: str
 
+    def __lt__(self, other):
+        return self.name < other.name
+
 @dataclass
 class Struct:
     """<type category="struct"> or <type category="union">"""
@@ -200,6 +211,9 @@ class Struct:
     extends: list[str] # Struct names that this struct extends
     extendedBy: list[str] # Struct names that can be extended by this struct
 
+    def __lt__(self, other):
+        return self.name < other.name
+
 @dataclass
 class EnumField:
     """<enum> of type enum"""
@@ -210,6 +224,9 @@ class EnumField:
     # some fields are enabled from 2 extensions (ex) VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR)
     extensions: list[Extension] # None if part of 1.0 core
 
+    def __lt__(self, other):
+        return self.name < other.name
+
 @dataclass
 class Enum:
     """<enums> of type enum"""
@@ -225,6 +242,9 @@ class Enum:
     # Unique list of all extension that are involved in 'fields' (superset of 'extensions')
     fieldExtensions: list[Extension]
 
+    def __lt__(self, other):
+        return self.name < other.name
+
 @dataclass
 class Flag:
     """<enum> of type bitmask"""
@@ -236,7 +256,10 @@ class Flag:
     zero: bool     # if true, the value is zero (ex) VK_PIPELINE_STAGE_NONE)
 
     # some fields are enabled from 2 extensions (ex) VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT)
-    extensions: list[str] # None if part of 1.0 core
+    extensions: list[Extension] # None if part of 1.0 core
+
+    def __lt__(self, other):
+        return self.name < other.name
 
 @dataclass
 class Bitmask:
@@ -246,12 +269,17 @@ class Bitmask:
     protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
 
     bitWidth: int # 32 or 64
+    returnedOnly: bool
+
     flags: list[Flag]
 
     extensions: list[Extension] # None if part of 1.0 core
     # Unique list of all extension that are involved in 'flag' (superset of 'extensions')
     flagExtensions: list[Extension]
 
+    def __lt__(self, other):
+        return self.name < other.name
+
 @dataclass
 class FormatComponent:
     """<format/component>"""
diff --git a/scripts/gn/stub.cpp b/scripts/gn/stub.cpp
index b5e148c..a9c729d 100644
--- a/scripts/gn/stub.cpp
+++ b/scripts/gn/stub.cpp
@@ -1,6 +1,6 @@
-// Copyright 2023 The Khronos Group Inc.
-// Copyright 2023 Valve Corporation
-// Copyright 2023 LunarG, Inc.
+// Copyright 2023-2024 The Khronos Group Inc.
+// Copyright 2023-2024 Valve Corporation
+// Copyright 2023-2024 LunarG, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
 
@@ -9,6 +9,9 @@
 #include <vulkan/layer/vk_layer_settings.h>
 #include <vulkan/layer/vk_layer_settings.hpp>
 #include <vulkan/utility/vk_dispatch_table.h>
+#include <vulkan/utility/vk_concurrent_unordered_map.hpp>
 #include <vulkan/utility/vk_format_utils.h>
 #include <vulkan/utility/vk_struct_helper.hpp>
+#include <vulkan/utility/vk_safe_struct.hpp>
+#include <vulkan/utility/vk_safe_struct_utils.hpp>
 #include <vulkan/vk_enum_string_helper.h>
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index eb36009..744b4e4 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -28,6 +28,7 @@ elseif(MSVC)
     target_compile_options(VulkanCompilerConfiguration INTERFACE
         /W4
         /we5038 # Enable warning about MIL ordering in constructors
+	/wd4324 # Disable warning about alignment padding
     )
 
     # Enforce stricter ISO C++
@@ -90,4 +91,7 @@ if (VUL_WERROR)
     endif()
 endif()
 
+option(VUL_MOCK_ANDROID "Enable building for Android on desktop for testing with MockICD setup")
+
 add_subdirectory(layer)
+add_subdirectory(vulkan)
diff --git a/src/vulkan/CMakeLists.txt b/src/vulkan/CMakeLists.txt
new file mode 100644
index 0000000..04e7f0a
--- /dev/null
+++ b/src/vulkan/CMakeLists.txt
@@ -0,0 +1,30 @@
+# Copyright 2023 The Khronos Group Inc.
+# Copyright 2023 Valve Corporation
+# Copyright 2023 LunarG, Inc.
+#
+# SPDX-License-Identifier: Apache-2.0
+set(CMAKE_FOLDER "${CMAKE_FOLDER}/VulkanSafeStruct")
+
+add_library(VulkanSafeStruct STATIC)
+add_library(Vulkan::SafeStruct ALIAS VulkanSafeStruct)
+
+target_sources(VulkanSafeStruct PRIVATE
+    vk_safe_struct_core.cpp
+    vk_safe_struct_ext.cpp
+    vk_safe_struct_khr.cpp
+    vk_safe_struct_utils.cpp
+    vk_safe_struct_vendor.cpp
+    vk_safe_struct_manual.cpp
+)
+
+target_link_Libraries(VulkanSafeStruct
+   PUBLIC
+      Vulkan::Headers
+      Vulkan::UtilityHeaders
+   PRIVATE
+      Vulkan::CompilerConfiguration
+)
+
+if(VUL_MOCK_ANDROID)
+	target_compile_definitions(VulkanSafeStruct PUBLIC VK_USE_PLATFORM_ANDROID_KHR VUL_MOCK_ANDROID)
+endif()
diff --git a/src/vulkan/vk_safe_struct_core.cpp b/src/vulkan/vk_safe_struct_core.cpp
new file mode 100644
index 0000000..21e9108
--- /dev/null
+++ b/src/vulkan/vk_safe_struct_core.cpp
@@ -0,0 +1,18773 @@
+// *** THIS FILE IS GENERATED - DO NOT EDIT ***
+// See safe_struct_generator.py for modifications
+
+/***************************************************************************
+ *
+ * Copyright (c) 2015-2024 The Khronos Group Inc.
+ * Copyright (c) 2015-2024 Valve Corporation
+ * Copyright (c) 2015-2024 LunarG, Inc.
+ * Copyright (c) 2015-2024 Google Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ ****************************************************************************/
+
+// NOLINTBEGIN
+
+#include <vulkan/utility/vk_safe_struct.hpp>
+#include <vulkan/utility/vk_struct_helper.hpp>
+
+#include <cstring>
+
+namespace vku {
+
+safe_VkBufferMemoryBarrier::safe_VkBufferMemoryBarrier(const VkBufferMemoryBarrier* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      srcAccessMask(in_struct->srcAccessMask),
+      dstAccessMask(in_struct->dstAccessMask),
+      srcQueueFamilyIndex(in_struct->srcQueueFamilyIndex),
+      dstQueueFamilyIndex(in_struct->dstQueueFamilyIndex),
+      buffer(in_struct->buffer),
+      offset(in_struct->offset),
+      size(in_struct->size) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkBufferMemoryBarrier::safe_VkBufferMemoryBarrier()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER),
+      pNext(nullptr),
+      srcAccessMask(),
+      dstAccessMask(),
+      srcQueueFamilyIndex(),
+      dstQueueFamilyIndex(),
+      buffer(),
+      offset(),
+      size() {}
+
+safe_VkBufferMemoryBarrier::safe_VkBufferMemoryBarrier(const safe_VkBufferMemoryBarrier& copy_src) {
+    sType = copy_src.sType;
+    srcAccessMask = copy_src.srcAccessMask;
+    dstAccessMask = copy_src.dstAccessMask;
+    srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex;
+    dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex;
+    buffer = copy_src.buffer;
+    offset = copy_src.offset;
+    size = copy_src.size;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBufferMemoryBarrier& safe_VkBufferMemoryBarrier::operator=(const safe_VkBufferMemoryBarrier& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    srcAccessMask = copy_src.srcAccessMask;
+    dstAccessMask = copy_src.dstAccessMask;
+    srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex;
+    dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex;
+    buffer = copy_src.buffer;
+    offset = copy_src.offset;
+    size = copy_src.size;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkBufferMemoryBarrier::~safe_VkBufferMemoryBarrier() { FreePnextChain(pNext); }
+
+void safe_VkBufferMemoryBarrier::initialize(const VkBufferMemoryBarrier* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    srcAccessMask = in_struct->srcAccessMask;
+    dstAccessMask = in_struct->dstAccessMask;
+    srcQueueFamilyIndex = in_struct->srcQueueFamilyIndex;
+    dstQueueFamilyIndex = in_struct->dstQueueFamilyIndex;
+    buffer = in_struct->buffer;
+    offset = in_struct->offset;
+    size = in_struct->size;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkBufferMemoryBarrier::initialize(const safe_VkBufferMemoryBarrier* copy_src,
+                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    srcAccessMask = copy_src->srcAccessMask;
+    dstAccessMask = copy_src->dstAccessMask;
+    srcQueueFamilyIndex = copy_src->srcQueueFamilyIndex;
+    dstQueueFamilyIndex = copy_src->dstQueueFamilyIndex;
+    buffer = copy_src->buffer;
+    offset = copy_src->offset;
+    size = copy_src->size;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkImageMemoryBarrier::safe_VkImageMemoryBarrier(const VkImageMemoryBarrier* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      srcAccessMask(in_struct->srcAccessMask),
+      dstAccessMask(in_struct->dstAccessMask),
+      oldLayout(in_struct->oldLayout),
+      newLayout(in_struct->newLayout),
+      srcQueueFamilyIndex(in_struct->srcQueueFamilyIndex),
+      dstQueueFamilyIndex(in_struct->dstQueueFamilyIndex),
+      image(in_struct->image),
+      subresourceRange(in_struct->subresourceRange) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImageMemoryBarrier::safe_VkImageMemoryBarrier()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER),
+      pNext(nullptr),
+      srcAccessMask(),
+      dstAccessMask(),
+      oldLayout(),
+      newLayout(),
+      srcQueueFamilyIndex(),
+      dstQueueFamilyIndex(),
+      image(),
+      subresourceRange() {}
+
+safe_VkImageMemoryBarrier::safe_VkImageMemoryBarrier(const safe_VkImageMemoryBarrier& copy_src) {
+    sType = copy_src.sType;
+    srcAccessMask = copy_src.srcAccessMask;
+    dstAccessMask = copy_src.dstAccessMask;
+    oldLayout = copy_src.oldLayout;
+    newLayout = copy_src.newLayout;
+    srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex;
+    dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex;
+    image = copy_src.image;
+    subresourceRange = copy_src.subresourceRange;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImageMemoryBarrier& safe_VkImageMemoryBarrier::operator=(const safe_VkImageMemoryBarrier& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    srcAccessMask = copy_src.srcAccessMask;
+    dstAccessMask = copy_src.dstAccessMask;
+    oldLayout = copy_src.oldLayout;
+    newLayout = copy_src.newLayout;
+    srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex;
+    dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex;
+    image = copy_src.image;
+    subresourceRange = copy_src.subresourceRange;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImageMemoryBarrier::~safe_VkImageMemoryBarrier() { FreePnextChain(pNext); }
+
+void safe_VkImageMemoryBarrier::initialize(const VkImageMemoryBarrier* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    srcAccessMask = in_struct->srcAccessMask;
+    dstAccessMask = in_struct->dstAccessMask;
+    oldLayout = in_struct->oldLayout;
+    newLayout = in_struct->newLayout;
+    srcQueueFamilyIndex = in_struct->srcQueueFamilyIndex;
+    dstQueueFamilyIndex = in_struct->dstQueueFamilyIndex;
+    image = in_struct->image;
+    subresourceRange = in_struct->subresourceRange;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImageMemoryBarrier::initialize(const safe_VkImageMemoryBarrier* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    srcAccessMask = copy_src->srcAccessMask;
+    dstAccessMask = copy_src->dstAccessMask;
+    oldLayout = copy_src->oldLayout;
+    newLayout = copy_src->newLayout;
+    srcQueueFamilyIndex = copy_src->srcQueueFamilyIndex;
+    dstQueueFamilyIndex = copy_src->dstQueueFamilyIndex;
+    image = copy_src->image;
+    subresourceRange = copy_src->subresourceRange;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkMemoryBarrier::safe_VkMemoryBarrier(const VkMemoryBarrier* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                           bool copy_pnext)
+    : sType(in_struct->sType), srcAccessMask(in_struct->srcAccessMask), dstAccessMask(in_struct->dstAccessMask) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMemoryBarrier::safe_VkMemoryBarrier()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_BARRIER), pNext(nullptr), srcAccessMask(), dstAccessMask() {}
+
+safe_VkMemoryBarrier::safe_VkMemoryBarrier(const safe_VkMemoryBarrier& copy_src) {
+    sType = copy_src.sType;
+    srcAccessMask = copy_src.srcAccessMask;
+    dstAccessMask = copy_src.dstAccessMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMemoryBarrier& safe_VkMemoryBarrier::operator=(const safe_VkMemoryBarrier& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    srcAccessMask = copy_src.srcAccessMask;
+    dstAccessMask = copy_src.dstAccessMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMemoryBarrier::~safe_VkMemoryBarrier() { FreePnextChain(pNext); }
+
+void safe_VkMemoryBarrier::initialize(const VkMemoryBarrier* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    srcAccessMask = in_struct->srcAccessMask;
+    dstAccessMask = in_struct->dstAccessMask;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMemoryBarrier::initialize(const safe_VkMemoryBarrier* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    srcAccessMask = copy_src->srcAccessMask;
+    dstAccessMask = copy_src->dstAccessMask;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkAllocationCallbacks::safe_VkAllocationCallbacks(const VkAllocationCallbacks* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state)
+    : pUserData(in_struct->pUserData),
+      pfnAllocation(in_struct->pfnAllocation),
+      pfnReallocation(in_struct->pfnReallocation),
+      pfnFree(in_struct->pfnFree),
+      pfnInternalAllocation(in_struct->pfnInternalAllocation),
+      pfnInternalFree(in_struct->pfnInternalFree) {}
+
+safe_VkAllocationCallbacks::safe_VkAllocationCallbacks()
+    : pUserData(nullptr), pfnAllocation(), pfnReallocation(), pfnFree(), pfnInternalAllocation(), pfnInternalFree() {}
+
+safe_VkAllocationCallbacks::safe_VkAllocationCallbacks(const safe_VkAllocationCallbacks& copy_src) {
+    pUserData = copy_src.pUserData;
+    pfnAllocation = copy_src.pfnAllocation;
+    pfnReallocation = copy_src.pfnReallocation;
+    pfnFree = copy_src.pfnFree;
+    pfnInternalAllocation = copy_src.pfnInternalAllocation;
+    pfnInternalFree = copy_src.pfnInternalFree;
+}
+
+safe_VkAllocationCallbacks& safe_VkAllocationCallbacks::operator=(const safe_VkAllocationCallbacks& copy_src) {
+    if (&copy_src == this) return *this;
+
+    pUserData = copy_src.pUserData;
+    pfnAllocation = copy_src.pfnAllocation;
+    pfnReallocation = copy_src.pfnReallocation;
+    pfnFree = copy_src.pfnFree;
+    pfnInternalAllocation = copy_src.pfnInternalAllocation;
+    pfnInternalFree = copy_src.pfnInternalFree;
+
+    return *this;
+}
+
+safe_VkAllocationCallbacks::~safe_VkAllocationCallbacks() {}
+
+void safe_VkAllocationCallbacks::initialize(const VkAllocationCallbacks* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    pUserData = in_struct->pUserData;
+    pfnAllocation = in_struct->pfnAllocation;
+    pfnReallocation = in_struct->pfnReallocation;
+    pfnFree = in_struct->pfnFree;
+    pfnInternalAllocation = in_struct->pfnInternalAllocation;
+    pfnInternalFree = in_struct->pfnInternalFree;
+}
+
+void safe_VkAllocationCallbacks::initialize(const safe_VkAllocationCallbacks* copy_src,
+                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    pUserData = copy_src->pUserData;
+    pfnAllocation = copy_src->pfnAllocation;
+    pfnReallocation = copy_src->pfnReallocation;
+    pfnFree = copy_src->pfnFree;
+    pfnInternalAllocation = copy_src->pfnInternalAllocation;
+    pfnInternalFree = copy_src->pfnInternalFree;
+}
+
+safe_VkApplicationInfo::safe_VkApplicationInfo(const VkApplicationInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                               bool copy_pnext)
+    : sType(in_struct->sType),
+      applicationVersion(in_struct->applicationVersion),
+      engineVersion(in_struct->engineVersion),
+      apiVersion(in_struct->apiVersion) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    pApplicationName = SafeStringCopy(in_struct->pApplicationName);
+    pEngineName = SafeStringCopy(in_struct->pEngineName);
+}
+
+safe_VkApplicationInfo::safe_VkApplicationInfo()
+    : sType(VK_STRUCTURE_TYPE_APPLICATION_INFO),
+      pNext(nullptr),
+      pApplicationName(nullptr),
+      applicationVersion(),
+      pEngineName(nullptr),
+      engineVersion(),
+      apiVersion() {}
+
+safe_VkApplicationInfo::safe_VkApplicationInfo(const safe_VkApplicationInfo& copy_src) {
+    sType = copy_src.sType;
+    applicationVersion = copy_src.applicationVersion;
+    engineVersion = copy_src.engineVersion;
+    apiVersion = copy_src.apiVersion;
+    pNext = SafePnextCopy(copy_src.pNext);
+    pApplicationName = SafeStringCopy(copy_src.pApplicationName);
+    pEngineName = SafeStringCopy(copy_src.pEngineName);
+}
+
+safe_VkApplicationInfo& safe_VkApplicationInfo::operator=(const safe_VkApplicationInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pApplicationName) delete[] pApplicationName;
+    if (pEngineName) delete[] pEngineName;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    applicationVersion = copy_src.applicationVersion;
+    engineVersion = copy_src.engineVersion;
+    apiVersion = copy_src.apiVersion;
+    pNext = SafePnextCopy(copy_src.pNext);
+    pApplicationName = SafeStringCopy(copy_src.pApplicationName);
+    pEngineName = SafeStringCopy(copy_src.pEngineName);
+
+    return *this;
+}
+
+safe_VkApplicationInfo::~safe_VkApplicationInfo() {
+    if (pApplicationName) delete[] pApplicationName;
+    if (pEngineName) delete[] pEngineName;
+    FreePnextChain(pNext);
+}
+
+void safe_VkApplicationInfo::initialize(const VkApplicationInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pApplicationName) delete[] pApplicationName;
+    if (pEngineName) delete[] pEngineName;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    applicationVersion = in_struct->applicationVersion;
+    engineVersion = in_struct->engineVersion;
+    apiVersion = in_struct->apiVersion;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    pApplicationName = SafeStringCopy(in_struct->pApplicationName);
+    pEngineName = SafeStringCopy(in_struct->pEngineName);
+}
+
+void safe_VkApplicationInfo::initialize(const safe_VkApplicationInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    applicationVersion = copy_src->applicationVersion;
+    engineVersion = copy_src->engineVersion;
+    apiVersion = copy_src->apiVersion;
+    pNext = SafePnextCopy(copy_src->pNext);
+    pApplicationName = SafeStringCopy(copy_src->pApplicationName);
+    pEngineName = SafeStringCopy(copy_src->pEngineName);
+}
+
+safe_VkInstanceCreateInfo::safe_VkInstanceCreateInfo(const VkInstanceCreateInfo* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      pApplicationInfo(nullptr),
+      enabledLayerCount(in_struct->enabledLayerCount),
+      enabledExtensionCount(in_struct->enabledExtensionCount) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    char** tmp_ppEnabledLayerNames = new char*[in_struct->enabledLayerCount];
+    for (uint32_t i = 0; i < enabledLayerCount; ++i) {
+        tmp_ppEnabledLayerNames[i] = SafeStringCopy(in_struct->ppEnabledLayerNames[i]);
+    }
+    ppEnabledLayerNames = tmp_ppEnabledLayerNames;
+    char** tmp_ppEnabledExtensionNames = new char*[in_struct->enabledExtensionCount];
+    for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
+        tmp_ppEnabledExtensionNames[i] = SafeStringCopy(in_struct->ppEnabledExtensionNames[i]);
+    }
+    ppEnabledExtensionNames = tmp_ppEnabledExtensionNames;
+    if (in_struct->pApplicationInfo) pApplicationInfo = new safe_VkApplicationInfo(in_struct->pApplicationInfo);
+}
+
+safe_VkInstanceCreateInfo::safe_VkInstanceCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      pApplicationInfo(nullptr),
+      enabledLayerCount(),
+      ppEnabledLayerNames(nullptr),
+      enabledExtensionCount(),
+      ppEnabledExtensionNames(nullptr) {}
+
+safe_VkInstanceCreateInfo::safe_VkInstanceCreateInfo(const safe_VkInstanceCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pApplicationInfo = nullptr;
+    enabledLayerCount = copy_src.enabledLayerCount;
+    enabledExtensionCount = copy_src.enabledExtensionCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    char** tmp_ppEnabledLayerNames = new char*[copy_src.enabledLayerCount];
+    for (uint32_t i = 0; i < enabledLayerCount; ++i) {
+        tmp_ppEnabledLayerNames[i] = SafeStringCopy(copy_src.ppEnabledLayerNames[i]);
+    }
+    ppEnabledLayerNames = tmp_ppEnabledLayerNames;
+    char** tmp_ppEnabledExtensionNames = new char*[copy_src.enabledExtensionCount];
+    for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
+        tmp_ppEnabledExtensionNames[i] = SafeStringCopy(copy_src.ppEnabledExtensionNames[i]);
+    }
+    ppEnabledExtensionNames = tmp_ppEnabledExtensionNames;
+    if (copy_src.pApplicationInfo) pApplicationInfo = new safe_VkApplicationInfo(*copy_src.pApplicationInfo);
+}
+
+safe_VkInstanceCreateInfo& safe_VkInstanceCreateInfo::operator=(const safe_VkInstanceCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pApplicationInfo) delete pApplicationInfo;
+
+    if (ppEnabledLayerNames) {
+        for (uint32_t i = 0; i < enabledLayerCount; ++i) {
+            delete[] ppEnabledLayerNames[i];
+        }
+        delete[] ppEnabledLayerNames;
+    }
+    if (ppEnabledExtensionNames) {
+        for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
+            delete[] ppEnabledExtensionNames[i];
+        }
+        delete[] ppEnabledExtensionNames;
+    }
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pApplicationInfo = nullptr;
+    enabledLayerCount = copy_src.enabledLayerCount;
+    enabledExtensionCount = copy_src.enabledExtensionCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    char** tmp_ppEnabledLayerNames = new char*[copy_src.enabledLayerCount];
+    for (uint32_t i = 0; i < enabledLayerCount; ++i) {
+        tmp_ppEnabledLayerNames[i] = SafeStringCopy(copy_src.ppEnabledLayerNames[i]);
+    }
+    ppEnabledLayerNames = tmp_ppEnabledLayerNames;
+    char** tmp_ppEnabledExtensionNames = new char*[copy_src.enabledExtensionCount];
+    for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
+        tmp_ppEnabledExtensionNames[i] = SafeStringCopy(copy_src.ppEnabledExtensionNames[i]);
+    }
+    ppEnabledExtensionNames = tmp_ppEnabledExtensionNames;
+    if (copy_src.pApplicationInfo) pApplicationInfo = new safe_VkApplicationInfo(*copy_src.pApplicationInfo);
+
+    return *this;
+}
+
+safe_VkInstanceCreateInfo::~safe_VkInstanceCreateInfo() {
+    if (pApplicationInfo) delete pApplicationInfo;
+
+    if (ppEnabledLayerNames) {
+        for (uint32_t i = 0; i < enabledLayerCount; ++i) {
+            delete[] ppEnabledLayerNames[i];
+        }
+        delete[] ppEnabledLayerNames;
+    }
+    if (ppEnabledExtensionNames) {
+        for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
+            delete[] ppEnabledExtensionNames[i];
+        }
+        delete[] ppEnabledExtensionNames;
+    }
+    FreePnextChain(pNext);
+}
+
+void safe_VkInstanceCreateInfo::initialize(const VkInstanceCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pApplicationInfo) delete pApplicationInfo;
+
+    if (ppEnabledLayerNames) {
+        for (uint32_t i = 0; i < enabledLayerCount; ++i) {
+            delete[] ppEnabledLayerNames[i];
+        }
+        delete[] ppEnabledLayerNames;
+    }
+    if (ppEnabledExtensionNames) {
+        for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
+            delete[] ppEnabledExtensionNames[i];
+        }
+        delete[] ppEnabledExtensionNames;
+    }
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    pApplicationInfo = nullptr;
+    enabledLayerCount = in_struct->enabledLayerCount;
+    enabledExtensionCount = in_struct->enabledExtensionCount;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    char** tmp_ppEnabledLayerNames = new char*[in_struct->enabledLayerCount];
+    for (uint32_t i = 0; i < enabledLayerCount; ++i) {
+        tmp_ppEnabledLayerNames[i] = SafeStringCopy(in_struct->ppEnabledLayerNames[i]);
+    }
+    ppEnabledLayerNames = tmp_ppEnabledLayerNames;
+    char** tmp_ppEnabledExtensionNames = new char*[in_struct->enabledExtensionCount];
+    for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
+        tmp_ppEnabledExtensionNames[i] = SafeStringCopy(in_struct->ppEnabledExtensionNames[i]);
+    }
+    ppEnabledExtensionNames = tmp_ppEnabledExtensionNames;
+    if (in_struct->pApplicationInfo) pApplicationInfo = new safe_VkApplicationInfo(in_struct->pApplicationInfo);
+}
+
+void safe_VkInstanceCreateInfo::initialize(const safe_VkInstanceCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pApplicationInfo = nullptr;
+    enabledLayerCount = copy_src->enabledLayerCount;
+    enabledExtensionCount = copy_src->enabledExtensionCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    char** tmp_ppEnabledLayerNames = new char*[copy_src->enabledLayerCount];
+    for (uint32_t i = 0; i < enabledLayerCount; ++i) {
+        tmp_ppEnabledLayerNames[i] = SafeStringCopy(copy_src->ppEnabledLayerNames[i]);
+    }
+    ppEnabledLayerNames = tmp_ppEnabledLayerNames;
+    char** tmp_ppEnabledExtensionNames = new char*[copy_src->enabledExtensionCount];
+    for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
+        tmp_ppEnabledExtensionNames[i] = SafeStringCopy(copy_src->ppEnabledExtensionNames[i]);
+    }
+    ppEnabledExtensionNames = tmp_ppEnabledExtensionNames;
+    if (copy_src->pApplicationInfo) pApplicationInfo = new safe_VkApplicationInfo(*copy_src->pApplicationInfo);
+}
+
+safe_VkDeviceQueueCreateInfo::safe_VkDeviceQueueCreateInfo(const VkDeviceQueueCreateInfo* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      queueFamilyIndex(in_struct->queueFamilyIndex),
+      queueCount(in_struct->queueCount),
+      pQueuePriorities(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pQueuePriorities) {
+        pQueuePriorities = new float[in_struct->queueCount];
+        memcpy((void*)pQueuePriorities, (void*)in_struct->pQueuePriorities, sizeof(float) * in_struct->queueCount);
+    }
+}
+
+safe_VkDeviceQueueCreateInfo::safe_VkDeviceQueueCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      queueFamilyIndex(),
+      queueCount(),
+      pQueuePriorities(nullptr) {}
+
+safe_VkDeviceQueueCreateInfo::safe_VkDeviceQueueCreateInfo(const safe_VkDeviceQueueCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    queueFamilyIndex = copy_src.queueFamilyIndex;
+    queueCount = copy_src.queueCount;
+    pQueuePriorities = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pQueuePriorities) {
+        pQueuePriorities = new float[copy_src.queueCount];
+        memcpy((void*)pQueuePriorities, (void*)copy_src.pQueuePriorities, sizeof(float) * copy_src.queueCount);
+    }
+}
+
+safe_VkDeviceQueueCreateInfo& safe_VkDeviceQueueCreateInfo::operator=(const safe_VkDeviceQueueCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pQueuePriorities) delete[] pQueuePriorities;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    queueFamilyIndex = copy_src.queueFamilyIndex;
+    queueCount = copy_src.queueCount;
+    pQueuePriorities = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pQueuePriorities) {
+        pQueuePriorities = new float[copy_src.queueCount];
+        memcpy((void*)pQueuePriorities, (void*)copy_src.pQueuePriorities, sizeof(float) * copy_src.queueCount);
+    }
+
+    return *this;
+}
+
+safe_VkDeviceQueueCreateInfo::~safe_VkDeviceQueueCreateInfo() {
+    if (pQueuePriorities) delete[] pQueuePriorities;
+    FreePnextChain(pNext);
+}
+
+void safe_VkDeviceQueueCreateInfo::initialize(const VkDeviceQueueCreateInfo* in_struct,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pQueuePriorities) delete[] pQueuePriorities;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    queueFamilyIndex = in_struct->queueFamilyIndex;
+    queueCount = in_struct->queueCount;
+    pQueuePriorities = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pQueuePriorities) {
+        pQueuePriorities = new float[in_struct->queueCount];
+        memcpy((void*)pQueuePriorities, (void*)in_struct->pQueuePriorities, sizeof(float) * in_struct->queueCount);
+    }
+}
+
+void safe_VkDeviceQueueCreateInfo::initialize(const safe_VkDeviceQueueCreateInfo* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    queueFamilyIndex = copy_src->queueFamilyIndex;
+    queueCount = copy_src->queueCount;
+    pQueuePriorities = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pQueuePriorities) {
+        pQueuePriorities = new float[copy_src->queueCount];
+        memcpy((void*)pQueuePriorities, (void*)copy_src->pQueuePriorities, sizeof(float) * copy_src->queueCount);
+    }
+}
+
+safe_VkDeviceCreateInfo::safe_VkDeviceCreateInfo(const VkDeviceCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                                 bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      queueCreateInfoCount(in_struct->queueCreateInfoCount),
+      pQueueCreateInfos(nullptr),
+      enabledLayerCount(in_struct->enabledLayerCount),
+      enabledExtensionCount(in_struct->enabledExtensionCount),
+      pEnabledFeatures(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    char** tmp_ppEnabledLayerNames = new char*[in_struct->enabledLayerCount];
+    for (uint32_t i = 0; i < enabledLayerCount; ++i) {
+        tmp_ppEnabledLayerNames[i] = SafeStringCopy(in_struct->ppEnabledLayerNames[i]);
+    }
+    ppEnabledLayerNames = tmp_ppEnabledLayerNames;
+    char** tmp_ppEnabledExtensionNames = new char*[in_struct->enabledExtensionCount];
+    for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
+        tmp_ppEnabledExtensionNames[i] = SafeStringCopy(in_struct->ppEnabledExtensionNames[i]);
+    }
+    ppEnabledExtensionNames = tmp_ppEnabledExtensionNames;
+    if (queueCreateInfoCount && in_struct->pQueueCreateInfos) {
+        pQueueCreateInfos = new safe_VkDeviceQueueCreateInfo[queueCreateInfoCount];
+        for (uint32_t i = 0; i < queueCreateInfoCount; ++i) {
+            pQueueCreateInfos[i].initialize(&in_struct->pQueueCreateInfos[i]);
+        }
+    }
+
+    if (in_struct->pEnabledFeatures) {
+        pEnabledFeatures = new VkPhysicalDeviceFeatures(*in_struct->pEnabledFeatures);
+    }
+}
+
+safe_VkDeviceCreateInfo::safe_VkDeviceCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      queueCreateInfoCount(),
+      pQueueCreateInfos(nullptr),
+      enabledLayerCount(),
+      ppEnabledLayerNames(nullptr),
+      enabledExtensionCount(),
+      ppEnabledExtensionNames(nullptr),
+      pEnabledFeatures(nullptr) {}
+
+safe_VkDeviceCreateInfo::safe_VkDeviceCreateInfo(const safe_VkDeviceCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    queueCreateInfoCount = copy_src.queueCreateInfoCount;
+    pQueueCreateInfos = nullptr;
+    enabledLayerCount = copy_src.enabledLayerCount;
+    enabledExtensionCount = copy_src.enabledExtensionCount;
+    pEnabledFeatures = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    char** tmp_ppEnabledLayerNames = new char*[copy_src.enabledLayerCount];
+    for (uint32_t i = 0; i < enabledLayerCount; ++i) {
+        tmp_ppEnabledLayerNames[i] = SafeStringCopy(copy_src.ppEnabledLayerNames[i]);
+    }
+    ppEnabledLayerNames = tmp_ppEnabledLayerNames;
+    char** tmp_ppEnabledExtensionNames = new char*[copy_src.enabledExtensionCount];
+    for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
+        tmp_ppEnabledExtensionNames[i] = SafeStringCopy(copy_src.ppEnabledExtensionNames[i]);
+    }
+    ppEnabledExtensionNames = tmp_ppEnabledExtensionNames;
+    if (queueCreateInfoCount && copy_src.pQueueCreateInfos) {
+        pQueueCreateInfos = new safe_VkDeviceQueueCreateInfo[queueCreateInfoCount];
+        for (uint32_t i = 0; i < queueCreateInfoCount; ++i) {
+            pQueueCreateInfos[i].initialize(&copy_src.pQueueCreateInfos[i]);
+        }
+    }
+
+    if (copy_src.pEnabledFeatures) {
+        pEnabledFeatures = new VkPhysicalDeviceFeatures(*copy_src.pEnabledFeatures);
+    }
+}
+
+safe_VkDeviceCreateInfo& safe_VkDeviceCreateInfo::operator=(const safe_VkDeviceCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pQueueCreateInfos) delete[] pQueueCreateInfos;
+
+    if (ppEnabledLayerNames) {
+        for (uint32_t i = 0; i < enabledLayerCount; ++i) {
+            delete[] ppEnabledLayerNames[i];
+        }
+        delete[] ppEnabledLayerNames;
+    }
+    if (ppEnabledExtensionNames) {
+        for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
+            delete[] ppEnabledExtensionNames[i];
+        }
+        delete[] ppEnabledExtensionNames;
+    }
+    if (pEnabledFeatures) delete pEnabledFeatures;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    queueCreateInfoCount = copy_src.queueCreateInfoCount;
+    pQueueCreateInfos = nullptr;
+    enabledLayerCount = copy_src.enabledLayerCount;
+    enabledExtensionCount = copy_src.enabledExtensionCount;
+    pEnabledFeatures = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    char** tmp_ppEnabledLayerNames = new char*[copy_src.enabledLayerCount];
+    for (uint32_t i = 0; i < enabledLayerCount; ++i) {
+        tmp_ppEnabledLayerNames[i] = SafeStringCopy(copy_src.ppEnabledLayerNames[i]);
+    }
+    ppEnabledLayerNames = tmp_ppEnabledLayerNames;
+    char** tmp_ppEnabledExtensionNames = new char*[copy_src.enabledExtensionCount];
+    for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
+        tmp_ppEnabledExtensionNames[i] = SafeStringCopy(copy_src.ppEnabledExtensionNames[i]);
+    }
+    ppEnabledExtensionNames = tmp_ppEnabledExtensionNames;
+    if (queueCreateInfoCount && copy_src.pQueueCreateInfos) {
+        pQueueCreateInfos = new safe_VkDeviceQueueCreateInfo[queueCreateInfoCount];
+        for (uint32_t i = 0; i < queueCreateInfoCount; ++i) {
+            pQueueCreateInfos[i].initialize(&copy_src.pQueueCreateInfos[i]);
+        }
+    }
+
+    if (copy_src.pEnabledFeatures) {
+        pEnabledFeatures = new VkPhysicalDeviceFeatures(*copy_src.pEnabledFeatures);
+    }
+
+    return *this;
+}
+
+safe_VkDeviceCreateInfo::~safe_VkDeviceCreateInfo() {
+    if (pQueueCreateInfos) delete[] pQueueCreateInfos;
+
+    if (ppEnabledLayerNames) {
+        for (uint32_t i = 0; i < enabledLayerCount; ++i) {
+            delete[] ppEnabledLayerNames[i];
+        }
+        delete[] ppEnabledLayerNames;
+    }
+    if (ppEnabledExtensionNames) {
+        for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
+            delete[] ppEnabledExtensionNames[i];
+        }
+        delete[] ppEnabledExtensionNames;
+    }
+    if (pEnabledFeatures) delete pEnabledFeatures;
+    FreePnextChain(pNext);
+}
+
+void safe_VkDeviceCreateInfo::initialize(const VkDeviceCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pQueueCreateInfos) delete[] pQueueCreateInfos;
+
+    if (ppEnabledLayerNames) {
+        for (uint32_t i = 0; i < enabledLayerCount; ++i) {
+            delete[] ppEnabledLayerNames[i];
+        }
+        delete[] ppEnabledLayerNames;
+    }
+    if (ppEnabledExtensionNames) {
+        for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
+            delete[] ppEnabledExtensionNames[i];
+        }
+        delete[] ppEnabledExtensionNames;
+    }
+    if (pEnabledFeatures) delete pEnabledFeatures;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    queueCreateInfoCount = in_struct->queueCreateInfoCount;
+    pQueueCreateInfos = nullptr;
+    enabledLayerCount = in_struct->enabledLayerCount;
+    enabledExtensionCount = in_struct->enabledExtensionCount;
+    pEnabledFeatures = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    char** tmp_ppEnabledLayerNames = new char*[in_struct->enabledLayerCount];
+    for (uint32_t i = 0; i < enabledLayerCount; ++i) {
+        tmp_ppEnabledLayerNames[i] = SafeStringCopy(in_struct->ppEnabledLayerNames[i]);
+    }
+    ppEnabledLayerNames = tmp_ppEnabledLayerNames;
+    char** tmp_ppEnabledExtensionNames = new char*[in_struct->enabledExtensionCount];
+    for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
+        tmp_ppEnabledExtensionNames[i] = SafeStringCopy(in_struct->ppEnabledExtensionNames[i]);
+    }
+    ppEnabledExtensionNames = tmp_ppEnabledExtensionNames;
+    if (queueCreateInfoCount && in_struct->pQueueCreateInfos) {
+        pQueueCreateInfos = new safe_VkDeviceQueueCreateInfo[queueCreateInfoCount];
+        for (uint32_t i = 0; i < queueCreateInfoCount; ++i) {
+            pQueueCreateInfos[i].initialize(&in_struct->pQueueCreateInfos[i]);
+        }
+    }
+
+    if (in_struct->pEnabledFeatures) {
+        pEnabledFeatures = new VkPhysicalDeviceFeatures(*in_struct->pEnabledFeatures);
+    }
+}
+
+void safe_VkDeviceCreateInfo::initialize(const safe_VkDeviceCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    queueCreateInfoCount = copy_src->queueCreateInfoCount;
+    pQueueCreateInfos = nullptr;
+    enabledLayerCount = copy_src->enabledLayerCount;
+    enabledExtensionCount = copy_src->enabledExtensionCount;
+    pEnabledFeatures = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    char** tmp_ppEnabledLayerNames = new char*[copy_src->enabledLayerCount];
+    for (uint32_t i = 0; i < enabledLayerCount; ++i) {
+        tmp_ppEnabledLayerNames[i] = SafeStringCopy(copy_src->ppEnabledLayerNames[i]);
+    }
+    ppEnabledLayerNames = tmp_ppEnabledLayerNames;
+    char** tmp_ppEnabledExtensionNames = new char*[copy_src->enabledExtensionCount];
+    for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
+        tmp_ppEnabledExtensionNames[i] = SafeStringCopy(copy_src->ppEnabledExtensionNames[i]);
+    }
+    ppEnabledExtensionNames = tmp_ppEnabledExtensionNames;
+    if (queueCreateInfoCount && copy_src->pQueueCreateInfos) {
+        pQueueCreateInfos = new safe_VkDeviceQueueCreateInfo[queueCreateInfoCount];
+        for (uint32_t i = 0; i < queueCreateInfoCount; ++i) {
+            pQueueCreateInfos[i].initialize(&copy_src->pQueueCreateInfos[i]);
+        }
+    }
+
+    if (copy_src->pEnabledFeatures) {
+        pEnabledFeatures = new VkPhysicalDeviceFeatures(*copy_src->pEnabledFeatures);
+    }
+}
+
+safe_VkSubmitInfo::safe_VkSubmitInfo(const VkSubmitInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      waitSemaphoreCount(in_struct->waitSemaphoreCount),
+      pWaitSemaphores(nullptr),
+      pWaitDstStageMask(nullptr),
+      commandBufferCount(in_struct->commandBufferCount),
+      pCommandBuffers(nullptr),
+      signalSemaphoreCount(in_struct->signalSemaphoreCount),
+      pSignalSemaphores(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (waitSemaphoreCount && in_struct->pWaitSemaphores) {
+        pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
+            pWaitSemaphores[i] = in_struct->pWaitSemaphores[i];
+        }
+    }
+
+    if (in_struct->pWaitDstStageMask) {
+        pWaitDstStageMask = new VkPipelineStageFlags[in_struct->waitSemaphoreCount];
+        memcpy((void*)pWaitDstStageMask, (void*)in_struct->pWaitDstStageMask,
+               sizeof(VkPipelineStageFlags) * in_struct->waitSemaphoreCount);
+    }
+
+    if (in_struct->pCommandBuffers) {
+        pCommandBuffers = new VkCommandBuffer[in_struct->commandBufferCount];
+        memcpy((void*)pCommandBuffers, (void*)in_struct->pCommandBuffers, sizeof(VkCommandBuffer) * in_struct->commandBufferCount);
+    }
+    if (signalSemaphoreCount && in_struct->pSignalSemaphores) {
+        pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
+        for (uint32_t i = 0; i < signalSemaphoreCount; ++i) {
+            pSignalSemaphores[i] = in_struct->pSignalSemaphores[i];
+        }
+    }
+}
+
+safe_VkSubmitInfo::safe_VkSubmitInfo()
+    : sType(VK_STRUCTURE_TYPE_SUBMIT_INFO),
+      pNext(nullptr),
+      waitSemaphoreCount(),
+      pWaitSemaphores(nullptr),
+      pWaitDstStageMask(nullptr),
+      commandBufferCount(),
+      pCommandBuffers(nullptr),
+      signalSemaphoreCount(),
+      pSignalSemaphores(nullptr) {}
+
+safe_VkSubmitInfo::safe_VkSubmitInfo(const safe_VkSubmitInfo& copy_src) {
+    sType = copy_src.sType;
+    waitSemaphoreCount = copy_src.waitSemaphoreCount;
+    pWaitSemaphores = nullptr;
+    pWaitDstStageMask = nullptr;
+    commandBufferCount = copy_src.commandBufferCount;
+    pCommandBuffers = nullptr;
+    signalSemaphoreCount = copy_src.signalSemaphoreCount;
+    pSignalSemaphores = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (waitSemaphoreCount && copy_src.pWaitSemaphores) {
+        pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
+            pWaitSemaphores[i] = copy_src.pWaitSemaphores[i];
+        }
+    }
+
+    if (copy_src.pWaitDstStageMask) {
+        pWaitDstStageMask = new VkPipelineStageFlags[copy_src.waitSemaphoreCount];
+        memcpy((void*)pWaitDstStageMask, (void*)copy_src.pWaitDstStageMask,
+               sizeof(VkPipelineStageFlags) * copy_src.waitSemaphoreCount);
+    }
+
+    if (copy_src.pCommandBuffers) {
+        pCommandBuffers = new VkCommandBuffer[copy_src.commandBufferCount];
+        memcpy((void*)pCommandBuffers, (void*)copy_src.pCommandBuffers, sizeof(VkCommandBuffer) * copy_src.commandBufferCount);
+    }
+    if (signalSemaphoreCount && copy_src.pSignalSemaphores) {
+        pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
+        for (uint32_t i = 0; i < signalSemaphoreCount; ++i) {
+            pSignalSemaphores[i] = copy_src.pSignalSemaphores[i];
+        }
+    }
+}
+
+safe_VkSubmitInfo& safe_VkSubmitInfo::operator=(const safe_VkSubmitInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pWaitSemaphores) delete[] pWaitSemaphores;
+    if (pWaitDstStageMask) delete[] pWaitDstStageMask;
+    if (pCommandBuffers) delete[] pCommandBuffers;
+    if (pSignalSemaphores) delete[] pSignalSemaphores;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    waitSemaphoreCount = copy_src.waitSemaphoreCount;
+    pWaitSemaphores = nullptr;
+    pWaitDstStageMask = nullptr;
+    commandBufferCount = copy_src.commandBufferCount;
+    pCommandBuffers = nullptr;
+    signalSemaphoreCount = copy_src.signalSemaphoreCount;
+    pSignalSemaphores = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (waitSemaphoreCount && copy_src.pWaitSemaphores) {
+        pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
+            pWaitSemaphores[i] = copy_src.pWaitSemaphores[i];
+        }
+    }
+
+    if (copy_src.pWaitDstStageMask) {
+        pWaitDstStageMask = new VkPipelineStageFlags[copy_src.waitSemaphoreCount];
+        memcpy((void*)pWaitDstStageMask, (void*)copy_src.pWaitDstStageMask,
+               sizeof(VkPipelineStageFlags) * copy_src.waitSemaphoreCount);
+    }
+
+    if (copy_src.pCommandBuffers) {
+        pCommandBuffers = new VkCommandBuffer[copy_src.commandBufferCount];
+        memcpy((void*)pCommandBuffers, (void*)copy_src.pCommandBuffers, sizeof(VkCommandBuffer) * copy_src.commandBufferCount);
+    }
+    if (signalSemaphoreCount && copy_src.pSignalSemaphores) {
+        pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
+        for (uint32_t i = 0; i < signalSemaphoreCount; ++i) {
+            pSignalSemaphores[i] = copy_src.pSignalSemaphores[i];
+        }
+    }
+
+    return *this;
+}
+
+safe_VkSubmitInfo::~safe_VkSubmitInfo() {
+    if (pWaitSemaphores) delete[] pWaitSemaphores;
+    if (pWaitDstStageMask) delete[] pWaitDstStageMask;
+    if (pCommandBuffers) delete[] pCommandBuffers;
+    if (pSignalSemaphores) delete[] pSignalSemaphores;
+    FreePnextChain(pNext);
+}
+
+void safe_VkSubmitInfo::initialize(const VkSubmitInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pWaitSemaphores) delete[] pWaitSemaphores;
+    if (pWaitDstStageMask) delete[] pWaitDstStageMask;
+    if (pCommandBuffers) delete[] pCommandBuffers;
+    if (pSignalSemaphores) delete[] pSignalSemaphores;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    waitSemaphoreCount = in_struct->waitSemaphoreCount;
+    pWaitSemaphores = nullptr;
+    pWaitDstStageMask = nullptr;
+    commandBufferCount = in_struct->commandBufferCount;
+    pCommandBuffers = nullptr;
+    signalSemaphoreCount = in_struct->signalSemaphoreCount;
+    pSignalSemaphores = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (waitSemaphoreCount && in_struct->pWaitSemaphores) {
+        pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
+            pWaitSemaphores[i] = in_struct->pWaitSemaphores[i];
+        }
+    }
+
+    if (in_struct->pWaitDstStageMask) {
+        pWaitDstStageMask = new VkPipelineStageFlags[in_struct->waitSemaphoreCount];
+        memcpy((void*)pWaitDstStageMask, (void*)in_struct->pWaitDstStageMask,
+               sizeof(VkPipelineStageFlags) * in_struct->waitSemaphoreCount);
+    }
+
+    if (in_struct->pCommandBuffers) {
+        pCommandBuffers = new VkCommandBuffer[in_struct->commandBufferCount];
+        memcpy((void*)pCommandBuffers, (void*)in_struct->pCommandBuffers, sizeof(VkCommandBuffer) * in_struct->commandBufferCount);
+    }
+    if (signalSemaphoreCount && in_struct->pSignalSemaphores) {
+        pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
+        for (uint32_t i = 0; i < signalSemaphoreCount; ++i) {
+            pSignalSemaphores[i] = in_struct->pSignalSemaphores[i];
+        }
+    }
+}
+
+void safe_VkSubmitInfo::initialize(const safe_VkSubmitInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    waitSemaphoreCount = copy_src->waitSemaphoreCount;
+    pWaitSemaphores = nullptr;
+    pWaitDstStageMask = nullptr;
+    commandBufferCount = copy_src->commandBufferCount;
+    pCommandBuffers = nullptr;
+    signalSemaphoreCount = copy_src->signalSemaphoreCount;
+    pSignalSemaphores = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (waitSemaphoreCount && copy_src->pWaitSemaphores) {
+        pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
+            pWaitSemaphores[i] = copy_src->pWaitSemaphores[i];
+        }
+    }
+
+    if (copy_src->pWaitDstStageMask) {
+        pWaitDstStageMask = new VkPipelineStageFlags[copy_src->waitSemaphoreCount];
+        memcpy((void*)pWaitDstStageMask, (void*)copy_src->pWaitDstStageMask,
+               sizeof(VkPipelineStageFlags) * copy_src->waitSemaphoreCount);
+    }
+
+    if (copy_src->pCommandBuffers) {
+        pCommandBuffers = new VkCommandBuffer[copy_src->commandBufferCount];
+        memcpy((void*)pCommandBuffers, (void*)copy_src->pCommandBuffers, sizeof(VkCommandBuffer) * copy_src->commandBufferCount);
+    }
+    if (signalSemaphoreCount && copy_src->pSignalSemaphores) {
+        pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
+        for (uint32_t i = 0; i < signalSemaphoreCount; ++i) {
+            pSignalSemaphores[i] = copy_src->pSignalSemaphores[i];
+        }
+    }
+}
+
+safe_VkMappedMemoryRange::safe_VkMappedMemoryRange(const VkMappedMemoryRange* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), memory(in_struct->memory), offset(in_struct->offset), size(in_struct->size) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMappedMemoryRange::safe_VkMappedMemoryRange()
+    : sType(VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE), pNext(nullptr), memory(), offset(), size() {}
+
+safe_VkMappedMemoryRange::safe_VkMappedMemoryRange(const safe_VkMappedMemoryRange& copy_src) {
+    sType = copy_src.sType;
+    memory = copy_src.memory;
+    offset = copy_src.offset;
+    size = copy_src.size;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMappedMemoryRange& safe_VkMappedMemoryRange::operator=(const safe_VkMappedMemoryRange& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    memory = copy_src.memory;
+    offset = copy_src.offset;
+    size = copy_src.size;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMappedMemoryRange::~safe_VkMappedMemoryRange() { FreePnextChain(pNext); }
+
+void safe_VkMappedMemoryRange::initialize(const VkMappedMemoryRange* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    memory = in_struct->memory;
+    offset = in_struct->offset;
+    size = in_struct->size;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMappedMemoryRange::initialize(const safe_VkMappedMemoryRange* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memory = copy_src->memory;
+    offset = copy_src->offset;
+    size = copy_src->size;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkMemoryAllocateInfo::safe_VkMemoryAllocateInfo(const VkMemoryAllocateInfo* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), allocationSize(in_struct->allocationSize), memoryTypeIndex(in_struct->memoryTypeIndex) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMemoryAllocateInfo::safe_VkMemoryAllocateInfo()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO), pNext(nullptr), allocationSize(), memoryTypeIndex() {}
+
+safe_VkMemoryAllocateInfo::safe_VkMemoryAllocateInfo(const safe_VkMemoryAllocateInfo& copy_src) {
+    sType = copy_src.sType;
+    allocationSize = copy_src.allocationSize;
+    memoryTypeIndex = copy_src.memoryTypeIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMemoryAllocateInfo& safe_VkMemoryAllocateInfo::operator=(const safe_VkMemoryAllocateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    allocationSize = copy_src.allocationSize;
+    memoryTypeIndex = copy_src.memoryTypeIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMemoryAllocateInfo::~safe_VkMemoryAllocateInfo() { FreePnextChain(pNext); }
+
+void safe_VkMemoryAllocateInfo::initialize(const VkMemoryAllocateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    allocationSize = in_struct->allocationSize;
+    memoryTypeIndex = in_struct->memoryTypeIndex;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMemoryAllocateInfo::initialize(const safe_VkMemoryAllocateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    allocationSize = copy_src->allocationSize;
+    memoryTypeIndex = copy_src->memoryTypeIndex;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSparseBufferMemoryBindInfo::safe_VkSparseBufferMemoryBindInfo(const VkSparseBufferMemoryBindInfo* in_struct,
+                                                                     [[maybe_unused]] PNextCopyState* copy_state)
+    : buffer(in_struct->buffer), bindCount(in_struct->bindCount), pBinds(nullptr) {
+    if (bindCount && in_struct->pBinds) {
+        pBinds = new VkSparseMemoryBind[bindCount];
+        for (uint32_t i = 0; i < bindCount; ++i) {
+            pBinds[i] = in_struct->pBinds[i];
+        }
+    }
+}
+
+safe_VkSparseBufferMemoryBindInfo::safe_VkSparseBufferMemoryBindInfo() : buffer(), bindCount(), pBinds(nullptr) {}
+
+safe_VkSparseBufferMemoryBindInfo::safe_VkSparseBufferMemoryBindInfo(const safe_VkSparseBufferMemoryBindInfo& copy_src) {
+    buffer = copy_src.buffer;
+    bindCount = copy_src.bindCount;
+    pBinds = nullptr;
+    if (bindCount && copy_src.pBinds) {
+        pBinds = new VkSparseMemoryBind[bindCount];
+        for (uint32_t i = 0; i < bindCount; ++i) {
+            pBinds[i] = copy_src.pBinds[i];
+        }
+    }
+}
+
+safe_VkSparseBufferMemoryBindInfo& safe_VkSparseBufferMemoryBindInfo::operator=(const safe_VkSparseBufferMemoryBindInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pBinds) delete[] pBinds;
+
+    buffer = copy_src.buffer;
+    bindCount = copy_src.bindCount;
+    pBinds = nullptr;
+    if (bindCount && copy_src.pBinds) {
+        pBinds = new VkSparseMemoryBind[bindCount];
+        for (uint32_t i = 0; i < bindCount; ++i) {
+            pBinds[i] = copy_src.pBinds[i];
+        }
+    }
+
+    return *this;
+}
+
+safe_VkSparseBufferMemoryBindInfo::~safe_VkSparseBufferMemoryBindInfo() {
+    if (pBinds) delete[] pBinds;
+}
+
+void safe_VkSparseBufferMemoryBindInfo::initialize(const VkSparseBufferMemoryBindInfo* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pBinds) delete[] pBinds;
+    buffer = in_struct->buffer;
+    bindCount = in_struct->bindCount;
+    pBinds = nullptr;
+    if (bindCount && in_struct->pBinds) {
+        pBinds = new VkSparseMemoryBind[bindCount];
+        for (uint32_t i = 0; i < bindCount; ++i) {
+            pBinds[i] = in_struct->pBinds[i];
+        }
+    }
+}
+
+void safe_VkSparseBufferMemoryBindInfo::initialize(const safe_VkSparseBufferMemoryBindInfo* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    buffer = copy_src->buffer;
+    bindCount = copy_src->bindCount;
+    pBinds = nullptr;
+    if (bindCount && copy_src->pBinds) {
+        pBinds = new VkSparseMemoryBind[bindCount];
+        for (uint32_t i = 0; i < bindCount; ++i) {
+            pBinds[i] = copy_src->pBinds[i];
+        }
+    }
+}
+
+safe_VkSparseImageOpaqueMemoryBindInfo::safe_VkSparseImageOpaqueMemoryBindInfo(const VkSparseImageOpaqueMemoryBindInfo* in_struct,
+                                                                               [[maybe_unused]] PNextCopyState* copy_state)
+    : image(in_struct->image), bindCount(in_struct->bindCount), pBinds(nullptr) {
+    if (bindCount && in_struct->pBinds) {
+        pBinds = new VkSparseMemoryBind[bindCount];
+        for (uint32_t i = 0; i < bindCount; ++i) {
+            pBinds[i] = in_struct->pBinds[i];
+        }
+    }
+}
+
+safe_VkSparseImageOpaqueMemoryBindInfo::safe_VkSparseImageOpaqueMemoryBindInfo() : image(), bindCount(), pBinds(nullptr) {}
+
+safe_VkSparseImageOpaqueMemoryBindInfo::safe_VkSparseImageOpaqueMemoryBindInfo(
+    const safe_VkSparseImageOpaqueMemoryBindInfo& copy_src) {
+    image = copy_src.image;
+    bindCount = copy_src.bindCount;
+    pBinds = nullptr;
+    if (bindCount && copy_src.pBinds) {
+        pBinds = new VkSparseMemoryBind[bindCount];
+        for (uint32_t i = 0; i < bindCount; ++i) {
+            pBinds[i] = copy_src.pBinds[i];
+        }
+    }
+}
+
+safe_VkSparseImageOpaqueMemoryBindInfo& safe_VkSparseImageOpaqueMemoryBindInfo::operator=(
+    const safe_VkSparseImageOpaqueMemoryBindInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pBinds) delete[] pBinds;
+
+    image = copy_src.image;
+    bindCount = copy_src.bindCount;
+    pBinds = nullptr;
+    if (bindCount && copy_src.pBinds) {
+        pBinds = new VkSparseMemoryBind[bindCount];
+        for (uint32_t i = 0; i < bindCount; ++i) {
+            pBinds[i] = copy_src.pBinds[i];
+        }
+    }
+
+    return *this;
+}
+
+safe_VkSparseImageOpaqueMemoryBindInfo::~safe_VkSparseImageOpaqueMemoryBindInfo() {
+    if (pBinds) delete[] pBinds;
+}
+
+void safe_VkSparseImageOpaqueMemoryBindInfo::initialize(const VkSparseImageOpaqueMemoryBindInfo* in_struct,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pBinds) delete[] pBinds;
+    image = in_struct->image;
+    bindCount = in_struct->bindCount;
+    pBinds = nullptr;
+    if (bindCount && in_struct->pBinds) {
+        pBinds = new VkSparseMemoryBind[bindCount];
+        for (uint32_t i = 0; i < bindCount; ++i) {
+            pBinds[i] = in_struct->pBinds[i];
+        }
+    }
+}
+
+void safe_VkSparseImageOpaqueMemoryBindInfo::initialize(const safe_VkSparseImageOpaqueMemoryBindInfo* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    image = copy_src->image;
+    bindCount = copy_src->bindCount;
+    pBinds = nullptr;
+    if (bindCount && copy_src->pBinds) {
+        pBinds = new VkSparseMemoryBind[bindCount];
+        for (uint32_t i = 0; i < bindCount; ++i) {
+            pBinds[i] = copy_src->pBinds[i];
+        }
+    }
+}
+
+safe_VkSparseImageMemoryBindInfo::safe_VkSparseImageMemoryBindInfo(const VkSparseImageMemoryBindInfo* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state)
+    : image(in_struct->image), bindCount(in_struct->bindCount), pBinds(nullptr) {
+    if (bindCount && in_struct->pBinds) {
+        pBinds = new VkSparseImageMemoryBind[bindCount];
+        for (uint32_t i = 0; i < bindCount; ++i) {
+            pBinds[i] = in_struct->pBinds[i];
+        }
+    }
+}
+
+safe_VkSparseImageMemoryBindInfo::safe_VkSparseImageMemoryBindInfo() : image(), bindCount(), pBinds(nullptr) {}
+
+safe_VkSparseImageMemoryBindInfo::safe_VkSparseImageMemoryBindInfo(const safe_VkSparseImageMemoryBindInfo& copy_src) {
+    image = copy_src.image;
+    bindCount = copy_src.bindCount;
+    pBinds = nullptr;
+    if (bindCount && copy_src.pBinds) {
+        pBinds = new VkSparseImageMemoryBind[bindCount];
+        for (uint32_t i = 0; i < bindCount; ++i) {
+            pBinds[i] = copy_src.pBinds[i];
+        }
+    }
+}
+
+safe_VkSparseImageMemoryBindInfo& safe_VkSparseImageMemoryBindInfo::operator=(const safe_VkSparseImageMemoryBindInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pBinds) delete[] pBinds;
+
+    image = copy_src.image;
+    bindCount = copy_src.bindCount;
+    pBinds = nullptr;
+    if (bindCount && copy_src.pBinds) {
+        pBinds = new VkSparseImageMemoryBind[bindCount];
+        for (uint32_t i = 0; i < bindCount; ++i) {
+            pBinds[i] = copy_src.pBinds[i];
+        }
+    }
+
+    return *this;
+}
+
+safe_VkSparseImageMemoryBindInfo::~safe_VkSparseImageMemoryBindInfo() {
+    if (pBinds) delete[] pBinds;
+}
+
+void safe_VkSparseImageMemoryBindInfo::initialize(const VkSparseImageMemoryBindInfo* in_struct,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pBinds) delete[] pBinds;
+    image = in_struct->image;
+    bindCount = in_struct->bindCount;
+    pBinds = nullptr;
+    if (bindCount && in_struct->pBinds) {
+        pBinds = new VkSparseImageMemoryBind[bindCount];
+        for (uint32_t i = 0; i < bindCount; ++i) {
+            pBinds[i] = in_struct->pBinds[i];
+        }
+    }
+}
+
+void safe_VkSparseImageMemoryBindInfo::initialize(const safe_VkSparseImageMemoryBindInfo* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    image = copy_src->image;
+    bindCount = copy_src->bindCount;
+    pBinds = nullptr;
+    if (bindCount && copy_src->pBinds) {
+        pBinds = new VkSparseImageMemoryBind[bindCount];
+        for (uint32_t i = 0; i < bindCount; ++i) {
+            pBinds[i] = copy_src->pBinds[i];
+        }
+    }
+}
+
+safe_VkBindSparseInfo::safe_VkBindSparseInfo(const VkBindSparseInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                             bool copy_pnext)
+    : sType(in_struct->sType),
+      waitSemaphoreCount(in_struct->waitSemaphoreCount),
+      pWaitSemaphores(nullptr),
+      bufferBindCount(in_struct->bufferBindCount),
+      pBufferBinds(nullptr),
+      imageOpaqueBindCount(in_struct->imageOpaqueBindCount),
+      pImageOpaqueBinds(nullptr),
+      imageBindCount(in_struct->imageBindCount),
+      pImageBinds(nullptr),
+      signalSemaphoreCount(in_struct->signalSemaphoreCount),
+      pSignalSemaphores(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (waitSemaphoreCount && in_struct->pWaitSemaphores) {
+        pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
+            pWaitSemaphores[i] = in_struct->pWaitSemaphores[i];
+        }
+    }
+    if (bufferBindCount && in_struct->pBufferBinds) {
+        pBufferBinds = new safe_VkSparseBufferMemoryBindInfo[bufferBindCount];
+        for (uint32_t i = 0; i < bufferBindCount; ++i) {
+            pBufferBinds[i].initialize(&in_struct->pBufferBinds[i]);
+        }
+    }
+    if (imageOpaqueBindCount && in_struct->pImageOpaqueBinds) {
+        pImageOpaqueBinds = new safe_VkSparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount];
+        for (uint32_t i = 0; i < imageOpaqueBindCount; ++i) {
+            pImageOpaqueBinds[i].initialize(&in_struct->pImageOpaqueBinds[i]);
+        }
+    }
+    if (imageBindCount && in_struct->pImageBinds) {
+        pImageBinds = new safe_VkSparseImageMemoryBindInfo[imageBindCount];
+        for (uint32_t i = 0; i < imageBindCount; ++i) {
+            pImageBinds[i].initialize(&in_struct->pImageBinds[i]);
+        }
+    }
+    if (signalSemaphoreCount && in_struct->pSignalSemaphores) {
+        pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
+        for (uint32_t i = 0; i < signalSemaphoreCount; ++i) {
+            pSignalSemaphores[i] = in_struct->pSignalSemaphores[i];
+        }
+    }
+}
+
+safe_VkBindSparseInfo::safe_VkBindSparseInfo()
+    : sType(VK_STRUCTURE_TYPE_BIND_SPARSE_INFO),
+      pNext(nullptr),
+      waitSemaphoreCount(),
+      pWaitSemaphores(nullptr),
+      bufferBindCount(),
+      pBufferBinds(nullptr),
+      imageOpaqueBindCount(),
+      pImageOpaqueBinds(nullptr),
+      imageBindCount(),
+      pImageBinds(nullptr),
+      signalSemaphoreCount(),
+      pSignalSemaphores(nullptr) {}
+
+safe_VkBindSparseInfo::safe_VkBindSparseInfo(const safe_VkBindSparseInfo& copy_src) {
+    sType = copy_src.sType;
+    waitSemaphoreCount = copy_src.waitSemaphoreCount;
+    pWaitSemaphores = nullptr;
+    bufferBindCount = copy_src.bufferBindCount;
+    pBufferBinds = nullptr;
+    imageOpaqueBindCount = copy_src.imageOpaqueBindCount;
+    pImageOpaqueBinds = nullptr;
+    imageBindCount = copy_src.imageBindCount;
+    pImageBinds = nullptr;
+    signalSemaphoreCount = copy_src.signalSemaphoreCount;
+    pSignalSemaphores = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (waitSemaphoreCount && copy_src.pWaitSemaphores) {
+        pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
+            pWaitSemaphores[i] = copy_src.pWaitSemaphores[i];
+        }
+    }
+    if (bufferBindCount && copy_src.pBufferBinds) {
+        pBufferBinds = new safe_VkSparseBufferMemoryBindInfo[bufferBindCount];
+        for (uint32_t i = 0; i < bufferBindCount; ++i) {
+            pBufferBinds[i].initialize(&copy_src.pBufferBinds[i]);
+        }
+    }
+    if (imageOpaqueBindCount && copy_src.pImageOpaqueBinds) {
+        pImageOpaqueBinds = new safe_VkSparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount];
+        for (uint32_t i = 0; i < imageOpaqueBindCount; ++i) {
+            pImageOpaqueBinds[i].initialize(&copy_src.pImageOpaqueBinds[i]);
+        }
+    }
+    if (imageBindCount && copy_src.pImageBinds) {
+        pImageBinds = new safe_VkSparseImageMemoryBindInfo[imageBindCount];
+        for (uint32_t i = 0; i < imageBindCount; ++i) {
+            pImageBinds[i].initialize(&copy_src.pImageBinds[i]);
+        }
+    }
+    if (signalSemaphoreCount && copy_src.pSignalSemaphores) {
+        pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
+        for (uint32_t i = 0; i < signalSemaphoreCount; ++i) {
+            pSignalSemaphores[i] = copy_src.pSignalSemaphores[i];
+        }
+    }
+}
+
+safe_VkBindSparseInfo& safe_VkBindSparseInfo::operator=(const safe_VkBindSparseInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pWaitSemaphores) delete[] pWaitSemaphores;
+    if (pBufferBinds) delete[] pBufferBinds;
+    if (pImageOpaqueBinds) delete[] pImageOpaqueBinds;
+    if (pImageBinds) delete[] pImageBinds;
+    if (pSignalSemaphores) delete[] pSignalSemaphores;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    waitSemaphoreCount = copy_src.waitSemaphoreCount;
+    pWaitSemaphores = nullptr;
+    bufferBindCount = copy_src.bufferBindCount;
+    pBufferBinds = nullptr;
+    imageOpaqueBindCount = copy_src.imageOpaqueBindCount;
+    pImageOpaqueBinds = nullptr;
+    imageBindCount = copy_src.imageBindCount;
+    pImageBinds = nullptr;
+    signalSemaphoreCount = copy_src.signalSemaphoreCount;
+    pSignalSemaphores = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (waitSemaphoreCount && copy_src.pWaitSemaphores) {
+        pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
+            pWaitSemaphores[i] = copy_src.pWaitSemaphores[i];
+        }
+    }
+    if (bufferBindCount && copy_src.pBufferBinds) {
+        pBufferBinds = new safe_VkSparseBufferMemoryBindInfo[bufferBindCount];
+        for (uint32_t i = 0; i < bufferBindCount; ++i) {
+            pBufferBinds[i].initialize(&copy_src.pBufferBinds[i]);
+        }
+    }
+    if (imageOpaqueBindCount && copy_src.pImageOpaqueBinds) {
+        pImageOpaqueBinds = new safe_VkSparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount];
+        for (uint32_t i = 0; i < imageOpaqueBindCount; ++i) {
+            pImageOpaqueBinds[i].initialize(&copy_src.pImageOpaqueBinds[i]);
+        }
+    }
+    if (imageBindCount && copy_src.pImageBinds) {
+        pImageBinds = new safe_VkSparseImageMemoryBindInfo[imageBindCount];
+        for (uint32_t i = 0; i < imageBindCount; ++i) {
+            pImageBinds[i].initialize(&copy_src.pImageBinds[i]);
+        }
+    }
+    if (signalSemaphoreCount && copy_src.pSignalSemaphores) {
+        pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
+        for (uint32_t i = 0; i < signalSemaphoreCount; ++i) {
+            pSignalSemaphores[i] = copy_src.pSignalSemaphores[i];
+        }
+    }
+
+    return *this;
+}
+
+safe_VkBindSparseInfo::~safe_VkBindSparseInfo() {
+    if (pWaitSemaphores) delete[] pWaitSemaphores;
+    if (pBufferBinds) delete[] pBufferBinds;
+    if (pImageOpaqueBinds) delete[] pImageOpaqueBinds;
+    if (pImageBinds) delete[] pImageBinds;
+    if (pSignalSemaphores) delete[] pSignalSemaphores;
+    FreePnextChain(pNext);
+}
+
+void safe_VkBindSparseInfo::initialize(const VkBindSparseInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pWaitSemaphores) delete[] pWaitSemaphores;
+    if (pBufferBinds) delete[] pBufferBinds;
+    if (pImageOpaqueBinds) delete[] pImageOpaqueBinds;
+    if (pImageBinds) delete[] pImageBinds;
+    if (pSignalSemaphores) delete[] pSignalSemaphores;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    waitSemaphoreCount = in_struct->waitSemaphoreCount;
+    pWaitSemaphores = nullptr;
+    bufferBindCount = in_struct->bufferBindCount;
+    pBufferBinds = nullptr;
+    imageOpaqueBindCount = in_struct->imageOpaqueBindCount;
+    pImageOpaqueBinds = nullptr;
+    imageBindCount = in_struct->imageBindCount;
+    pImageBinds = nullptr;
+    signalSemaphoreCount = in_struct->signalSemaphoreCount;
+    pSignalSemaphores = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (waitSemaphoreCount && in_struct->pWaitSemaphores) {
+        pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
+            pWaitSemaphores[i] = in_struct->pWaitSemaphores[i];
+        }
+    }
+    if (bufferBindCount && in_struct->pBufferBinds) {
+        pBufferBinds = new safe_VkSparseBufferMemoryBindInfo[bufferBindCount];
+        for (uint32_t i = 0; i < bufferBindCount; ++i) {
+            pBufferBinds[i].initialize(&in_struct->pBufferBinds[i]);
+        }
+    }
+    if (imageOpaqueBindCount && in_struct->pImageOpaqueBinds) {
+        pImageOpaqueBinds = new safe_VkSparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount];
+        for (uint32_t i = 0; i < imageOpaqueBindCount; ++i) {
+            pImageOpaqueBinds[i].initialize(&in_struct->pImageOpaqueBinds[i]);
+        }
+    }
+    if (imageBindCount && in_struct->pImageBinds) {
+        pImageBinds = new safe_VkSparseImageMemoryBindInfo[imageBindCount];
+        for (uint32_t i = 0; i < imageBindCount; ++i) {
+            pImageBinds[i].initialize(&in_struct->pImageBinds[i]);
+        }
+    }
+    if (signalSemaphoreCount && in_struct->pSignalSemaphores) {
+        pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
+        for (uint32_t i = 0; i < signalSemaphoreCount; ++i) {
+            pSignalSemaphores[i] = in_struct->pSignalSemaphores[i];
+        }
+    }
+}
+
+void safe_VkBindSparseInfo::initialize(const safe_VkBindSparseInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    waitSemaphoreCount = copy_src->waitSemaphoreCount;
+    pWaitSemaphores = nullptr;
+    bufferBindCount = copy_src->bufferBindCount;
+    pBufferBinds = nullptr;
+    imageOpaqueBindCount = copy_src->imageOpaqueBindCount;
+    pImageOpaqueBinds = nullptr;
+    imageBindCount = copy_src->imageBindCount;
+    pImageBinds = nullptr;
+    signalSemaphoreCount = copy_src->signalSemaphoreCount;
+    pSignalSemaphores = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (waitSemaphoreCount && copy_src->pWaitSemaphores) {
+        pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
+            pWaitSemaphores[i] = copy_src->pWaitSemaphores[i];
+        }
+    }
+    if (bufferBindCount && copy_src->pBufferBinds) {
+        pBufferBinds = new safe_VkSparseBufferMemoryBindInfo[bufferBindCount];
+        for (uint32_t i = 0; i < bufferBindCount; ++i) {
+            pBufferBinds[i].initialize(&copy_src->pBufferBinds[i]);
+        }
+    }
+    if (imageOpaqueBindCount && copy_src->pImageOpaqueBinds) {
+        pImageOpaqueBinds = new safe_VkSparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount];
+        for (uint32_t i = 0; i < imageOpaqueBindCount; ++i) {
+            pImageOpaqueBinds[i].initialize(&copy_src->pImageOpaqueBinds[i]);
+        }
+    }
+    if (imageBindCount && copy_src->pImageBinds) {
+        pImageBinds = new safe_VkSparseImageMemoryBindInfo[imageBindCount];
+        for (uint32_t i = 0; i < imageBindCount; ++i) {
+            pImageBinds[i].initialize(&copy_src->pImageBinds[i]);
+        }
+    }
+    if (signalSemaphoreCount && copy_src->pSignalSemaphores) {
+        pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
+        for (uint32_t i = 0; i < signalSemaphoreCount; ++i) {
+            pSignalSemaphores[i] = copy_src->pSignalSemaphores[i];
+        }
+    }
+}
+
+safe_VkFenceCreateInfo::safe_VkFenceCreateInfo(const VkFenceCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                               bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkFenceCreateInfo::safe_VkFenceCreateInfo() : sType(VK_STRUCTURE_TYPE_FENCE_CREATE_INFO), pNext(nullptr), flags() {}
+
+safe_VkFenceCreateInfo::safe_VkFenceCreateInfo(const safe_VkFenceCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkFenceCreateInfo& safe_VkFenceCreateInfo::operator=(const safe_VkFenceCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkFenceCreateInfo::~safe_VkFenceCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkFenceCreateInfo::initialize(const VkFenceCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkFenceCreateInfo::initialize(const safe_VkFenceCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSemaphoreCreateInfo::safe_VkSemaphoreCreateInfo(const VkSemaphoreCreateInfo* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSemaphoreCreateInfo::safe_VkSemaphoreCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO), pNext(nullptr), flags() {}
+
+safe_VkSemaphoreCreateInfo::safe_VkSemaphoreCreateInfo(const safe_VkSemaphoreCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSemaphoreCreateInfo& safe_VkSemaphoreCreateInfo::operator=(const safe_VkSemaphoreCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSemaphoreCreateInfo::~safe_VkSemaphoreCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkSemaphoreCreateInfo::initialize(const VkSemaphoreCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSemaphoreCreateInfo::initialize(const safe_VkSemaphoreCreateInfo* copy_src,
+                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkEventCreateInfo::safe_VkEventCreateInfo(const VkEventCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                               bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkEventCreateInfo::safe_VkEventCreateInfo() : sType(VK_STRUCTURE_TYPE_EVENT_CREATE_INFO), pNext(nullptr), flags() {}
+
+safe_VkEventCreateInfo::safe_VkEventCreateInfo(const safe_VkEventCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkEventCreateInfo& safe_VkEventCreateInfo::operator=(const safe_VkEventCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkEventCreateInfo::~safe_VkEventCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkEventCreateInfo::initialize(const VkEventCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkEventCreateInfo::initialize(const safe_VkEventCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkQueryPoolCreateInfo::safe_VkQueryPoolCreateInfo(const VkQueryPoolCreateInfo* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      queryType(in_struct->queryType),
+      queryCount(in_struct->queryCount),
+      pipelineStatistics(in_struct->pipelineStatistics) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkQueryPoolCreateInfo::safe_VkQueryPoolCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO), pNext(nullptr), flags(), queryType(), queryCount(), pipelineStatistics() {}
+
+safe_VkQueryPoolCreateInfo::safe_VkQueryPoolCreateInfo(const safe_VkQueryPoolCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    queryType = copy_src.queryType;
+    queryCount = copy_src.queryCount;
+    pipelineStatistics = copy_src.pipelineStatistics;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkQueryPoolCreateInfo& safe_VkQueryPoolCreateInfo::operator=(const safe_VkQueryPoolCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    queryType = copy_src.queryType;
+    queryCount = copy_src.queryCount;
+    pipelineStatistics = copy_src.pipelineStatistics;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkQueryPoolCreateInfo::~safe_VkQueryPoolCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkQueryPoolCreateInfo::initialize(const VkQueryPoolCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    queryType = in_struct->queryType;
+    queryCount = in_struct->queryCount;
+    pipelineStatistics = in_struct->pipelineStatistics;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkQueryPoolCreateInfo::initialize(const safe_VkQueryPoolCreateInfo* copy_src,
+                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    queryType = copy_src->queryType;
+    queryCount = copy_src->queryCount;
+    pipelineStatistics = copy_src->pipelineStatistics;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkBufferCreateInfo::safe_VkBufferCreateInfo(const VkBufferCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                                 bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      size(in_struct->size),
+      usage(in_struct->usage),
+      sharingMode(in_struct->sharingMode),
+      queueFamilyIndexCount(0),
+      pQueueFamilyIndices(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if ((in_struct->sharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->pQueueFamilyIndices) {
+        pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
+        memcpy((void*)pQueueFamilyIndices, (void*)in_struct->pQueueFamilyIndices,
+               sizeof(uint32_t) * in_struct->queueFamilyIndexCount);
+        queueFamilyIndexCount = in_struct->queueFamilyIndexCount;
+    } else {
+        queueFamilyIndexCount = 0;
+    }
+}
+
+safe_VkBufferCreateInfo::safe_VkBufferCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      size(),
+      usage(),
+      sharingMode(),
+      queueFamilyIndexCount(),
+      pQueueFamilyIndices(nullptr) {}
+
+safe_VkBufferCreateInfo::safe_VkBufferCreateInfo(const safe_VkBufferCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    size = copy_src.size;
+    usage = copy_src.usage;
+    sharingMode = copy_src.sharingMode;
+    pQueueFamilyIndices = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if ((copy_src.sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src.pQueueFamilyIndices) {
+        pQueueFamilyIndices = new uint32_t[copy_src.queueFamilyIndexCount];
+        memcpy((void*)pQueueFamilyIndices, (void*)copy_src.pQueueFamilyIndices, sizeof(uint32_t) * copy_src.queueFamilyIndexCount);
+        queueFamilyIndexCount = copy_src.queueFamilyIndexCount;
+    } else {
+        queueFamilyIndexCount = 0;
+    }
+}
+
+safe_VkBufferCreateInfo& safe_VkBufferCreateInfo::operator=(const safe_VkBufferCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pQueueFamilyIndices) delete[] pQueueFamilyIndices;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    size = copy_src.size;
+    usage = copy_src.usage;
+    sharingMode = copy_src.sharingMode;
+    pQueueFamilyIndices = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if ((copy_src.sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src.pQueueFamilyIndices) {
+        pQueueFamilyIndices = new uint32_t[copy_src.queueFamilyIndexCount];
+        memcpy((void*)pQueueFamilyIndices, (void*)copy_src.pQueueFamilyIndices, sizeof(uint32_t) * copy_src.queueFamilyIndexCount);
+        queueFamilyIndexCount = copy_src.queueFamilyIndexCount;
+    } else {
+        queueFamilyIndexCount = 0;
+    }
+
+    return *this;
+}
+
+safe_VkBufferCreateInfo::~safe_VkBufferCreateInfo() {
+    if (pQueueFamilyIndices) delete[] pQueueFamilyIndices;
+    FreePnextChain(pNext);
+}
+
+void safe_VkBufferCreateInfo::initialize(const VkBufferCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pQueueFamilyIndices) delete[] pQueueFamilyIndices;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    size = in_struct->size;
+    usage = in_struct->usage;
+    sharingMode = in_struct->sharingMode;
+    pQueueFamilyIndices = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if ((in_struct->sharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->pQueueFamilyIndices) {
+        pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
+        memcpy((void*)pQueueFamilyIndices, (void*)in_struct->pQueueFamilyIndices,
+               sizeof(uint32_t) * in_struct->queueFamilyIndexCount);
+        queueFamilyIndexCount = in_struct->queueFamilyIndexCount;
+    } else {
+        queueFamilyIndexCount = 0;
+    }
+}
+
+void safe_VkBufferCreateInfo::initialize(const safe_VkBufferCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    size = copy_src->size;
+    usage = copy_src->usage;
+    sharingMode = copy_src->sharingMode;
+    pQueueFamilyIndices = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if ((copy_src->sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src->pQueueFamilyIndices) {
+        pQueueFamilyIndices = new uint32_t[copy_src->queueFamilyIndexCount];
+        memcpy((void*)pQueueFamilyIndices, (void*)copy_src->pQueueFamilyIndices,
+               sizeof(uint32_t) * copy_src->queueFamilyIndexCount);
+        queueFamilyIndexCount = copy_src->queueFamilyIndexCount;
+    } else {
+        queueFamilyIndexCount = 0;
+    }
+}
+
+safe_VkBufferViewCreateInfo::safe_VkBufferViewCreateInfo(const VkBufferViewCreateInfo* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      buffer(in_struct->buffer),
+      format(in_struct->format),
+      offset(in_struct->offset),
+      range(in_struct->range) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkBufferViewCreateInfo::safe_VkBufferViewCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO), pNext(nullptr), flags(), buffer(), format(), offset(), range() {}
+
+safe_VkBufferViewCreateInfo::safe_VkBufferViewCreateInfo(const safe_VkBufferViewCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    buffer = copy_src.buffer;
+    format = copy_src.format;
+    offset = copy_src.offset;
+    range = copy_src.range;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBufferViewCreateInfo& safe_VkBufferViewCreateInfo::operator=(const safe_VkBufferViewCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    buffer = copy_src.buffer;
+    format = copy_src.format;
+    offset = copy_src.offset;
+    range = copy_src.range;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkBufferViewCreateInfo::~safe_VkBufferViewCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkBufferViewCreateInfo::initialize(const VkBufferViewCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    buffer = in_struct->buffer;
+    format = in_struct->format;
+    offset = in_struct->offset;
+    range = in_struct->range;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkBufferViewCreateInfo::initialize(const safe_VkBufferViewCreateInfo* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    buffer = copy_src->buffer;
+    format = copy_src->format;
+    offset = copy_src->offset;
+    range = copy_src->range;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkImageCreateInfo::safe_VkImageCreateInfo(const VkImageCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                               bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      imageType(in_struct->imageType),
+      format(in_struct->format),
+      extent(in_struct->extent),
+      mipLevels(in_struct->mipLevels),
+      arrayLayers(in_struct->arrayLayers),
+      samples(in_struct->samples),
+      tiling(in_struct->tiling),
+      usage(in_struct->usage),
+      sharingMode(in_struct->sharingMode),
+      queueFamilyIndexCount(0),
+      pQueueFamilyIndices(nullptr),
+      initialLayout(in_struct->initialLayout) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if ((in_struct->sharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->pQueueFamilyIndices) {
+        pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
+        memcpy((void*)pQueueFamilyIndices, (void*)in_struct->pQueueFamilyIndices,
+               sizeof(uint32_t) * in_struct->queueFamilyIndexCount);
+        queueFamilyIndexCount = in_struct->queueFamilyIndexCount;
+    } else {
+        queueFamilyIndexCount = 0;
+    }
+}
+
+safe_VkImageCreateInfo::safe_VkImageCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      imageType(),
+      format(),
+      extent(),
+      mipLevels(),
+      arrayLayers(),
+      samples(),
+      tiling(),
+      usage(),
+      sharingMode(),
+      queueFamilyIndexCount(),
+      pQueueFamilyIndices(nullptr),
+      initialLayout() {}
+
+safe_VkImageCreateInfo::safe_VkImageCreateInfo(const safe_VkImageCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    imageType = copy_src.imageType;
+    format = copy_src.format;
+    extent = copy_src.extent;
+    mipLevels = copy_src.mipLevels;
+    arrayLayers = copy_src.arrayLayers;
+    samples = copy_src.samples;
+    tiling = copy_src.tiling;
+    usage = copy_src.usage;
+    sharingMode = copy_src.sharingMode;
+    pQueueFamilyIndices = nullptr;
+    initialLayout = copy_src.initialLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if ((copy_src.sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src.pQueueFamilyIndices) {
+        pQueueFamilyIndices = new uint32_t[copy_src.queueFamilyIndexCount];
+        memcpy((void*)pQueueFamilyIndices, (void*)copy_src.pQueueFamilyIndices, sizeof(uint32_t) * copy_src.queueFamilyIndexCount);
+        queueFamilyIndexCount = copy_src.queueFamilyIndexCount;
+    } else {
+        queueFamilyIndexCount = 0;
+    }
+}
+
+safe_VkImageCreateInfo& safe_VkImageCreateInfo::operator=(const safe_VkImageCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pQueueFamilyIndices) delete[] pQueueFamilyIndices;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    imageType = copy_src.imageType;
+    format = copy_src.format;
+    extent = copy_src.extent;
+    mipLevels = copy_src.mipLevels;
+    arrayLayers = copy_src.arrayLayers;
+    samples = copy_src.samples;
+    tiling = copy_src.tiling;
+    usage = copy_src.usage;
+    sharingMode = copy_src.sharingMode;
+    pQueueFamilyIndices = nullptr;
+    initialLayout = copy_src.initialLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if ((copy_src.sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src.pQueueFamilyIndices) {
+        pQueueFamilyIndices = new uint32_t[copy_src.queueFamilyIndexCount];
+        memcpy((void*)pQueueFamilyIndices, (void*)copy_src.pQueueFamilyIndices, sizeof(uint32_t) * copy_src.queueFamilyIndexCount);
+        queueFamilyIndexCount = copy_src.queueFamilyIndexCount;
+    } else {
+        queueFamilyIndexCount = 0;
+    }
+
+    return *this;
+}
+
+safe_VkImageCreateInfo::~safe_VkImageCreateInfo() {
+    if (pQueueFamilyIndices) delete[] pQueueFamilyIndices;
+    FreePnextChain(pNext);
+}
+
+void safe_VkImageCreateInfo::initialize(const VkImageCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pQueueFamilyIndices) delete[] pQueueFamilyIndices;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    imageType = in_struct->imageType;
+    format = in_struct->format;
+    extent = in_struct->extent;
+    mipLevels = in_struct->mipLevels;
+    arrayLayers = in_struct->arrayLayers;
+    samples = in_struct->samples;
+    tiling = in_struct->tiling;
+    usage = in_struct->usage;
+    sharingMode = in_struct->sharingMode;
+    pQueueFamilyIndices = nullptr;
+    initialLayout = in_struct->initialLayout;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if ((in_struct->sharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->pQueueFamilyIndices) {
+        pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
+        memcpy((void*)pQueueFamilyIndices, (void*)in_struct->pQueueFamilyIndices,
+               sizeof(uint32_t) * in_struct->queueFamilyIndexCount);
+        queueFamilyIndexCount = in_struct->queueFamilyIndexCount;
+    } else {
+        queueFamilyIndexCount = 0;
+    }
+}
+
+void safe_VkImageCreateInfo::initialize(const safe_VkImageCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    imageType = copy_src->imageType;
+    format = copy_src->format;
+    extent = copy_src->extent;
+    mipLevels = copy_src->mipLevels;
+    arrayLayers = copy_src->arrayLayers;
+    samples = copy_src->samples;
+    tiling = copy_src->tiling;
+    usage = copy_src->usage;
+    sharingMode = copy_src->sharingMode;
+    pQueueFamilyIndices = nullptr;
+    initialLayout = copy_src->initialLayout;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if ((copy_src->sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src->pQueueFamilyIndices) {
+        pQueueFamilyIndices = new uint32_t[copy_src->queueFamilyIndexCount];
+        memcpy((void*)pQueueFamilyIndices, (void*)copy_src->pQueueFamilyIndices,
+               sizeof(uint32_t) * copy_src->queueFamilyIndexCount);
+        queueFamilyIndexCount = copy_src->queueFamilyIndexCount;
+    } else {
+        queueFamilyIndexCount = 0;
+    }
+}
+
+safe_VkImageViewCreateInfo::safe_VkImageViewCreateInfo(const VkImageViewCreateInfo* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      image(in_struct->image),
+      viewType(in_struct->viewType),
+      format(in_struct->format),
+      components(in_struct->components),
+      subresourceRange(in_struct->subresourceRange) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImageViewCreateInfo::safe_VkImageViewCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      image(),
+      viewType(),
+      format(),
+      components(),
+      subresourceRange() {}
+
+safe_VkImageViewCreateInfo::safe_VkImageViewCreateInfo(const safe_VkImageViewCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    image = copy_src.image;
+    viewType = copy_src.viewType;
+    format = copy_src.format;
+    components = copy_src.components;
+    subresourceRange = copy_src.subresourceRange;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImageViewCreateInfo& safe_VkImageViewCreateInfo::operator=(const safe_VkImageViewCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    image = copy_src.image;
+    viewType = copy_src.viewType;
+    format = copy_src.format;
+    components = copy_src.components;
+    subresourceRange = copy_src.subresourceRange;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImageViewCreateInfo::~safe_VkImageViewCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkImageViewCreateInfo::initialize(const VkImageViewCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    image = in_struct->image;
+    viewType = in_struct->viewType;
+    format = in_struct->format;
+    components = in_struct->components;
+    subresourceRange = in_struct->subresourceRange;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImageViewCreateInfo::initialize(const safe_VkImageViewCreateInfo* copy_src,
+                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    image = copy_src->image;
+    viewType = copy_src->viewType;
+    format = copy_src->format;
+    components = copy_src->components;
+    subresourceRange = copy_src->subresourceRange;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkShaderModuleCreateInfo::safe_VkShaderModuleCreateInfo(const VkShaderModuleCreateInfo* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags), codeSize(in_struct->codeSize), pCode(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pCode) {
+        pCode = reinterpret_cast<uint32_t*>(new uint8_t[codeSize]);
+        memcpy((void*)pCode, (void*)in_struct->pCode, codeSize);
+    }
+}
+
+safe_VkShaderModuleCreateInfo::safe_VkShaderModuleCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO), pNext(nullptr), flags(), codeSize(), pCode(nullptr) {}
+
+safe_VkShaderModuleCreateInfo::safe_VkShaderModuleCreateInfo(const safe_VkShaderModuleCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    codeSize = copy_src.codeSize;
+    pCode = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pCode) {
+        pCode = reinterpret_cast<uint32_t*>(new uint8_t[codeSize]);
+        memcpy((void*)pCode, (void*)copy_src.pCode, codeSize);
+    }
+}
+
+safe_VkShaderModuleCreateInfo& safe_VkShaderModuleCreateInfo::operator=(const safe_VkShaderModuleCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pCode) delete[] reinterpret_cast<const uint8_t*>(pCode);
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    codeSize = copy_src.codeSize;
+    pCode = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pCode) {
+        pCode = reinterpret_cast<uint32_t*>(new uint8_t[codeSize]);
+        memcpy((void*)pCode, (void*)copy_src.pCode, codeSize);
+    }
+
+    return *this;
+}
+
+safe_VkShaderModuleCreateInfo::~safe_VkShaderModuleCreateInfo() {
+    if (pCode) delete[] reinterpret_cast<const uint8_t*>(pCode);
+    FreePnextChain(pNext);
+}
+
+void safe_VkShaderModuleCreateInfo::initialize(const VkShaderModuleCreateInfo* in_struct,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pCode) delete[] reinterpret_cast<const uint8_t*>(pCode);
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    codeSize = in_struct->codeSize;
+    pCode = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pCode) {
+        pCode = reinterpret_cast<uint32_t*>(new uint8_t[codeSize]);
+        memcpy((void*)pCode, (void*)in_struct->pCode, codeSize);
+    }
+}
+
+void safe_VkShaderModuleCreateInfo::initialize(const safe_VkShaderModuleCreateInfo* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    codeSize = copy_src->codeSize;
+    pCode = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pCode) {
+        pCode = reinterpret_cast<uint32_t*>(new uint8_t[codeSize]);
+        memcpy((void*)pCode, (void*)copy_src->pCode, codeSize);
+    }
+}
+
+safe_VkPipelineCacheCreateInfo::safe_VkPipelineCacheCreateInfo(const VkPipelineCacheCreateInfo* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      initialDataSize(in_struct->initialDataSize),
+      pInitialData(in_struct->pInitialData) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPipelineCacheCreateInfo::safe_VkPipelineCacheCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO), pNext(nullptr), flags(), initialDataSize(), pInitialData(nullptr) {}
+
+safe_VkPipelineCacheCreateInfo::safe_VkPipelineCacheCreateInfo(const safe_VkPipelineCacheCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    initialDataSize = copy_src.initialDataSize;
+    pInitialData = copy_src.pInitialData;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPipelineCacheCreateInfo& safe_VkPipelineCacheCreateInfo::operator=(const safe_VkPipelineCacheCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    initialDataSize = copy_src.initialDataSize;
+    pInitialData = copy_src.pInitialData;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineCacheCreateInfo::~safe_VkPipelineCacheCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkPipelineCacheCreateInfo::initialize(const VkPipelineCacheCreateInfo* in_struct,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    initialDataSize = in_struct->initialDataSize;
+    pInitialData = in_struct->pInitialData;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPipelineCacheCreateInfo::initialize(const safe_VkPipelineCacheCreateInfo* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    initialDataSize = copy_src->initialDataSize;
+    pInitialData = copy_src->pInitialData;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSpecializationInfo::safe_VkSpecializationInfo(const VkSpecializationInfo* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state)
+    : mapEntryCount(in_struct->mapEntryCount), pMapEntries(nullptr), dataSize(in_struct->dataSize), pData(nullptr) {
+    if (in_struct->pMapEntries) {
+        pMapEntries = new VkSpecializationMapEntry[in_struct->mapEntryCount];
+        memcpy((void*)pMapEntries, (void*)in_struct->pMapEntries, sizeof(VkSpecializationMapEntry) * in_struct->mapEntryCount);
+    }
+
+    if (in_struct->pData != nullptr) {
+        auto temp = new std::byte[in_struct->dataSize];
+        std::memcpy(temp, in_struct->pData, in_struct->dataSize);
+        pData = temp;
+    }
+}
+
+safe_VkSpecializationInfo::safe_VkSpecializationInfo() : mapEntryCount(), pMapEntries(nullptr), dataSize(), pData(nullptr) {}
+
+safe_VkSpecializationInfo::safe_VkSpecializationInfo(const safe_VkSpecializationInfo& copy_src) {
+    mapEntryCount = copy_src.mapEntryCount;
+    pMapEntries = nullptr;
+    dataSize = copy_src.dataSize;
+
+    if (copy_src.pMapEntries) {
+        pMapEntries = new VkSpecializationMapEntry[copy_src.mapEntryCount];
+        memcpy((void*)pMapEntries, (void*)copy_src.pMapEntries, sizeof(VkSpecializationMapEntry) * copy_src.mapEntryCount);
+    }
+
+    if (copy_src.pData != nullptr) {
+        auto temp = new std::byte[copy_src.dataSize];
+        std::memcpy(temp, copy_src.pData, copy_src.dataSize);
+        pData = temp;
+    }
+}
+
+safe_VkSpecializationInfo& safe_VkSpecializationInfo::operator=(const safe_VkSpecializationInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pMapEntries) delete[] pMapEntries;
+
+    if (pData != nullptr) {
+        auto temp = reinterpret_cast<const std::byte*>(pData);
+        delete[] temp;
+    }
+
+    mapEntryCount = copy_src.mapEntryCount;
+    pMapEntries = nullptr;
+    dataSize = copy_src.dataSize;
+
+    if (copy_src.pMapEntries) {
+        pMapEntries = new VkSpecializationMapEntry[copy_src.mapEntryCount];
+        memcpy((void*)pMapEntries, (void*)copy_src.pMapEntries, sizeof(VkSpecializationMapEntry) * copy_src.mapEntryCount);
+    }
+
+    if (copy_src.pData != nullptr) {
+        auto temp = new std::byte[copy_src.dataSize];
+        std::memcpy(temp, copy_src.pData, copy_src.dataSize);
+        pData = temp;
+    }
+
+    return *this;
+}
+
+safe_VkSpecializationInfo::~safe_VkSpecializationInfo() {
+    if (pMapEntries) delete[] pMapEntries;
+
+    if (pData != nullptr) {
+        auto temp = reinterpret_cast<const std::byte*>(pData);
+        delete[] temp;
+    }
+}
+
+void safe_VkSpecializationInfo::initialize(const VkSpecializationInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pMapEntries) delete[] pMapEntries;
+
+    if (pData != nullptr) {
+        auto temp = reinterpret_cast<const std::byte*>(pData);
+        delete[] temp;
+    }
+    mapEntryCount = in_struct->mapEntryCount;
+    pMapEntries = nullptr;
+    dataSize = in_struct->dataSize;
+
+    if (in_struct->pMapEntries) {
+        pMapEntries = new VkSpecializationMapEntry[in_struct->mapEntryCount];
+        memcpy((void*)pMapEntries, (void*)in_struct->pMapEntries, sizeof(VkSpecializationMapEntry) * in_struct->mapEntryCount);
+    }
+
+    if (in_struct->pData != nullptr) {
+        auto temp = new std::byte[in_struct->dataSize];
+        std::memcpy(temp, in_struct->pData, in_struct->dataSize);
+        pData = temp;
+    }
+}
+
+void safe_VkSpecializationInfo::initialize(const safe_VkSpecializationInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    mapEntryCount = copy_src->mapEntryCount;
+    pMapEntries = nullptr;
+    dataSize = copy_src->dataSize;
+
+    if (copy_src->pMapEntries) {
+        pMapEntries = new VkSpecializationMapEntry[copy_src->mapEntryCount];
+        memcpy((void*)pMapEntries, (void*)copy_src->pMapEntries, sizeof(VkSpecializationMapEntry) * copy_src->mapEntryCount);
+    }
+
+    if (copy_src->pData != nullptr) {
+        auto temp = new std::byte[copy_src->dataSize];
+        std::memcpy(temp, copy_src->pData, copy_src->dataSize);
+        pData = temp;
+    }
+}
+
+safe_VkPipelineShaderStageCreateInfo::safe_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      stage(in_struct->stage),
+      module(in_struct->module),
+      pSpecializationInfo(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    pName = SafeStringCopy(in_struct->pName);
+    if (in_struct->pSpecializationInfo) pSpecializationInfo = new safe_VkSpecializationInfo(in_struct->pSpecializationInfo);
+}
+
+safe_VkPipelineShaderStageCreateInfo::safe_VkPipelineShaderStageCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      stage(),
+      module(),
+      pName(nullptr),
+      pSpecializationInfo(nullptr) {}
+
+safe_VkPipelineShaderStageCreateInfo::safe_VkPipelineShaderStageCreateInfo(const safe_VkPipelineShaderStageCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    stage = copy_src.stage;
+    module = copy_src.module;
+    pSpecializationInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    pName = SafeStringCopy(copy_src.pName);
+    if (copy_src.pSpecializationInfo) pSpecializationInfo = new safe_VkSpecializationInfo(*copy_src.pSpecializationInfo);
+}
+
+safe_VkPipelineShaderStageCreateInfo& safe_VkPipelineShaderStageCreateInfo::operator=(
+    const safe_VkPipelineShaderStageCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pName) delete[] pName;
+    if (pSpecializationInfo) delete pSpecializationInfo;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    stage = copy_src.stage;
+    module = copy_src.module;
+    pSpecializationInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    pName = SafeStringCopy(copy_src.pName);
+    if (copy_src.pSpecializationInfo) pSpecializationInfo = new safe_VkSpecializationInfo(*copy_src.pSpecializationInfo);
+
+    return *this;
+}
+
+safe_VkPipelineShaderStageCreateInfo::~safe_VkPipelineShaderStageCreateInfo() {
+    if (pName) delete[] pName;
+    if (pSpecializationInfo) delete pSpecializationInfo;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineShaderStageCreateInfo::initialize(const VkPipelineShaderStageCreateInfo* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pName) delete[] pName;
+    if (pSpecializationInfo) delete pSpecializationInfo;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    stage = in_struct->stage;
+    module = in_struct->module;
+    pSpecializationInfo = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    pName = SafeStringCopy(in_struct->pName);
+    if (in_struct->pSpecializationInfo) pSpecializationInfo = new safe_VkSpecializationInfo(in_struct->pSpecializationInfo);
+}
+
+void safe_VkPipelineShaderStageCreateInfo::initialize(const safe_VkPipelineShaderStageCreateInfo* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    stage = copy_src->stage;
+    module = copy_src->module;
+    pSpecializationInfo = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    pName = SafeStringCopy(copy_src->pName);
+    if (copy_src->pSpecializationInfo) pSpecializationInfo = new safe_VkSpecializationInfo(*copy_src->pSpecializationInfo);
+}
+
+safe_VkComputePipelineCreateInfo::safe_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      stage(&in_struct->stage),
+      layout(in_struct->layout),
+      basePipelineHandle(in_struct->basePipelineHandle),
+      basePipelineIndex(in_struct->basePipelineIndex) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkComputePipelineCreateInfo::safe_VkComputePipelineCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      layout(),
+      basePipelineHandle(),
+      basePipelineIndex() {}
+
+safe_VkComputePipelineCreateInfo::safe_VkComputePipelineCreateInfo(const safe_VkComputePipelineCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    stage.initialize(&copy_src.stage);
+    layout = copy_src.layout;
+    basePipelineHandle = copy_src.basePipelineHandle;
+    basePipelineIndex = copy_src.basePipelineIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkComputePipelineCreateInfo& safe_VkComputePipelineCreateInfo::operator=(const safe_VkComputePipelineCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    stage.initialize(&copy_src.stage);
+    layout = copy_src.layout;
+    basePipelineHandle = copy_src.basePipelineHandle;
+    basePipelineIndex = copy_src.basePipelineIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkComputePipelineCreateInfo::~safe_VkComputePipelineCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkComputePipelineCreateInfo::initialize(const VkComputePipelineCreateInfo* in_struct,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    stage.initialize(&in_struct->stage);
+    layout = in_struct->layout;
+    basePipelineHandle = in_struct->basePipelineHandle;
+    basePipelineIndex = in_struct->basePipelineIndex;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkComputePipelineCreateInfo::initialize(const safe_VkComputePipelineCreateInfo* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    stage.initialize(&copy_src->stage);
+    layout = copy_src->layout;
+    basePipelineHandle = copy_src->basePipelineHandle;
+    basePipelineIndex = copy_src->basePipelineIndex;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineVertexInputStateCreateInfo::safe_VkPipelineVertexInputStateCreateInfo(
+    const VkPipelineVertexInputStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      vertexBindingDescriptionCount(in_struct->vertexBindingDescriptionCount),
+      pVertexBindingDescriptions(nullptr),
+      vertexAttributeDescriptionCount(in_struct->vertexAttributeDescriptionCount),
+      pVertexAttributeDescriptions(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pVertexBindingDescriptions) {
+        pVertexBindingDescriptions = new VkVertexInputBindingDescription[in_struct->vertexBindingDescriptionCount];
+        memcpy((void*)pVertexBindingDescriptions, (void*)in_struct->pVertexBindingDescriptions,
+               sizeof(VkVertexInputBindingDescription) * in_struct->vertexBindingDescriptionCount);
+    }
+
+    if (in_struct->pVertexAttributeDescriptions) {
+        pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[in_struct->vertexAttributeDescriptionCount];
+        memcpy((void*)pVertexAttributeDescriptions, (void*)in_struct->pVertexAttributeDescriptions,
+               sizeof(VkVertexInputAttributeDescription) * in_struct->vertexAttributeDescriptionCount);
+    }
+}
+
+safe_VkPipelineVertexInputStateCreateInfo::safe_VkPipelineVertexInputStateCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      vertexBindingDescriptionCount(),
+      pVertexBindingDescriptions(nullptr),
+      vertexAttributeDescriptionCount(),
+      pVertexAttributeDescriptions(nullptr) {}
+
+safe_VkPipelineVertexInputStateCreateInfo::safe_VkPipelineVertexInputStateCreateInfo(
+    const safe_VkPipelineVertexInputStateCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    vertexBindingDescriptionCount = copy_src.vertexBindingDescriptionCount;
+    pVertexBindingDescriptions = nullptr;
+    vertexAttributeDescriptionCount = copy_src.vertexAttributeDescriptionCount;
+    pVertexAttributeDescriptions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pVertexBindingDescriptions) {
+        pVertexBindingDescriptions = new VkVertexInputBindingDescription[copy_src.vertexBindingDescriptionCount];
+        memcpy((void*)pVertexBindingDescriptions, (void*)copy_src.pVertexBindingDescriptions,
+               sizeof(VkVertexInputBindingDescription) * copy_src.vertexBindingDescriptionCount);
+    }
+
+    if (copy_src.pVertexAttributeDescriptions) {
+        pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[copy_src.vertexAttributeDescriptionCount];
+        memcpy((void*)pVertexAttributeDescriptions, (void*)copy_src.pVertexAttributeDescriptions,
+               sizeof(VkVertexInputAttributeDescription) * copy_src.vertexAttributeDescriptionCount);
+    }
+}
+
+safe_VkPipelineVertexInputStateCreateInfo& safe_VkPipelineVertexInputStateCreateInfo::operator=(
+    const safe_VkPipelineVertexInputStateCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pVertexBindingDescriptions) delete[] pVertexBindingDescriptions;
+    if (pVertexAttributeDescriptions) delete[] pVertexAttributeDescriptions;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    vertexBindingDescriptionCount = copy_src.vertexBindingDescriptionCount;
+    pVertexBindingDescriptions = nullptr;
+    vertexAttributeDescriptionCount = copy_src.vertexAttributeDescriptionCount;
+    pVertexAttributeDescriptions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pVertexBindingDescriptions) {
+        pVertexBindingDescriptions = new VkVertexInputBindingDescription[copy_src.vertexBindingDescriptionCount];
+        memcpy((void*)pVertexBindingDescriptions, (void*)copy_src.pVertexBindingDescriptions,
+               sizeof(VkVertexInputBindingDescription) * copy_src.vertexBindingDescriptionCount);
+    }
+
+    if (copy_src.pVertexAttributeDescriptions) {
+        pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[copy_src.vertexAttributeDescriptionCount];
+        memcpy((void*)pVertexAttributeDescriptions, (void*)copy_src.pVertexAttributeDescriptions,
+               sizeof(VkVertexInputAttributeDescription) * copy_src.vertexAttributeDescriptionCount);
+    }
+
+    return *this;
+}
+
+safe_VkPipelineVertexInputStateCreateInfo::~safe_VkPipelineVertexInputStateCreateInfo() {
+    if (pVertexBindingDescriptions) delete[] pVertexBindingDescriptions;
+    if (pVertexAttributeDescriptions) delete[] pVertexAttributeDescriptions;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineVertexInputStateCreateInfo::initialize(const VkPipelineVertexInputStateCreateInfo* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pVertexBindingDescriptions) delete[] pVertexBindingDescriptions;
+    if (pVertexAttributeDescriptions) delete[] pVertexAttributeDescriptions;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    vertexBindingDescriptionCount = in_struct->vertexBindingDescriptionCount;
+    pVertexBindingDescriptions = nullptr;
+    vertexAttributeDescriptionCount = in_struct->vertexAttributeDescriptionCount;
+    pVertexAttributeDescriptions = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pVertexBindingDescriptions) {
+        pVertexBindingDescriptions = new VkVertexInputBindingDescription[in_struct->vertexBindingDescriptionCount];
+        memcpy((void*)pVertexBindingDescriptions, (void*)in_struct->pVertexBindingDescriptions,
+               sizeof(VkVertexInputBindingDescription) * in_struct->vertexBindingDescriptionCount);
+    }
+
+    if (in_struct->pVertexAttributeDescriptions) {
+        pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[in_struct->vertexAttributeDescriptionCount];
+        memcpy((void*)pVertexAttributeDescriptions, (void*)in_struct->pVertexAttributeDescriptions,
+               sizeof(VkVertexInputAttributeDescription) * in_struct->vertexAttributeDescriptionCount);
+    }
+}
+
+void safe_VkPipelineVertexInputStateCreateInfo::initialize(const safe_VkPipelineVertexInputStateCreateInfo* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    vertexBindingDescriptionCount = copy_src->vertexBindingDescriptionCount;
+    pVertexBindingDescriptions = nullptr;
+    vertexAttributeDescriptionCount = copy_src->vertexAttributeDescriptionCount;
+    pVertexAttributeDescriptions = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pVertexBindingDescriptions) {
+        pVertexBindingDescriptions = new VkVertexInputBindingDescription[copy_src->vertexBindingDescriptionCount];
+        memcpy((void*)pVertexBindingDescriptions, (void*)copy_src->pVertexBindingDescriptions,
+               sizeof(VkVertexInputBindingDescription) * copy_src->vertexBindingDescriptionCount);
+    }
+
+    if (copy_src->pVertexAttributeDescriptions) {
+        pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[copy_src->vertexAttributeDescriptionCount];
+        memcpy((void*)pVertexAttributeDescriptions, (void*)copy_src->pVertexAttributeDescriptions,
+               sizeof(VkVertexInputAttributeDescription) * copy_src->vertexAttributeDescriptionCount);
+    }
+}
+
+safe_VkPipelineInputAssemblyStateCreateInfo::safe_VkPipelineInputAssemblyStateCreateInfo(
+    const VkPipelineInputAssemblyStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      topology(in_struct->topology),
+      primitiveRestartEnable(in_struct->primitiveRestartEnable) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPipelineInputAssemblyStateCreateInfo::safe_VkPipelineInputAssemblyStateCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      topology(),
+      primitiveRestartEnable() {}
+
+safe_VkPipelineInputAssemblyStateCreateInfo::safe_VkPipelineInputAssemblyStateCreateInfo(
+    const safe_VkPipelineInputAssemblyStateCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    topology = copy_src.topology;
+    primitiveRestartEnable = copy_src.primitiveRestartEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPipelineInputAssemblyStateCreateInfo& safe_VkPipelineInputAssemblyStateCreateInfo::operator=(
+    const safe_VkPipelineInputAssemblyStateCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    topology = copy_src.topology;
+    primitiveRestartEnable = copy_src.primitiveRestartEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineInputAssemblyStateCreateInfo::~safe_VkPipelineInputAssemblyStateCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkPipelineInputAssemblyStateCreateInfo::initialize(const VkPipelineInputAssemblyStateCreateInfo* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    topology = in_struct->topology;
+    primitiveRestartEnable = in_struct->primitiveRestartEnable;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPipelineInputAssemblyStateCreateInfo::initialize(const safe_VkPipelineInputAssemblyStateCreateInfo* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    topology = copy_src->topology;
+    primitiveRestartEnable = copy_src->primitiveRestartEnable;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineTessellationStateCreateInfo::safe_VkPipelineTessellationStateCreateInfo(
+    const VkPipelineTessellationStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags), patchControlPoints(in_struct->patchControlPoints) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPipelineTessellationStateCreateInfo::safe_VkPipelineTessellationStateCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO), pNext(nullptr), flags(), patchControlPoints() {}
+
+safe_VkPipelineTessellationStateCreateInfo::safe_VkPipelineTessellationStateCreateInfo(
+    const safe_VkPipelineTessellationStateCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    patchControlPoints = copy_src.patchControlPoints;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPipelineTessellationStateCreateInfo& safe_VkPipelineTessellationStateCreateInfo::operator=(
+    const safe_VkPipelineTessellationStateCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    patchControlPoints = copy_src.patchControlPoints;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineTessellationStateCreateInfo::~safe_VkPipelineTessellationStateCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkPipelineTessellationStateCreateInfo::initialize(const VkPipelineTessellationStateCreateInfo* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    patchControlPoints = in_struct->patchControlPoints;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPipelineTessellationStateCreateInfo::initialize(const safe_VkPipelineTessellationStateCreateInfo* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    patchControlPoints = copy_src->patchControlPoints;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineRasterizationStateCreateInfo::safe_VkPipelineRasterizationStateCreateInfo(
+    const VkPipelineRasterizationStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      depthClampEnable(in_struct->depthClampEnable),
+      rasterizerDiscardEnable(in_struct->rasterizerDiscardEnable),
+      polygonMode(in_struct->polygonMode),
+      cullMode(in_struct->cullMode),
+      frontFace(in_struct->frontFace),
+      depthBiasEnable(in_struct->depthBiasEnable),
+      depthBiasConstantFactor(in_struct->depthBiasConstantFactor),
+      depthBiasClamp(in_struct->depthBiasClamp),
+      depthBiasSlopeFactor(in_struct->depthBiasSlopeFactor),
+      lineWidth(in_struct->lineWidth) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPipelineRasterizationStateCreateInfo::safe_VkPipelineRasterizationStateCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      depthClampEnable(),
+      rasterizerDiscardEnable(),
+      polygonMode(),
+      cullMode(),
+      frontFace(),
+      depthBiasEnable(),
+      depthBiasConstantFactor(),
+      depthBiasClamp(),
+      depthBiasSlopeFactor(),
+      lineWidth() {}
+
+safe_VkPipelineRasterizationStateCreateInfo::safe_VkPipelineRasterizationStateCreateInfo(
+    const safe_VkPipelineRasterizationStateCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    depthClampEnable = copy_src.depthClampEnable;
+    rasterizerDiscardEnable = copy_src.rasterizerDiscardEnable;
+    polygonMode = copy_src.polygonMode;
+    cullMode = copy_src.cullMode;
+    frontFace = copy_src.frontFace;
+    depthBiasEnable = copy_src.depthBiasEnable;
+    depthBiasConstantFactor = copy_src.depthBiasConstantFactor;
+    depthBiasClamp = copy_src.depthBiasClamp;
+    depthBiasSlopeFactor = copy_src.depthBiasSlopeFactor;
+    lineWidth = copy_src.lineWidth;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPipelineRasterizationStateCreateInfo& safe_VkPipelineRasterizationStateCreateInfo::operator=(
+    const safe_VkPipelineRasterizationStateCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    depthClampEnable = copy_src.depthClampEnable;
+    rasterizerDiscardEnable = copy_src.rasterizerDiscardEnable;
+    polygonMode = copy_src.polygonMode;
+    cullMode = copy_src.cullMode;
+    frontFace = copy_src.frontFace;
+    depthBiasEnable = copy_src.depthBiasEnable;
+    depthBiasConstantFactor = copy_src.depthBiasConstantFactor;
+    depthBiasClamp = copy_src.depthBiasClamp;
+    depthBiasSlopeFactor = copy_src.depthBiasSlopeFactor;
+    lineWidth = copy_src.lineWidth;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineRasterizationStateCreateInfo::~safe_VkPipelineRasterizationStateCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkPipelineRasterizationStateCreateInfo::initialize(const VkPipelineRasterizationStateCreateInfo* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    depthClampEnable = in_struct->depthClampEnable;
+    rasterizerDiscardEnable = in_struct->rasterizerDiscardEnable;
+    polygonMode = in_struct->polygonMode;
+    cullMode = in_struct->cullMode;
+    frontFace = in_struct->frontFace;
+    depthBiasEnable = in_struct->depthBiasEnable;
+    depthBiasConstantFactor = in_struct->depthBiasConstantFactor;
+    depthBiasClamp = in_struct->depthBiasClamp;
+    depthBiasSlopeFactor = in_struct->depthBiasSlopeFactor;
+    lineWidth = in_struct->lineWidth;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPipelineRasterizationStateCreateInfo::initialize(const safe_VkPipelineRasterizationStateCreateInfo* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    depthClampEnable = copy_src->depthClampEnable;
+    rasterizerDiscardEnable = copy_src->rasterizerDiscardEnable;
+    polygonMode = copy_src->polygonMode;
+    cullMode = copy_src->cullMode;
+    frontFace = copy_src->frontFace;
+    depthBiasEnable = copy_src->depthBiasEnable;
+    depthBiasConstantFactor = copy_src->depthBiasConstantFactor;
+    depthBiasClamp = copy_src->depthBiasClamp;
+    depthBiasSlopeFactor = copy_src->depthBiasSlopeFactor;
+    lineWidth = copy_src->lineWidth;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineMultisampleStateCreateInfo::safe_VkPipelineMultisampleStateCreateInfo(
+    const VkPipelineMultisampleStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      rasterizationSamples(in_struct->rasterizationSamples),
+      sampleShadingEnable(in_struct->sampleShadingEnable),
+      minSampleShading(in_struct->minSampleShading),
+      pSampleMask(nullptr),
+      alphaToCoverageEnable(in_struct->alphaToCoverageEnable),
+      alphaToOneEnable(in_struct->alphaToOneEnable) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pSampleMask) {
+        pSampleMask = new VkSampleMask(*in_struct->pSampleMask);
+    }
+}
+
+safe_VkPipelineMultisampleStateCreateInfo::safe_VkPipelineMultisampleStateCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      rasterizationSamples(),
+      sampleShadingEnable(),
+      minSampleShading(),
+      pSampleMask(nullptr),
+      alphaToCoverageEnable(),
+      alphaToOneEnable() {}
+
+safe_VkPipelineMultisampleStateCreateInfo::safe_VkPipelineMultisampleStateCreateInfo(
+    const safe_VkPipelineMultisampleStateCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    rasterizationSamples = copy_src.rasterizationSamples;
+    sampleShadingEnable = copy_src.sampleShadingEnable;
+    minSampleShading = copy_src.minSampleShading;
+    pSampleMask = nullptr;
+    alphaToCoverageEnable = copy_src.alphaToCoverageEnable;
+    alphaToOneEnable = copy_src.alphaToOneEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pSampleMask) {
+        pSampleMask = new VkSampleMask(*copy_src.pSampleMask);
+    }
+}
+
+safe_VkPipelineMultisampleStateCreateInfo& safe_VkPipelineMultisampleStateCreateInfo::operator=(
+    const safe_VkPipelineMultisampleStateCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pSampleMask) delete pSampleMask;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    rasterizationSamples = copy_src.rasterizationSamples;
+    sampleShadingEnable = copy_src.sampleShadingEnable;
+    minSampleShading = copy_src.minSampleShading;
+    pSampleMask = nullptr;
+    alphaToCoverageEnable = copy_src.alphaToCoverageEnable;
+    alphaToOneEnable = copy_src.alphaToOneEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pSampleMask) {
+        pSampleMask = new VkSampleMask(*copy_src.pSampleMask);
+    }
+
+    return *this;
+}
+
+safe_VkPipelineMultisampleStateCreateInfo::~safe_VkPipelineMultisampleStateCreateInfo() {
+    if (pSampleMask) delete pSampleMask;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineMultisampleStateCreateInfo::initialize(const VkPipelineMultisampleStateCreateInfo* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pSampleMask) delete pSampleMask;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    rasterizationSamples = in_struct->rasterizationSamples;
+    sampleShadingEnable = in_struct->sampleShadingEnable;
+    minSampleShading = in_struct->minSampleShading;
+    pSampleMask = nullptr;
+    alphaToCoverageEnable = in_struct->alphaToCoverageEnable;
+    alphaToOneEnable = in_struct->alphaToOneEnable;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pSampleMask) {
+        pSampleMask = new VkSampleMask(*in_struct->pSampleMask);
+    }
+}
+
+void safe_VkPipelineMultisampleStateCreateInfo::initialize(const safe_VkPipelineMultisampleStateCreateInfo* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    rasterizationSamples = copy_src->rasterizationSamples;
+    sampleShadingEnable = copy_src->sampleShadingEnable;
+    minSampleShading = copy_src->minSampleShading;
+    pSampleMask = nullptr;
+    alphaToCoverageEnable = copy_src->alphaToCoverageEnable;
+    alphaToOneEnable = copy_src->alphaToOneEnable;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pSampleMask) {
+        pSampleMask = new VkSampleMask(*copy_src->pSampleMask);
+    }
+}
+
+safe_VkPipelineDepthStencilStateCreateInfo::safe_VkPipelineDepthStencilStateCreateInfo(
+    const VkPipelineDepthStencilStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      depthTestEnable(in_struct->depthTestEnable),
+      depthWriteEnable(in_struct->depthWriteEnable),
+      depthCompareOp(in_struct->depthCompareOp),
+      depthBoundsTestEnable(in_struct->depthBoundsTestEnable),
+      stencilTestEnable(in_struct->stencilTestEnable),
+      front(in_struct->front),
+      back(in_struct->back),
+      minDepthBounds(in_struct->minDepthBounds),
+      maxDepthBounds(in_struct->maxDepthBounds) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPipelineDepthStencilStateCreateInfo::safe_VkPipelineDepthStencilStateCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      depthTestEnable(),
+      depthWriteEnable(),
+      depthCompareOp(),
+      depthBoundsTestEnable(),
+      stencilTestEnable(),
+      front(),
+      back(),
+      minDepthBounds(),
+      maxDepthBounds() {}
+
+safe_VkPipelineDepthStencilStateCreateInfo::safe_VkPipelineDepthStencilStateCreateInfo(
+    const safe_VkPipelineDepthStencilStateCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    depthTestEnable = copy_src.depthTestEnable;
+    depthWriteEnable = copy_src.depthWriteEnable;
+    depthCompareOp = copy_src.depthCompareOp;
+    depthBoundsTestEnable = copy_src.depthBoundsTestEnable;
+    stencilTestEnable = copy_src.stencilTestEnable;
+    front = copy_src.front;
+    back = copy_src.back;
+    minDepthBounds = copy_src.minDepthBounds;
+    maxDepthBounds = copy_src.maxDepthBounds;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPipelineDepthStencilStateCreateInfo& safe_VkPipelineDepthStencilStateCreateInfo::operator=(
+    const safe_VkPipelineDepthStencilStateCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    depthTestEnable = copy_src.depthTestEnable;
+    depthWriteEnable = copy_src.depthWriteEnable;
+    depthCompareOp = copy_src.depthCompareOp;
+    depthBoundsTestEnable = copy_src.depthBoundsTestEnable;
+    stencilTestEnable = copy_src.stencilTestEnable;
+    front = copy_src.front;
+    back = copy_src.back;
+    minDepthBounds = copy_src.minDepthBounds;
+    maxDepthBounds = copy_src.maxDepthBounds;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineDepthStencilStateCreateInfo::~safe_VkPipelineDepthStencilStateCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkPipelineDepthStencilStateCreateInfo::initialize(const VkPipelineDepthStencilStateCreateInfo* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    depthTestEnable = in_struct->depthTestEnable;
+    depthWriteEnable = in_struct->depthWriteEnable;
+    depthCompareOp = in_struct->depthCompareOp;
+    depthBoundsTestEnable = in_struct->depthBoundsTestEnable;
+    stencilTestEnable = in_struct->stencilTestEnable;
+    front = in_struct->front;
+    back = in_struct->back;
+    minDepthBounds = in_struct->minDepthBounds;
+    maxDepthBounds = in_struct->maxDepthBounds;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPipelineDepthStencilStateCreateInfo::initialize(const safe_VkPipelineDepthStencilStateCreateInfo* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    depthTestEnable = copy_src->depthTestEnable;
+    depthWriteEnable = copy_src->depthWriteEnable;
+    depthCompareOp = copy_src->depthCompareOp;
+    depthBoundsTestEnable = copy_src->depthBoundsTestEnable;
+    stencilTestEnable = copy_src->stencilTestEnable;
+    front = copy_src->front;
+    back = copy_src->back;
+    minDepthBounds = copy_src->minDepthBounds;
+    maxDepthBounds = copy_src->maxDepthBounds;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineColorBlendStateCreateInfo::safe_VkPipelineColorBlendStateCreateInfo(
+    const VkPipelineColorBlendStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      logicOpEnable(in_struct->logicOpEnable),
+      logicOp(in_struct->logicOp),
+      attachmentCount(in_struct->attachmentCount),
+      pAttachments(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pAttachments) {
+        pAttachments = new VkPipelineColorBlendAttachmentState[in_struct->attachmentCount];
+        memcpy((void*)pAttachments, (void*)in_struct->pAttachments,
+               sizeof(VkPipelineColorBlendAttachmentState) * in_struct->attachmentCount);
+    }
+
+    for (uint32_t i = 0; i < 4; ++i) {
+        blendConstants[i] = in_struct->blendConstants[i];
+    }
+}
+
+safe_VkPipelineColorBlendStateCreateInfo::safe_VkPipelineColorBlendStateCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      logicOpEnable(),
+      logicOp(),
+      attachmentCount(),
+      pAttachments(nullptr) {}
+
+safe_VkPipelineColorBlendStateCreateInfo::safe_VkPipelineColorBlendStateCreateInfo(
+    const safe_VkPipelineColorBlendStateCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    logicOpEnable = copy_src.logicOpEnable;
+    logicOp = copy_src.logicOp;
+    attachmentCount = copy_src.attachmentCount;
+    pAttachments = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pAttachments) {
+        pAttachments = new VkPipelineColorBlendAttachmentState[copy_src.attachmentCount];
+        memcpy((void*)pAttachments, (void*)copy_src.pAttachments,
+               sizeof(VkPipelineColorBlendAttachmentState) * copy_src.attachmentCount);
+    }
+
+    for (uint32_t i = 0; i < 4; ++i) {
+        blendConstants[i] = copy_src.blendConstants[i];
+    }
+}
+
+safe_VkPipelineColorBlendStateCreateInfo& safe_VkPipelineColorBlendStateCreateInfo::operator=(
+    const safe_VkPipelineColorBlendStateCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pAttachments) delete[] pAttachments;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    logicOpEnable = copy_src.logicOpEnable;
+    logicOp = copy_src.logicOp;
+    attachmentCount = copy_src.attachmentCount;
+    pAttachments = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pAttachments) {
+        pAttachments = new VkPipelineColorBlendAttachmentState[copy_src.attachmentCount];
+        memcpy((void*)pAttachments, (void*)copy_src.pAttachments,
+               sizeof(VkPipelineColorBlendAttachmentState) * copy_src.attachmentCount);
+    }
+
+    for (uint32_t i = 0; i < 4; ++i) {
+        blendConstants[i] = copy_src.blendConstants[i];
+    }
+
+    return *this;
+}
+
+safe_VkPipelineColorBlendStateCreateInfo::~safe_VkPipelineColorBlendStateCreateInfo() {
+    if (pAttachments) delete[] pAttachments;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineColorBlendStateCreateInfo::initialize(const VkPipelineColorBlendStateCreateInfo* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pAttachments) delete[] pAttachments;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    logicOpEnable = in_struct->logicOpEnable;
+    logicOp = in_struct->logicOp;
+    attachmentCount = in_struct->attachmentCount;
+    pAttachments = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pAttachments) {
+        pAttachments = new VkPipelineColorBlendAttachmentState[in_struct->attachmentCount];
+        memcpy((void*)pAttachments, (void*)in_struct->pAttachments,
+               sizeof(VkPipelineColorBlendAttachmentState) * in_struct->attachmentCount);
+    }
+
+    for (uint32_t i = 0; i < 4; ++i) {
+        blendConstants[i] = in_struct->blendConstants[i];
+    }
+}
+
+void safe_VkPipelineColorBlendStateCreateInfo::initialize(const safe_VkPipelineColorBlendStateCreateInfo* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    logicOpEnable = copy_src->logicOpEnable;
+    logicOp = copy_src->logicOp;
+    attachmentCount = copy_src->attachmentCount;
+    pAttachments = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pAttachments) {
+        pAttachments = new VkPipelineColorBlendAttachmentState[copy_src->attachmentCount];
+        memcpy((void*)pAttachments, (void*)copy_src->pAttachments,
+               sizeof(VkPipelineColorBlendAttachmentState) * copy_src->attachmentCount);
+    }
+
+    for (uint32_t i = 0; i < 4; ++i) {
+        blendConstants[i] = copy_src->blendConstants[i];
+    }
+}
+
+safe_VkPipelineDynamicStateCreateInfo::safe_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags), dynamicStateCount(in_struct->dynamicStateCount), pDynamicStates(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pDynamicStates) {
+        pDynamicStates = new VkDynamicState[in_struct->dynamicStateCount];
+        memcpy((void*)pDynamicStates, (void*)in_struct->pDynamicStates, sizeof(VkDynamicState) * in_struct->dynamicStateCount);
+    }
+}
+
+safe_VkPipelineDynamicStateCreateInfo::safe_VkPipelineDynamicStateCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      dynamicStateCount(),
+      pDynamicStates(nullptr) {}
+
+safe_VkPipelineDynamicStateCreateInfo::safe_VkPipelineDynamicStateCreateInfo(
+    const safe_VkPipelineDynamicStateCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    dynamicStateCount = copy_src.dynamicStateCount;
+    pDynamicStates = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDynamicStates) {
+        pDynamicStates = new VkDynamicState[copy_src.dynamicStateCount];
+        memcpy((void*)pDynamicStates, (void*)copy_src.pDynamicStates, sizeof(VkDynamicState) * copy_src.dynamicStateCount);
+    }
+}
+
+safe_VkPipelineDynamicStateCreateInfo& safe_VkPipelineDynamicStateCreateInfo::operator=(
+    const safe_VkPipelineDynamicStateCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pDynamicStates) delete[] pDynamicStates;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    dynamicStateCount = copy_src.dynamicStateCount;
+    pDynamicStates = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDynamicStates) {
+        pDynamicStates = new VkDynamicState[copy_src.dynamicStateCount];
+        memcpy((void*)pDynamicStates, (void*)copy_src.pDynamicStates, sizeof(VkDynamicState) * copy_src.dynamicStateCount);
+    }
+
+    return *this;
+}
+
+safe_VkPipelineDynamicStateCreateInfo::~safe_VkPipelineDynamicStateCreateInfo() {
+    if (pDynamicStates) delete[] pDynamicStates;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineDynamicStateCreateInfo::initialize(const VkPipelineDynamicStateCreateInfo* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pDynamicStates) delete[] pDynamicStates;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    dynamicStateCount = in_struct->dynamicStateCount;
+    pDynamicStates = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pDynamicStates) {
+        pDynamicStates = new VkDynamicState[in_struct->dynamicStateCount];
+        memcpy((void*)pDynamicStates, (void*)in_struct->pDynamicStates, sizeof(VkDynamicState) * in_struct->dynamicStateCount);
+    }
+}
+
+void safe_VkPipelineDynamicStateCreateInfo::initialize(const safe_VkPipelineDynamicStateCreateInfo* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    dynamicStateCount = copy_src->dynamicStateCount;
+    pDynamicStates = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pDynamicStates) {
+        pDynamicStates = new VkDynamicState[copy_src->dynamicStateCount];
+        memcpy((void*)pDynamicStates, (void*)copy_src->pDynamicStates, sizeof(VkDynamicState) * copy_src->dynamicStateCount);
+    }
+}
+
+safe_VkPipelineLayoutCreateInfo::safe_VkPipelineLayoutCreateInfo(const VkPipelineLayoutCreateInfo* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      setLayoutCount(in_struct->setLayoutCount),
+      pSetLayouts(nullptr),
+      pushConstantRangeCount(in_struct->pushConstantRangeCount),
+      pPushConstantRanges(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (setLayoutCount && in_struct->pSetLayouts) {
+        pSetLayouts = new VkDescriptorSetLayout[setLayoutCount];
+        for (uint32_t i = 0; i < setLayoutCount; ++i) {
+            pSetLayouts[i] = in_struct->pSetLayouts[i];
+        }
+    }
+
+    if (in_struct->pPushConstantRanges) {
+        pPushConstantRanges = new VkPushConstantRange[in_struct->pushConstantRangeCount];
+        memcpy((void*)pPushConstantRanges, (void*)in_struct->pPushConstantRanges,
+               sizeof(VkPushConstantRange) * in_struct->pushConstantRangeCount);
+    }
+}
+
+safe_VkPipelineLayoutCreateInfo::safe_VkPipelineLayoutCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      setLayoutCount(),
+      pSetLayouts(nullptr),
+      pushConstantRangeCount(),
+      pPushConstantRanges(nullptr) {}
+
+safe_VkPipelineLayoutCreateInfo::safe_VkPipelineLayoutCreateInfo(const safe_VkPipelineLayoutCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    setLayoutCount = copy_src.setLayoutCount;
+    pSetLayouts = nullptr;
+    pushConstantRangeCount = copy_src.pushConstantRangeCount;
+    pPushConstantRanges = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (setLayoutCount && copy_src.pSetLayouts) {
+        pSetLayouts = new VkDescriptorSetLayout[setLayoutCount];
+        for (uint32_t i = 0; i < setLayoutCount; ++i) {
+            pSetLayouts[i] = copy_src.pSetLayouts[i];
+        }
+    }
+
+    if (copy_src.pPushConstantRanges) {
+        pPushConstantRanges = new VkPushConstantRange[copy_src.pushConstantRangeCount];
+        memcpy((void*)pPushConstantRanges, (void*)copy_src.pPushConstantRanges,
+               sizeof(VkPushConstantRange) * copy_src.pushConstantRangeCount);
+    }
+}
+
+safe_VkPipelineLayoutCreateInfo& safe_VkPipelineLayoutCreateInfo::operator=(const safe_VkPipelineLayoutCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pSetLayouts) delete[] pSetLayouts;
+    if (pPushConstantRanges) delete[] pPushConstantRanges;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    setLayoutCount = copy_src.setLayoutCount;
+    pSetLayouts = nullptr;
+    pushConstantRangeCount = copy_src.pushConstantRangeCount;
+    pPushConstantRanges = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (setLayoutCount && copy_src.pSetLayouts) {
+        pSetLayouts = new VkDescriptorSetLayout[setLayoutCount];
+        for (uint32_t i = 0; i < setLayoutCount; ++i) {
+            pSetLayouts[i] = copy_src.pSetLayouts[i];
+        }
+    }
+
+    if (copy_src.pPushConstantRanges) {
+        pPushConstantRanges = new VkPushConstantRange[copy_src.pushConstantRangeCount];
+        memcpy((void*)pPushConstantRanges, (void*)copy_src.pPushConstantRanges,
+               sizeof(VkPushConstantRange) * copy_src.pushConstantRangeCount);
+    }
+
+    return *this;
+}
+
+safe_VkPipelineLayoutCreateInfo::~safe_VkPipelineLayoutCreateInfo() {
+    if (pSetLayouts) delete[] pSetLayouts;
+    if (pPushConstantRanges) delete[] pPushConstantRanges;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineLayoutCreateInfo::initialize(const VkPipelineLayoutCreateInfo* in_struct,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pSetLayouts) delete[] pSetLayouts;
+    if (pPushConstantRanges) delete[] pPushConstantRanges;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    setLayoutCount = in_struct->setLayoutCount;
+    pSetLayouts = nullptr;
+    pushConstantRangeCount = in_struct->pushConstantRangeCount;
+    pPushConstantRanges = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (setLayoutCount && in_struct->pSetLayouts) {
+        pSetLayouts = new VkDescriptorSetLayout[setLayoutCount];
+        for (uint32_t i = 0; i < setLayoutCount; ++i) {
+            pSetLayouts[i] = in_struct->pSetLayouts[i];
+        }
+    }
+
+    if (in_struct->pPushConstantRanges) {
+        pPushConstantRanges = new VkPushConstantRange[in_struct->pushConstantRangeCount];
+        memcpy((void*)pPushConstantRanges, (void*)in_struct->pPushConstantRanges,
+               sizeof(VkPushConstantRange) * in_struct->pushConstantRangeCount);
+    }
+}
+
+void safe_VkPipelineLayoutCreateInfo::initialize(const safe_VkPipelineLayoutCreateInfo* copy_src,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    setLayoutCount = copy_src->setLayoutCount;
+    pSetLayouts = nullptr;
+    pushConstantRangeCount = copy_src->pushConstantRangeCount;
+    pPushConstantRanges = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (setLayoutCount && copy_src->pSetLayouts) {
+        pSetLayouts = new VkDescriptorSetLayout[setLayoutCount];
+        for (uint32_t i = 0; i < setLayoutCount; ++i) {
+            pSetLayouts[i] = copy_src->pSetLayouts[i];
+        }
+    }
+
+    if (copy_src->pPushConstantRanges) {
+        pPushConstantRanges = new VkPushConstantRange[copy_src->pushConstantRangeCount];
+        memcpy((void*)pPushConstantRanges, (void*)copy_src->pPushConstantRanges,
+               sizeof(VkPushConstantRange) * copy_src->pushConstantRangeCount);
+    }
+}
+
+safe_VkSamplerCreateInfo::safe_VkSamplerCreateInfo(const VkSamplerCreateInfo* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      magFilter(in_struct->magFilter),
+      minFilter(in_struct->minFilter),
+      mipmapMode(in_struct->mipmapMode),
+      addressModeU(in_struct->addressModeU),
+      addressModeV(in_struct->addressModeV),
+      addressModeW(in_struct->addressModeW),
+      mipLodBias(in_struct->mipLodBias),
+      anisotropyEnable(in_struct->anisotropyEnable),
+      maxAnisotropy(in_struct->maxAnisotropy),
+      compareEnable(in_struct->compareEnable),
+      compareOp(in_struct->compareOp),
+      minLod(in_struct->minLod),
+      maxLod(in_struct->maxLod),
+      borderColor(in_struct->borderColor),
+      unnormalizedCoordinates(in_struct->unnormalizedCoordinates) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSamplerCreateInfo::safe_VkSamplerCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      magFilter(),
+      minFilter(),
+      mipmapMode(),
+      addressModeU(),
+      addressModeV(),
+      addressModeW(),
+      mipLodBias(),
+      anisotropyEnable(),
+      maxAnisotropy(),
+      compareEnable(),
+      compareOp(),
+      minLod(),
+      maxLod(),
+      borderColor(),
+      unnormalizedCoordinates() {}
+
+safe_VkSamplerCreateInfo::safe_VkSamplerCreateInfo(const safe_VkSamplerCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    magFilter = copy_src.magFilter;
+    minFilter = copy_src.minFilter;
+    mipmapMode = copy_src.mipmapMode;
+    addressModeU = copy_src.addressModeU;
+    addressModeV = copy_src.addressModeV;
+    addressModeW = copy_src.addressModeW;
+    mipLodBias = copy_src.mipLodBias;
+    anisotropyEnable = copy_src.anisotropyEnable;
+    maxAnisotropy = copy_src.maxAnisotropy;
+    compareEnable = copy_src.compareEnable;
+    compareOp = copy_src.compareOp;
+    minLod = copy_src.minLod;
+    maxLod = copy_src.maxLod;
+    borderColor = copy_src.borderColor;
+    unnormalizedCoordinates = copy_src.unnormalizedCoordinates;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSamplerCreateInfo& safe_VkSamplerCreateInfo::operator=(const safe_VkSamplerCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    magFilter = copy_src.magFilter;
+    minFilter = copy_src.minFilter;
+    mipmapMode = copy_src.mipmapMode;
+    addressModeU = copy_src.addressModeU;
+    addressModeV = copy_src.addressModeV;
+    addressModeW = copy_src.addressModeW;
+    mipLodBias = copy_src.mipLodBias;
+    anisotropyEnable = copy_src.anisotropyEnable;
+    maxAnisotropy = copy_src.maxAnisotropy;
+    compareEnable = copy_src.compareEnable;
+    compareOp = copy_src.compareOp;
+    minLod = copy_src.minLod;
+    maxLod = copy_src.maxLod;
+    borderColor = copy_src.borderColor;
+    unnormalizedCoordinates = copy_src.unnormalizedCoordinates;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSamplerCreateInfo::~safe_VkSamplerCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkSamplerCreateInfo::initialize(const VkSamplerCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    magFilter = in_struct->magFilter;
+    minFilter = in_struct->minFilter;
+    mipmapMode = in_struct->mipmapMode;
+    addressModeU = in_struct->addressModeU;
+    addressModeV = in_struct->addressModeV;
+    addressModeW = in_struct->addressModeW;
+    mipLodBias = in_struct->mipLodBias;
+    anisotropyEnable = in_struct->anisotropyEnable;
+    maxAnisotropy = in_struct->maxAnisotropy;
+    compareEnable = in_struct->compareEnable;
+    compareOp = in_struct->compareOp;
+    minLod = in_struct->minLod;
+    maxLod = in_struct->maxLod;
+    borderColor = in_struct->borderColor;
+    unnormalizedCoordinates = in_struct->unnormalizedCoordinates;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSamplerCreateInfo::initialize(const safe_VkSamplerCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    magFilter = copy_src->magFilter;
+    minFilter = copy_src->minFilter;
+    mipmapMode = copy_src->mipmapMode;
+    addressModeU = copy_src->addressModeU;
+    addressModeV = copy_src->addressModeV;
+    addressModeW = copy_src->addressModeW;
+    mipLodBias = copy_src->mipLodBias;
+    anisotropyEnable = copy_src->anisotropyEnable;
+    maxAnisotropy = copy_src->maxAnisotropy;
+    compareEnable = copy_src->compareEnable;
+    compareOp = copy_src->compareOp;
+    minLod = copy_src->minLod;
+    maxLod = copy_src->maxLod;
+    borderColor = copy_src->borderColor;
+    unnormalizedCoordinates = copy_src->unnormalizedCoordinates;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkCopyDescriptorSet::safe_VkCopyDescriptorSet(const VkCopyDescriptorSet* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      srcSet(in_struct->srcSet),
+      srcBinding(in_struct->srcBinding),
+      srcArrayElement(in_struct->srcArrayElement),
+      dstSet(in_struct->dstSet),
+      dstBinding(in_struct->dstBinding),
+      dstArrayElement(in_struct->dstArrayElement),
+      descriptorCount(in_struct->descriptorCount) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkCopyDescriptorSet::safe_VkCopyDescriptorSet()
+    : sType(VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET),
+      pNext(nullptr),
+      srcSet(),
+      srcBinding(),
+      srcArrayElement(),
+      dstSet(),
+      dstBinding(),
+      dstArrayElement(),
+      descriptorCount() {}
+
+safe_VkCopyDescriptorSet::safe_VkCopyDescriptorSet(const safe_VkCopyDescriptorSet& copy_src) {
+    sType = copy_src.sType;
+    srcSet = copy_src.srcSet;
+    srcBinding = copy_src.srcBinding;
+    srcArrayElement = copy_src.srcArrayElement;
+    dstSet = copy_src.dstSet;
+    dstBinding = copy_src.dstBinding;
+    dstArrayElement = copy_src.dstArrayElement;
+    descriptorCount = copy_src.descriptorCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkCopyDescriptorSet& safe_VkCopyDescriptorSet::operator=(const safe_VkCopyDescriptorSet& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    srcSet = copy_src.srcSet;
+    srcBinding = copy_src.srcBinding;
+    srcArrayElement = copy_src.srcArrayElement;
+    dstSet = copy_src.dstSet;
+    dstBinding = copy_src.dstBinding;
+    dstArrayElement = copy_src.dstArrayElement;
+    descriptorCount = copy_src.descriptorCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkCopyDescriptorSet::~safe_VkCopyDescriptorSet() { FreePnextChain(pNext); }
+
+void safe_VkCopyDescriptorSet::initialize(const VkCopyDescriptorSet* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    srcSet = in_struct->srcSet;
+    srcBinding = in_struct->srcBinding;
+    srcArrayElement = in_struct->srcArrayElement;
+    dstSet = in_struct->dstSet;
+    dstBinding = in_struct->dstBinding;
+    dstArrayElement = in_struct->dstArrayElement;
+    descriptorCount = in_struct->descriptorCount;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkCopyDescriptorSet::initialize(const safe_VkCopyDescriptorSet* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    srcSet = copy_src->srcSet;
+    srcBinding = copy_src->srcBinding;
+    srcArrayElement = copy_src->srcArrayElement;
+    dstSet = copy_src->dstSet;
+    dstBinding = copy_src->dstBinding;
+    dstArrayElement = copy_src->dstArrayElement;
+    descriptorCount = copy_src->descriptorCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDescriptorPoolCreateInfo::safe_VkDescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      maxSets(in_struct->maxSets),
+      poolSizeCount(in_struct->poolSizeCount),
+      pPoolSizes(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pPoolSizes) {
+        pPoolSizes = new VkDescriptorPoolSize[in_struct->poolSizeCount];
+        memcpy((void*)pPoolSizes, (void*)in_struct->pPoolSizes, sizeof(VkDescriptorPoolSize) * in_struct->poolSizeCount);
+    }
+}
+
+safe_VkDescriptorPoolCreateInfo::safe_VkDescriptorPoolCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      maxSets(),
+      poolSizeCount(),
+      pPoolSizes(nullptr) {}
+
+safe_VkDescriptorPoolCreateInfo::safe_VkDescriptorPoolCreateInfo(const safe_VkDescriptorPoolCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    maxSets = copy_src.maxSets;
+    poolSizeCount = copy_src.poolSizeCount;
+    pPoolSizes = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pPoolSizes) {
+        pPoolSizes = new VkDescriptorPoolSize[copy_src.poolSizeCount];
+        memcpy((void*)pPoolSizes, (void*)copy_src.pPoolSizes, sizeof(VkDescriptorPoolSize) * copy_src.poolSizeCount);
+    }
+}
+
+safe_VkDescriptorPoolCreateInfo& safe_VkDescriptorPoolCreateInfo::operator=(const safe_VkDescriptorPoolCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pPoolSizes) delete[] pPoolSizes;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    maxSets = copy_src.maxSets;
+    poolSizeCount = copy_src.poolSizeCount;
+    pPoolSizes = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pPoolSizes) {
+        pPoolSizes = new VkDescriptorPoolSize[copy_src.poolSizeCount];
+        memcpy((void*)pPoolSizes, (void*)copy_src.pPoolSizes, sizeof(VkDescriptorPoolSize) * copy_src.poolSizeCount);
+    }
+
+    return *this;
+}
+
+safe_VkDescriptorPoolCreateInfo::~safe_VkDescriptorPoolCreateInfo() {
+    if (pPoolSizes) delete[] pPoolSizes;
+    FreePnextChain(pNext);
+}
+
+void safe_VkDescriptorPoolCreateInfo::initialize(const VkDescriptorPoolCreateInfo* in_struct,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pPoolSizes) delete[] pPoolSizes;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    maxSets = in_struct->maxSets;
+    poolSizeCount = in_struct->poolSizeCount;
+    pPoolSizes = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pPoolSizes) {
+        pPoolSizes = new VkDescriptorPoolSize[in_struct->poolSizeCount];
+        memcpy((void*)pPoolSizes, (void*)in_struct->pPoolSizes, sizeof(VkDescriptorPoolSize) * in_struct->poolSizeCount);
+    }
+}
+
+void safe_VkDescriptorPoolCreateInfo::initialize(const safe_VkDescriptorPoolCreateInfo* copy_src,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    maxSets = copy_src->maxSets;
+    poolSizeCount = copy_src->poolSizeCount;
+    pPoolSizes = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pPoolSizes) {
+        pPoolSizes = new VkDescriptorPoolSize[copy_src->poolSizeCount];
+        memcpy((void*)pPoolSizes, (void*)copy_src->pPoolSizes, sizeof(VkDescriptorPoolSize) * copy_src->poolSizeCount);
+    }
+}
+
+safe_VkDescriptorSetAllocateInfo::safe_VkDescriptorSetAllocateInfo(const VkDescriptorSetAllocateInfo* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      descriptorPool(in_struct->descriptorPool),
+      descriptorSetCount(in_struct->descriptorSetCount),
+      pSetLayouts(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (descriptorSetCount && in_struct->pSetLayouts) {
+        pSetLayouts = new VkDescriptorSetLayout[descriptorSetCount];
+        for (uint32_t i = 0; i < descriptorSetCount; ++i) {
+            pSetLayouts[i] = in_struct->pSetLayouts[i];
+        }
+    }
+}
+
+safe_VkDescriptorSetAllocateInfo::safe_VkDescriptorSetAllocateInfo()
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO),
+      pNext(nullptr),
+      descriptorPool(),
+      descriptorSetCount(),
+      pSetLayouts(nullptr) {}
+
+safe_VkDescriptorSetAllocateInfo::safe_VkDescriptorSetAllocateInfo(const safe_VkDescriptorSetAllocateInfo& copy_src) {
+    sType = copy_src.sType;
+    descriptorPool = copy_src.descriptorPool;
+    descriptorSetCount = copy_src.descriptorSetCount;
+    pSetLayouts = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (descriptorSetCount && copy_src.pSetLayouts) {
+        pSetLayouts = new VkDescriptorSetLayout[descriptorSetCount];
+        for (uint32_t i = 0; i < descriptorSetCount; ++i) {
+            pSetLayouts[i] = copy_src.pSetLayouts[i];
+        }
+    }
+}
+
+safe_VkDescriptorSetAllocateInfo& safe_VkDescriptorSetAllocateInfo::operator=(const safe_VkDescriptorSetAllocateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pSetLayouts) delete[] pSetLayouts;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    descriptorPool = copy_src.descriptorPool;
+    descriptorSetCount = copy_src.descriptorSetCount;
+    pSetLayouts = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (descriptorSetCount && copy_src.pSetLayouts) {
+        pSetLayouts = new VkDescriptorSetLayout[descriptorSetCount];
+        for (uint32_t i = 0; i < descriptorSetCount; ++i) {
+            pSetLayouts[i] = copy_src.pSetLayouts[i];
+        }
+    }
+
+    return *this;
+}
+
+safe_VkDescriptorSetAllocateInfo::~safe_VkDescriptorSetAllocateInfo() {
+    if (pSetLayouts) delete[] pSetLayouts;
+    FreePnextChain(pNext);
+}
+
+void safe_VkDescriptorSetAllocateInfo::initialize(const VkDescriptorSetAllocateInfo* in_struct,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pSetLayouts) delete[] pSetLayouts;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    descriptorPool = in_struct->descriptorPool;
+    descriptorSetCount = in_struct->descriptorSetCount;
+    pSetLayouts = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (descriptorSetCount && in_struct->pSetLayouts) {
+        pSetLayouts = new VkDescriptorSetLayout[descriptorSetCount];
+        for (uint32_t i = 0; i < descriptorSetCount; ++i) {
+            pSetLayouts[i] = in_struct->pSetLayouts[i];
+        }
+    }
+}
+
+void safe_VkDescriptorSetAllocateInfo::initialize(const safe_VkDescriptorSetAllocateInfo* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    descriptorPool = copy_src->descriptorPool;
+    descriptorSetCount = copy_src->descriptorSetCount;
+    pSetLayouts = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (descriptorSetCount && copy_src->pSetLayouts) {
+        pSetLayouts = new VkDescriptorSetLayout[descriptorSetCount];
+        for (uint32_t i = 0; i < descriptorSetCount; ++i) {
+            pSetLayouts[i] = copy_src->pSetLayouts[i];
+        }
+    }
+}
+
+safe_VkDescriptorSetLayoutBinding::safe_VkDescriptorSetLayoutBinding(const VkDescriptorSetLayoutBinding* in_struct,
+                                                                     [[maybe_unused]] PNextCopyState* copy_state)
+    : binding(in_struct->binding),
+      descriptorType(in_struct->descriptorType),
+      descriptorCount(in_struct->descriptorCount),
+      stageFlags(in_struct->stageFlags),
+      pImmutableSamplers(nullptr) {
+    const bool sampler_type = in_struct->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER ||
+                              in_struct->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+    if (descriptorCount && in_struct->pImmutableSamplers && sampler_type) {
+        pImmutableSamplers = new VkSampler[descriptorCount];
+        for (uint32_t i = 0; i < descriptorCount; ++i) {
+            pImmutableSamplers[i] = in_struct->pImmutableSamplers[i];
+        }
+    }
+}
+
+safe_VkDescriptorSetLayoutBinding::safe_VkDescriptorSetLayoutBinding()
+    : binding(), descriptorType(), descriptorCount(), stageFlags(), pImmutableSamplers(nullptr) {}
+
+safe_VkDescriptorSetLayoutBinding::safe_VkDescriptorSetLayoutBinding(const safe_VkDescriptorSetLayoutBinding& copy_src) {
+    binding = copy_src.binding;
+    descriptorType = copy_src.descriptorType;
+    descriptorCount = copy_src.descriptorCount;
+    stageFlags = copy_src.stageFlags;
+    pImmutableSamplers = nullptr;
+
+    const bool sampler_type = copy_src.descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER ||
+                              copy_src.descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+    if (descriptorCount && copy_src.pImmutableSamplers && sampler_type) {
+        pImmutableSamplers = new VkSampler[descriptorCount];
+        for (uint32_t i = 0; i < descriptorCount; ++i) {
+            pImmutableSamplers[i] = copy_src.pImmutableSamplers[i];
+        }
+    }
+}
+
+safe_VkDescriptorSetLayoutBinding& safe_VkDescriptorSetLayoutBinding::operator=(const safe_VkDescriptorSetLayoutBinding& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pImmutableSamplers) delete[] pImmutableSamplers;
+
+    binding = copy_src.binding;
+    descriptorType = copy_src.descriptorType;
+    descriptorCount = copy_src.descriptorCount;
+    stageFlags = copy_src.stageFlags;
+    pImmutableSamplers = nullptr;
+
+    const bool sampler_type = copy_src.descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER ||
+                              copy_src.descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+    if (descriptorCount && copy_src.pImmutableSamplers && sampler_type) {
+        pImmutableSamplers = new VkSampler[descriptorCount];
+        for (uint32_t i = 0; i < descriptorCount; ++i) {
+            pImmutableSamplers[i] = copy_src.pImmutableSamplers[i];
+        }
+    }
+
+    return *this;
+}
+
+safe_VkDescriptorSetLayoutBinding::~safe_VkDescriptorSetLayoutBinding() {
+    if (pImmutableSamplers) delete[] pImmutableSamplers;
+}
+
+void safe_VkDescriptorSetLayoutBinding::initialize(const VkDescriptorSetLayoutBinding* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pImmutableSamplers) delete[] pImmutableSamplers;
+    binding = in_struct->binding;
+    descriptorType = in_struct->descriptorType;
+    descriptorCount = in_struct->descriptorCount;
+    stageFlags = in_struct->stageFlags;
+    pImmutableSamplers = nullptr;
+
+    const bool sampler_type = in_struct->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER ||
+                              in_struct->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+    if (descriptorCount && in_struct->pImmutableSamplers && sampler_type) {
+        pImmutableSamplers = new VkSampler[descriptorCount];
+        for (uint32_t i = 0; i < descriptorCount; ++i) {
+            pImmutableSamplers[i] = in_struct->pImmutableSamplers[i];
+        }
+    }
+}
+
+void safe_VkDescriptorSetLayoutBinding::initialize(const safe_VkDescriptorSetLayoutBinding* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    binding = copy_src->binding;
+    descriptorType = copy_src->descriptorType;
+    descriptorCount = copy_src->descriptorCount;
+    stageFlags = copy_src->stageFlags;
+    pImmutableSamplers = nullptr;
+
+    const bool sampler_type = copy_src->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER ||
+                              copy_src->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+    if (descriptorCount && copy_src->pImmutableSamplers && sampler_type) {
+        pImmutableSamplers = new VkSampler[descriptorCount];
+        for (uint32_t i = 0; i < descriptorCount; ++i) {
+            pImmutableSamplers[i] = copy_src->pImmutableSamplers[i];
+        }
+    }
+}
+
+safe_VkDescriptorSetLayoutCreateInfo::safe_VkDescriptorSetLayoutCreateInfo(const VkDescriptorSetLayoutCreateInfo* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags), bindingCount(in_struct->bindingCount), pBindings(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (bindingCount && in_struct->pBindings) {
+        pBindings = new safe_VkDescriptorSetLayoutBinding[bindingCount];
+        for (uint32_t i = 0; i < bindingCount; ++i) {
+            pBindings[i].initialize(&in_struct->pBindings[i]);
+        }
+    }
+}
+
+safe_VkDescriptorSetLayoutCreateInfo::safe_VkDescriptorSetLayoutCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO), pNext(nullptr), flags(), bindingCount(), pBindings(nullptr) {}
+
+safe_VkDescriptorSetLayoutCreateInfo::safe_VkDescriptorSetLayoutCreateInfo(const safe_VkDescriptorSetLayoutCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    bindingCount = copy_src.bindingCount;
+    pBindings = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (bindingCount && copy_src.pBindings) {
+        pBindings = new safe_VkDescriptorSetLayoutBinding[bindingCount];
+        for (uint32_t i = 0; i < bindingCount; ++i) {
+            pBindings[i].initialize(&copy_src.pBindings[i]);
+        }
+    }
+}
+
+safe_VkDescriptorSetLayoutCreateInfo& safe_VkDescriptorSetLayoutCreateInfo::operator=(
+    const safe_VkDescriptorSetLayoutCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pBindings) delete[] pBindings;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    bindingCount = copy_src.bindingCount;
+    pBindings = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (bindingCount && copy_src.pBindings) {
+        pBindings = new safe_VkDescriptorSetLayoutBinding[bindingCount];
+        for (uint32_t i = 0; i < bindingCount; ++i) {
+            pBindings[i].initialize(&copy_src.pBindings[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkDescriptorSetLayoutCreateInfo::~safe_VkDescriptorSetLayoutCreateInfo() {
+    if (pBindings) delete[] pBindings;
+    FreePnextChain(pNext);
+}
+
+void safe_VkDescriptorSetLayoutCreateInfo::initialize(const VkDescriptorSetLayoutCreateInfo* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pBindings) delete[] pBindings;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    bindingCount = in_struct->bindingCount;
+    pBindings = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (bindingCount && in_struct->pBindings) {
+        pBindings = new safe_VkDescriptorSetLayoutBinding[bindingCount];
+        for (uint32_t i = 0; i < bindingCount; ++i) {
+            pBindings[i].initialize(&in_struct->pBindings[i]);
+        }
+    }
+}
+
+void safe_VkDescriptorSetLayoutCreateInfo::initialize(const safe_VkDescriptorSetLayoutCreateInfo* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    bindingCount = copy_src->bindingCount;
+    pBindings = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (bindingCount && copy_src->pBindings) {
+        pBindings = new safe_VkDescriptorSetLayoutBinding[bindingCount];
+        for (uint32_t i = 0; i < bindingCount; ++i) {
+            pBindings[i].initialize(&copy_src->pBindings[i]);
+        }
+    }
+}
+
+safe_VkWriteDescriptorSet::safe_VkWriteDescriptorSet(const VkWriteDescriptorSet* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      dstSet(in_struct->dstSet),
+      dstBinding(in_struct->dstBinding),
+      dstArrayElement(in_struct->dstArrayElement),
+      descriptorCount(in_struct->descriptorCount),
+      descriptorType(in_struct->descriptorType),
+      pImageInfo(nullptr),
+      pBufferInfo(nullptr),
+      pTexelBufferView(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    switch (descriptorType) {
+        case VK_DESCRIPTOR_TYPE_SAMPLER:
+        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+        case VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM:
+        case VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM:
+            if (descriptorCount && in_struct->pImageInfo) {
+                pImageInfo = new VkDescriptorImageInfo[descriptorCount];
+                for (uint32_t i = 0; i < descriptorCount; ++i) {
+                    pImageInfo[i] = in_struct->pImageInfo[i];
+                }
+            }
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+            if (descriptorCount && in_struct->pBufferInfo) {
+                pBufferInfo = new VkDescriptorBufferInfo[descriptorCount];
+                for (uint32_t i = 0; i < descriptorCount; ++i) {
+                    pBufferInfo[i] = in_struct->pBufferInfo[i];
+                }
+            }
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+            if (descriptorCount && in_struct->pTexelBufferView) {
+                pTexelBufferView = new VkBufferView[descriptorCount];
+                for (uint32_t i = 0; i < descriptorCount; ++i) {
+                    pTexelBufferView[i] = in_struct->pTexelBufferView[i];
+                }
+            }
+            break;
+        default:
+            break;
+    }
+}
+
+safe_VkWriteDescriptorSet::safe_VkWriteDescriptorSet()
+    : sType(VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET),
+      pNext(nullptr),
+      dstSet(),
+      dstBinding(),
+      dstArrayElement(),
+      descriptorCount(),
+      descriptorType(),
+      pImageInfo(nullptr),
+      pBufferInfo(nullptr),
+      pTexelBufferView(nullptr) {}
+
+safe_VkWriteDescriptorSet::safe_VkWriteDescriptorSet(const safe_VkWriteDescriptorSet& copy_src) {
+    sType = copy_src.sType;
+    dstSet = copy_src.dstSet;
+    dstBinding = copy_src.dstBinding;
+    dstArrayElement = copy_src.dstArrayElement;
+    descriptorCount = copy_src.descriptorCount;
+    descriptorType = copy_src.descriptorType;
+    pImageInfo = nullptr;
+    pBufferInfo = nullptr;
+    pTexelBufferView = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    switch (descriptorType) {
+        case VK_DESCRIPTOR_TYPE_SAMPLER:
+        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+        case VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM:
+        case VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM:
+            if (descriptorCount && copy_src.pImageInfo) {
+                pImageInfo = new VkDescriptorImageInfo[descriptorCount];
+                for (uint32_t i = 0; i < descriptorCount; ++i) {
+                    pImageInfo[i] = copy_src.pImageInfo[i];
+                }
+            }
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+            if (descriptorCount && copy_src.pBufferInfo) {
+                pBufferInfo = new VkDescriptorBufferInfo[descriptorCount];
+                for (uint32_t i = 0; i < descriptorCount; ++i) {
+                    pBufferInfo[i] = copy_src.pBufferInfo[i];
+                }
+            }
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+            if (descriptorCount && copy_src.pTexelBufferView) {
+                pTexelBufferView = new VkBufferView[descriptorCount];
+                for (uint32_t i = 0; i < descriptorCount; ++i) {
+                    pTexelBufferView[i] = copy_src.pTexelBufferView[i];
+                }
+            }
+            break;
+        default:
+            break;
+    }
+}
+
+safe_VkWriteDescriptorSet& safe_VkWriteDescriptorSet::operator=(const safe_VkWriteDescriptorSet& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pImageInfo) delete[] pImageInfo;
+    if (pBufferInfo) delete[] pBufferInfo;
+    if (pTexelBufferView) delete[] pTexelBufferView;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    dstSet = copy_src.dstSet;
+    dstBinding = copy_src.dstBinding;
+    dstArrayElement = copy_src.dstArrayElement;
+    descriptorCount = copy_src.descriptorCount;
+    descriptorType = copy_src.descriptorType;
+    pImageInfo = nullptr;
+    pBufferInfo = nullptr;
+    pTexelBufferView = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    switch (descriptorType) {
+        case VK_DESCRIPTOR_TYPE_SAMPLER:
+        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+        case VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM:
+        case VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM:
+            if (descriptorCount && copy_src.pImageInfo) {
+                pImageInfo = new VkDescriptorImageInfo[descriptorCount];
+                for (uint32_t i = 0; i < descriptorCount; ++i) {
+                    pImageInfo[i] = copy_src.pImageInfo[i];
+                }
+            }
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+            if (descriptorCount && copy_src.pBufferInfo) {
+                pBufferInfo = new VkDescriptorBufferInfo[descriptorCount];
+                for (uint32_t i = 0; i < descriptorCount; ++i) {
+                    pBufferInfo[i] = copy_src.pBufferInfo[i];
+                }
+            }
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+            if (descriptorCount && copy_src.pTexelBufferView) {
+                pTexelBufferView = new VkBufferView[descriptorCount];
+                for (uint32_t i = 0; i < descriptorCount; ++i) {
+                    pTexelBufferView[i] = copy_src.pTexelBufferView[i];
+                }
+            }
+            break;
+        default:
+            break;
+    }
+
+    return *this;
+}
+
+safe_VkWriteDescriptorSet::~safe_VkWriteDescriptorSet() {
+    if (pImageInfo) delete[] pImageInfo;
+    if (pBufferInfo) delete[] pBufferInfo;
+    if (pTexelBufferView) delete[] pTexelBufferView;
+    FreePnextChain(pNext);
+}
+
+void safe_VkWriteDescriptorSet::initialize(const VkWriteDescriptorSet* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pImageInfo) delete[] pImageInfo;
+    if (pBufferInfo) delete[] pBufferInfo;
+    if (pTexelBufferView) delete[] pTexelBufferView;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    dstSet = in_struct->dstSet;
+    dstBinding = in_struct->dstBinding;
+    dstArrayElement = in_struct->dstArrayElement;
+    descriptorCount = in_struct->descriptorCount;
+    descriptorType = in_struct->descriptorType;
+    pImageInfo = nullptr;
+    pBufferInfo = nullptr;
+    pTexelBufferView = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    switch (descriptorType) {
+        case VK_DESCRIPTOR_TYPE_SAMPLER:
+        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+        case VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM:
+        case VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM:
+            if (descriptorCount && in_struct->pImageInfo) {
+                pImageInfo = new VkDescriptorImageInfo[descriptorCount];
+                for (uint32_t i = 0; i < descriptorCount; ++i) {
+                    pImageInfo[i] = in_struct->pImageInfo[i];
+                }
+            }
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+            if (descriptorCount && in_struct->pBufferInfo) {
+                pBufferInfo = new VkDescriptorBufferInfo[descriptorCount];
+                for (uint32_t i = 0; i < descriptorCount; ++i) {
+                    pBufferInfo[i] = in_struct->pBufferInfo[i];
+                }
+            }
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+            if (descriptorCount && in_struct->pTexelBufferView) {
+                pTexelBufferView = new VkBufferView[descriptorCount];
+                for (uint32_t i = 0; i < descriptorCount; ++i) {
+                    pTexelBufferView[i] = in_struct->pTexelBufferView[i];
+                }
+            }
+            break;
+        default:
+            break;
+    }
+}
+
+void safe_VkWriteDescriptorSet::initialize(const safe_VkWriteDescriptorSet* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    dstSet = copy_src->dstSet;
+    dstBinding = copy_src->dstBinding;
+    dstArrayElement = copy_src->dstArrayElement;
+    descriptorCount = copy_src->descriptorCount;
+    descriptorType = copy_src->descriptorType;
+    pImageInfo = nullptr;
+    pBufferInfo = nullptr;
+    pTexelBufferView = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    switch (descriptorType) {
+        case VK_DESCRIPTOR_TYPE_SAMPLER:
+        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+        case VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM:
+        case VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM:
+            if (descriptorCount && copy_src->pImageInfo) {
+                pImageInfo = new VkDescriptorImageInfo[descriptorCount];
+                for (uint32_t i = 0; i < descriptorCount; ++i) {
+                    pImageInfo[i] = copy_src->pImageInfo[i];
+                }
+            }
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+            if (descriptorCount && copy_src->pBufferInfo) {
+                pBufferInfo = new VkDescriptorBufferInfo[descriptorCount];
+                for (uint32_t i = 0; i < descriptorCount; ++i) {
+                    pBufferInfo[i] = copy_src->pBufferInfo[i];
+                }
+            }
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+            if (descriptorCount && copy_src->pTexelBufferView) {
+                pTexelBufferView = new VkBufferView[descriptorCount];
+                for (uint32_t i = 0; i < descriptorCount; ++i) {
+                    pTexelBufferView[i] = copy_src->pTexelBufferView[i];
+                }
+            }
+            break;
+        default:
+            break;
+    }
+}
+
+safe_VkFramebufferCreateInfo::safe_VkFramebufferCreateInfo(const VkFramebufferCreateInfo* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      renderPass(in_struct->renderPass),
+      attachmentCount(in_struct->attachmentCount),
+      pAttachments(nullptr),
+      width(in_struct->width),
+      height(in_struct->height),
+      layers(in_struct->layers) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (attachmentCount && in_struct->pAttachments && !(flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT)) {
+        pAttachments = new VkImageView[attachmentCount];
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
+            pAttachments[i] = in_struct->pAttachments[i];
+        }
+    }
+}
+
+safe_VkFramebufferCreateInfo::safe_VkFramebufferCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      renderPass(),
+      attachmentCount(),
+      pAttachments(nullptr),
+      width(),
+      height(),
+      layers() {}
+
+safe_VkFramebufferCreateInfo::safe_VkFramebufferCreateInfo(const safe_VkFramebufferCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    renderPass = copy_src.renderPass;
+    attachmentCount = copy_src.attachmentCount;
+    pAttachments = nullptr;
+    width = copy_src.width;
+    height = copy_src.height;
+    layers = copy_src.layers;
+
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (attachmentCount && copy_src.pAttachments && !(flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT)) {
+        pAttachments = new VkImageView[attachmentCount];
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
+            pAttachments[i] = copy_src.pAttachments[i];
+        }
+    }
+}
+
+safe_VkFramebufferCreateInfo& safe_VkFramebufferCreateInfo::operator=(const safe_VkFramebufferCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pAttachments) delete[] pAttachments;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    renderPass = copy_src.renderPass;
+    attachmentCount = copy_src.attachmentCount;
+    pAttachments = nullptr;
+    width = copy_src.width;
+    height = copy_src.height;
+    layers = copy_src.layers;
+
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (attachmentCount && copy_src.pAttachments && !(flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT)) {
+        pAttachments = new VkImageView[attachmentCount];
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
+            pAttachments[i] = copy_src.pAttachments[i];
+        }
+    }
+
+    return *this;
+}
+
+safe_VkFramebufferCreateInfo::~safe_VkFramebufferCreateInfo() {
+    if (pAttachments) delete[] pAttachments;
+    FreePnextChain(pNext);
+}
+
+void safe_VkFramebufferCreateInfo::initialize(const VkFramebufferCreateInfo* in_struct,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pAttachments) delete[] pAttachments;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    renderPass = in_struct->renderPass;
+    attachmentCount = in_struct->attachmentCount;
+    pAttachments = nullptr;
+    width = in_struct->width;
+    height = in_struct->height;
+    layers = in_struct->layers;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (attachmentCount && in_struct->pAttachments && !(flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT)) {
+        pAttachments = new VkImageView[attachmentCount];
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
+            pAttachments[i] = in_struct->pAttachments[i];
+        }
+    }
+}
+
+void safe_VkFramebufferCreateInfo::initialize(const safe_VkFramebufferCreateInfo* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    renderPass = copy_src->renderPass;
+    attachmentCount = copy_src->attachmentCount;
+    pAttachments = nullptr;
+    width = copy_src->width;
+    height = copy_src->height;
+    layers = copy_src->layers;
+
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (attachmentCount && copy_src->pAttachments && !(flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT)) {
+        pAttachments = new VkImageView[attachmentCount];
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
+            pAttachments[i] = copy_src->pAttachments[i];
+        }
+    }
+}
+
+safe_VkSubpassDescription::safe_VkSubpassDescription(const VkSubpassDescription* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state)
+    : flags(in_struct->flags),
+      pipelineBindPoint(in_struct->pipelineBindPoint),
+      inputAttachmentCount(in_struct->inputAttachmentCount),
+      pInputAttachments(nullptr),
+      colorAttachmentCount(in_struct->colorAttachmentCount),
+      pColorAttachments(nullptr),
+      pResolveAttachments(nullptr),
+      pDepthStencilAttachment(nullptr),
+      preserveAttachmentCount(in_struct->preserveAttachmentCount),
+      pPreserveAttachments(nullptr) {
+    if (in_struct->pInputAttachments) {
+        pInputAttachments = new VkAttachmentReference[in_struct->inputAttachmentCount];
+        memcpy((void*)pInputAttachments, (void*)in_struct->pInputAttachments,
+               sizeof(VkAttachmentReference) * in_struct->inputAttachmentCount);
+    }
+
+    if (in_struct->pColorAttachments) {
+        pColorAttachments = new VkAttachmentReference[in_struct->colorAttachmentCount];
+        memcpy((void*)pColorAttachments, (void*)in_struct->pColorAttachments,
+               sizeof(VkAttachmentReference) * in_struct->colorAttachmentCount);
+    }
+
+    if (in_struct->pResolveAttachments) {
+        pResolveAttachments = new VkAttachmentReference[in_struct->colorAttachmentCount];
+        memcpy((void*)pResolveAttachments, (void*)in_struct->pResolveAttachments,
+               sizeof(VkAttachmentReference) * in_struct->colorAttachmentCount);
+    }
+
+    if (in_struct->pDepthStencilAttachment) {
+        pDepthStencilAttachment = new VkAttachmentReference(*in_struct->pDepthStencilAttachment);
+    }
+
+    if (in_struct->pPreserveAttachments) {
+        pPreserveAttachments = new uint32_t[in_struct->preserveAttachmentCount];
+        memcpy((void*)pPreserveAttachments, (void*)in_struct->pPreserveAttachments,
+               sizeof(uint32_t) * in_struct->preserveAttachmentCount);
+    }
+}
+
+safe_VkSubpassDescription::safe_VkSubpassDescription()
+    : flags(),
+      pipelineBindPoint(),
+      inputAttachmentCount(),
+      pInputAttachments(nullptr),
+      colorAttachmentCount(),
+      pColorAttachments(nullptr),
+      pResolveAttachments(nullptr),
+      pDepthStencilAttachment(nullptr),
+      preserveAttachmentCount(),
+      pPreserveAttachments(nullptr) {}
+
+safe_VkSubpassDescription::safe_VkSubpassDescription(const safe_VkSubpassDescription& copy_src) {
+    flags = copy_src.flags;
+    pipelineBindPoint = copy_src.pipelineBindPoint;
+    inputAttachmentCount = copy_src.inputAttachmentCount;
+    pInputAttachments = nullptr;
+    colorAttachmentCount = copy_src.colorAttachmentCount;
+    pColorAttachments = nullptr;
+    pResolveAttachments = nullptr;
+    pDepthStencilAttachment = nullptr;
+    preserveAttachmentCount = copy_src.preserveAttachmentCount;
+    pPreserveAttachments = nullptr;
+
+    if (copy_src.pInputAttachments) {
+        pInputAttachments = new VkAttachmentReference[copy_src.inputAttachmentCount];
+        memcpy((void*)pInputAttachments, (void*)copy_src.pInputAttachments,
+               sizeof(VkAttachmentReference) * copy_src.inputAttachmentCount);
+    }
+
+    if (copy_src.pColorAttachments) {
+        pColorAttachments = new VkAttachmentReference[copy_src.colorAttachmentCount];
+        memcpy((void*)pColorAttachments, (void*)copy_src.pColorAttachments,
+               sizeof(VkAttachmentReference) * copy_src.colorAttachmentCount);
+    }
+
+    if (copy_src.pResolveAttachments) {
+        pResolveAttachments = new VkAttachmentReference[copy_src.colorAttachmentCount];
+        memcpy((void*)pResolveAttachments, (void*)copy_src.pResolveAttachments,
+               sizeof(VkAttachmentReference) * copy_src.colorAttachmentCount);
+    }
+
+    if (copy_src.pDepthStencilAttachment) {
+        pDepthStencilAttachment = new VkAttachmentReference(*copy_src.pDepthStencilAttachment);
+    }
+
+    if (copy_src.pPreserveAttachments) {
+        pPreserveAttachments = new uint32_t[copy_src.preserveAttachmentCount];
+        memcpy((void*)pPreserveAttachments, (void*)copy_src.pPreserveAttachments,
+               sizeof(uint32_t) * copy_src.preserveAttachmentCount);
+    }
+}
+
+safe_VkSubpassDescription& safe_VkSubpassDescription::operator=(const safe_VkSubpassDescription& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pInputAttachments) delete[] pInputAttachments;
+    if (pColorAttachments) delete[] pColorAttachments;
+    if (pResolveAttachments) delete[] pResolveAttachments;
+    if (pDepthStencilAttachment) delete pDepthStencilAttachment;
+    if (pPreserveAttachments) delete[] pPreserveAttachments;
+
+    flags = copy_src.flags;
+    pipelineBindPoint = copy_src.pipelineBindPoint;
+    inputAttachmentCount = copy_src.inputAttachmentCount;
+    pInputAttachments = nullptr;
+    colorAttachmentCount = copy_src.colorAttachmentCount;
+    pColorAttachments = nullptr;
+    pResolveAttachments = nullptr;
+    pDepthStencilAttachment = nullptr;
+    preserveAttachmentCount = copy_src.preserveAttachmentCount;
+    pPreserveAttachments = nullptr;
+
+    if (copy_src.pInputAttachments) {
+        pInputAttachments = new VkAttachmentReference[copy_src.inputAttachmentCount];
+        memcpy((void*)pInputAttachments, (void*)copy_src.pInputAttachments,
+               sizeof(VkAttachmentReference) * copy_src.inputAttachmentCount);
+    }
+
+    if (copy_src.pColorAttachments) {
+        pColorAttachments = new VkAttachmentReference[copy_src.colorAttachmentCount];
+        memcpy((void*)pColorAttachments, (void*)copy_src.pColorAttachments,
+               sizeof(VkAttachmentReference) * copy_src.colorAttachmentCount);
+    }
+
+    if (copy_src.pResolveAttachments) {
+        pResolveAttachments = new VkAttachmentReference[copy_src.colorAttachmentCount];
+        memcpy((void*)pResolveAttachments, (void*)copy_src.pResolveAttachments,
+               sizeof(VkAttachmentReference) * copy_src.colorAttachmentCount);
+    }
+
+    if (copy_src.pDepthStencilAttachment) {
+        pDepthStencilAttachment = new VkAttachmentReference(*copy_src.pDepthStencilAttachment);
+    }
+
+    if (copy_src.pPreserveAttachments) {
+        pPreserveAttachments = new uint32_t[copy_src.preserveAttachmentCount];
+        memcpy((void*)pPreserveAttachments, (void*)copy_src.pPreserveAttachments,
+               sizeof(uint32_t) * copy_src.preserveAttachmentCount);
+    }
+
+    return *this;
+}
+
+safe_VkSubpassDescription::~safe_VkSubpassDescription() {
+    if (pInputAttachments) delete[] pInputAttachments;
+    if (pColorAttachments) delete[] pColorAttachments;
+    if (pResolveAttachments) delete[] pResolveAttachments;
+    if (pDepthStencilAttachment) delete pDepthStencilAttachment;
+    if (pPreserveAttachments) delete[] pPreserveAttachments;
+}
+
+void safe_VkSubpassDescription::initialize(const VkSubpassDescription* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pInputAttachments) delete[] pInputAttachments;
+    if (pColorAttachments) delete[] pColorAttachments;
+    if (pResolveAttachments) delete[] pResolveAttachments;
+    if (pDepthStencilAttachment) delete pDepthStencilAttachment;
+    if (pPreserveAttachments) delete[] pPreserveAttachments;
+    flags = in_struct->flags;
+    pipelineBindPoint = in_struct->pipelineBindPoint;
+    inputAttachmentCount = in_struct->inputAttachmentCount;
+    pInputAttachments = nullptr;
+    colorAttachmentCount = in_struct->colorAttachmentCount;
+    pColorAttachments = nullptr;
+    pResolveAttachments = nullptr;
+    pDepthStencilAttachment = nullptr;
+    preserveAttachmentCount = in_struct->preserveAttachmentCount;
+    pPreserveAttachments = nullptr;
+
+    if (in_struct->pInputAttachments) {
+        pInputAttachments = new VkAttachmentReference[in_struct->inputAttachmentCount];
+        memcpy((void*)pInputAttachments, (void*)in_struct->pInputAttachments,
+               sizeof(VkAttachmentReference) * in_struct->inputAttachmentCount);
+    }
+
+    if (in_struct->pColorAttachments) {
+        pColorAttachments = new VkAttachmentReference[in_struct->colorAttachmentCount];
+        memcpy((void*)pColorAttachments, (void*)in_struct->pColorAttachments,
+               sizeof(VkAttachmentReference) * in_struct->colorAttachmentCount);
+    }
+
+    if (in_struct->pResolveAttachments) {
+        pResolveAttachments = new VkAttachmentReference[in_struct->colorAttachmentCount];
+        memcpy((void*)pResolveAttachments, (void*)in_struct->pResolveAttachments,
+               sizeof(VkAttachmentReference) * in_struct->colorAttachmentCount);
+    }
+
+    if (in_struct->pDepthStencilAttachment) {
+        pDepthStencilAttachment = new VkAttachmentReference(*in_struct->pDepthStencilAttachment);
+    }
+
+    if (in_struct->pPreserveAttachments) {
+        pPreserveAttachments = new uint32_t[in_struct->preserveAttachmentCount];
+        memcpy((void*)pPreserveAttachments, (void*)in_struct->pPreserveAttachments,
+               sizeof(uint32_t) * in_struct->preserveAttachmentCount);
+    }
+}
+
+void safe_VkSubpassDescription::initialize(const safe_VkSubpassDescription* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    flags = copy_src->flags;
+    pipelineBindPoint = copy_src->pipelineBindPoint;
+    inputAttachmentCount = copy_src->inputAttachmentCount;
+    pInputAttachments = nullptr;
+    colorAttachmentCount = copy_src->colorAttachmentCount;
+    pColorAttachments = nullptr;
+    pResolveAttachments = nullptr;
+    pDepthStencilAttachment = nullptr;
+    preserveAttachmentCount = copy_src->preserveAttachmentCount;
+    pPreserveAttachments = nullptr;
+
+    if (copy_src->pInputAttachments) {
+        pInputAttachments = new VkAttachmentReference[copy_src->inputAttachmentCount];
+        memcpy((void*)pInputAttachments, (void*)copy_src->pInputAttachments,
+               sizeof(VkAttachmentReference) * copy_src->inputAttachmentCount);
+    }
+
+    if (copy_src->pColorAttachments) {
+        pColorAttachments = new VkAttachmentReference[copy_src->colorAttachmentCount];
+        memcpy((void*)pColorAttachments, (void*)copy_src->pColorAttachments,
+               sizeof(VkAttachmentReference) * copy_src->colorAttachmentCount);
+    }
+
+    if (copy_src->pResolveAttachments) {
+        pResolveAttachments = new VkAttachmentReference[copy_src->colorAttachmentCount];
+        memcpy((void*)pResolveAttachments, (void*)copy_src->pResolveAttachments,
+               sizeof(VkAttachmentReference) * copy_src->colorAttachmentCount);
+    }
+
+    if (copy_src->pDepthStencilAttachment) {
+        pDepthStencilAttachment = new VkAttachmentReference(*copy_src->pDepthStencilAttachment);
+    }
+
+    if (copy_src->pPreserveAttachments) {
+        pPreserveAttachments = new uint32_t[copy_src->preserveAttachmentCount];
+        memcpy((void*)pPreserveAttachments, (void*)copy_src->pPreserveAttachments,
+               sizeof(uint32_t) * copy_src->preserveAttachmentCount);
+    }
+}
+
+safe_VkRenderPassCreateInfo::safe_VkRenderPassCreateInfo(const VkRenderPassCreateInfo* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      attachmentCount(in_struct->attachmentCount),
+      pAttachments(nullptr),
+      subpassCount(in_struct->subpassCount),
+      pSubpasses(nullptr),
+      dependencyCount(in_struct->dependencyCount),
+      pDependencies(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pAttachments) {
+        pAttachments = new VkAttachmentDescription[in_struct->attachmentCount];
+        memcpy((void*)pAttachments, (void*)in_struct->pAttachments, sizeof(VkAttachmentDescription) * in_struct->attachmentCount);
+    }
+    if (subpassCount && in_struct->pSubpasses) {
+        pSubpasses = new safe_VkSubpassDescription[subpassCount];
+        for (uint32_t i = 0; i < subpassCount; ++i) {
+            pSubpasses[i].initialize(&in_struct->pSubpasses[i]);
+        }
+    }
+
+    if (in_struct->pDependencies) {
+        pDependencies = new VkSubpassDependency[in_struct->dependencyCount];
+        memcpy((void*)pDependencies, (void*)in_struct->pDependencies, sizeof(VkSubpassDependency) * in_struct->dependencyCount);
+    }
+}
+
+safe_VkRenderPassCreateInfo::safe_VkRenderPassCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      attachmentCount(),
+      pAttachments(nullptr),
+      subpassCount(),
+      pSubpasses(nullptr),
+      dependencyCount(),
+      pDependencies(nullptr) {}
+
+safe_VkRenderPassCreateInfo::safe_VkRenderPassCreateInfo(const safe_VkRenderPassCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    attachmentCount = copy_src.attachmentCount;
+    pAttachments = nullptr;
+    subpassCount = copy_src.subpassCount;
+    pSubpasses = nullptr;
+    dependencyCount = copy_src.dependencyCount;
+    pDependencies = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pAttachments) {
+        pAttachments = new VkAttachmentDescription[copy_src.attachmentCount];
+        memcpy((void*)pAttachments, (void*)copy_src.pAttachments, sizeof(VkAttachmentDescription) * copy_src.attachmentCount);
+    }
+    if (subpassCount && copy_src.pSubpasses) {
+        pSubpasses = new safe_VkSubpassDescription[subpassCount];
+        for (uint32_t i = 0; i < subpassCount; ++i) {
+            pSubpasses[i].initialize(&copy_src.pSubpasses[i]);
+        }
+    }
+
+    if (copy_src.pDependencies) {
+        pDependencies = new VkSubpassDependency[copy_src.dependencyCount];
+        memcpy((void*)pDependencies, (void*)copy_src.pDependencies, sizeof(VkSubpassDependency) * copy_src.dependencyCount);
+    }
+}
+
+safe_VkRenderPassCreateInfo& safe_VkRenderPassCreateInfo::operator=(const safe_VkRenderPassCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pAttachments) delete[] pAttachments;
+    if (pSubpasses) delete[] pSubpasses;
+    if (pDependencies) delete[] pDependencies;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    attachmentCount = copy_src.attachmentCount;
+    pAttachments = nullptr;
+    subpassCount = copy_src.subpassCount;
+    pSubpasses = nullptr;
+    dependencyCount = copy_src.dependencyCount;
+    pDependencies = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pAttachments) {
+        pAttachments = new VkAttachmentDescription[copy_src.attachmentCount];
+        memcpy((void*)pAttachments, (void*)copy_src.pAttachments, sizeof(VkAttachmentDescription) * copy_src.attachmentCount);
+    }
+    if (subpassCount && copy_src.pSubpasses) {
+        pSubpasses = new safe_VkSubpassDescription[subpassCount];
+        for (uint32_t i = 0; i < subpassCount; ++i) {
+            pSubpasses[i].initialize(&copy_src.pSubpasses[i]);
+        }
+    }
+
+    if (copy_src.pDependencies) {
+        pDependencies = new VkSubpassDependency[copy_src.dependencyCount];
+        memcpy((void*)pDependencies, (void*)copy_src.pDependencies, sizeof(VkSubpassDependency) * copy_src.dependencyCount);
+    }
+
+    return *this;
+}
+
+safe_VkRenderPassCreateInfo::~safe_VkRenderPassCreateInfo() {
+    if (pAttachments) delete[] pAttachments;
+    if (pSubpasses) delete[] pSubpasses;
+    if (pDependencies) delete[] pDependencies;
+    FreePnextChain(pNext);
+}
+
+void safe_VkRenderPassCreateInfo::initialize(const VkRenderPassCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pAttachments) delete[] pAttachments;
+    if (pSubpasses) delete[] pSubpasses;
+    if (pDependencies) delete[] pDependencies;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    attachmentCount = in_struct->attachmentCount;
+    pAttachments = nullptr;
+    subpassCount = in_struct->subpassCount;
+    pSubpasses = nullptr;
+    dependencyCount = in_struct->dependencyCount;
+    pDependencies = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pAttachments) {
+        pAttachments = new VkAttachmentDescription[in_struct->attachmentCount];
+        memcpy((void*)pAttachments, (void*)in_struct->pAttachments, sizeof(VkAttachmentDescription) * in_struct->attachmentCount);
+    }
+    if (subpassCount && in_struct->pSubpasses) {
+        pSubpasses = new safe_VkSubpassDescription[subpassCount];
+        for (uint32_t i = 0; i < subpassCount; ++i) {
+            pSubpasses[i].initialize(&in_struct->pSubpasses[i]);
+        }
+    }
+
+    if (in_struct->pDependencies) {
+        pDependencies = new VkSubpassDependency[in_struct->dependencyCount];
+        memcpy((void*)pDependencies, (void*)in_struct->pDependencies, sizeof(VkSubpassDependency) * in_struct->dependencyCount);
+    }
+}
+
+void safe_VkRenderPassCreateInfo::initialize(const safe_VkRenderPassCreateInfo* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    attachmentCount = copy_src->attachmentCount;
+    pAttachments = nullptr;
+    subpassCount = copy_src->subpassCount;
+    pSubpasses = nullptr;
+    dependencyCount = copy_src->dependencyCount;
+    pDependencies = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pAttachments) {
+        pAttachments = new VkAttachmentDescription[copy_src->attachmentCount];
+        memcpy((void*)pAttachments, (void*)copy_src->pAttachments, sizeof(VkAttachmentDescription) * copy_src->attachmentCount);
+    }
+    if (subpassCount && copy_src->pSubpasses) {
+        pSubpasses = new safe_VkSubpassDescription[subpassCount];
+        for (uint32_t i = 0; i < subpassCount; ++i) {
+            pSubpasses[i].initialize(&copy_src->pSubpasses[i]);
+        }
+    }
+
+    if (copy_src->pDependencies) {
+        pDependencies = new VkSubpassDependency[copy_src->dependencyCount];
+        memcpy((void*)pDependencies, (void*)copy_src->pDependencies, sizeof(VkSubpassDependency) * copy_src->dependencyCount);
+    }
+}
+
+safe_VkCommandPoolCreateInfo::safe_VkCommandPoolCreateInfo(const VkCommandPoolCreateInfo* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags), queueFamilyIndex(in_struct->queueFamilyIndex) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkCommandPoolCreateInfo::safe_VkCommandPoolCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO), pNext(nullptr), flags(), queueFamilyIndex() {}
+
+safe_VkCommandPoolCreateInfo::safe_VkCommandPoolCreateInfo(const safe_VkCommandPoolCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    queueFamilyIndex = copy_src.queueFamilyIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkCommandPoolCreateInfo& safe_VkCommandPoolCreateInfo::operator=(const safe_VkCommandPoolCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    queueFamilyIndex = copy_src.queueFamilyIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkCommandPoolCreateInfo::~safe_VkCommandPoolCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkCommandPoolCreateInfo::initialize(const VkCommandPoolCreateInfo* in_struct,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    queueFamilyIndex = in_struct->queueFamilyIndex;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkCommandPoolCreateInfo::initialize(const safe_VkCommandPoolCreateInfo* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    queueFamilyIndex = copy_src->queueFamilyIndex;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkCommandBufferAllocateInfo::safe_VkCommandBufferAllocateInfo(const VkCommandBufferAllocateInfo* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      commandPool(in_struct->commandPool),
+      level(in_struct->level),
+      commandBufferCount(in_struct->commandBufferCount) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkCommandBufferAllocateInfo::safe_VkCommandBufferAllocateInfo()
+    : sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO), pNext(nullptr), commandPool(), level(), commandBufferCount() {}
+
+safe_VkCommandBufferAllocateInfo::safe_VkCommandBufferAllocateInfo(const safe_VkCommandBufferAllocateInfo& copy_src) {
+    sType = copy_src.sType;
+    commandPool = copy_src.commandPool;
+    level = copy_src.level;
+    commandBufferCount = copy_src.commandBufferCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkCommandBufferAllocateInfo& safe_VkCommandBufferAllocateInfo::operator=(const safe_VkCommandBufferAllocateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    commandPool = copy_src.commandPool;
+    level = copy_src.level;
+    commandBufferCount = copy_src.commandBufferCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkCommandBufferAllocateInfo::~safe_VkCommandBufferAllocateInfo() { FreePnextChain(pNext); }
+
+void safe_VkCommandBufferAllocateInfo::initialize(const VkCommandBufferAllocateInfo* in_struct,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    commandPool = in_struct->commandPool;
+    level = in_struct->level;
+    commandBufferCount = in_struct->commandBufferCount;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkCommandBufferAllocateInfo::initialize(const safe_VkCommandBufferAllocateInfo* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    commandPool = copy_src->commandPool;
+    level = copy_src->level;
+    commandBufferCount = copy_src->commandBufferCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkCommandBufferInheritanceInfo::safe_VkCommandBufferInheritanceInfo(const VkCommandBufferInheritanceInfo* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType),
+      renderPass(in_struct->renderPass),
+      subpass(in_struct->subpass),
+      framebuffer(in_struct->framebuffer),
+      occlusionQueryEnable(in_struct->occlusionQueryEnable),
+      queryFlags(in_struct->queryFlags),
+      pipelineStatistics(in_struct->pipelineStatistics) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkCommandBufferInheritanceInfo::safe_VkCommandBufferInheritanceInfo()
+    : sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO),
+      pNext(nullptr),
+      renderPass(),
+      subpass(),
+      framebuffer(),
+      occlusionQueryEnable(),
+      queryFlags(),
+      pipelineStatistics() {}
+
+safe_VkCommandBufferInheritanceInfo::safe_VkCommandBufferInheritanceInfo(const safe_VkCommandBufferInheritanceInfo& copy_src) {
+    sType = copy_src.sType;
+    renderPass = copy_src.renderPass;
+    subpass = copy_src.subpass;
+    framebuffer = copy_src.framebuffer;
+    occlusionQueryEnable = copy_src.occlusionQueryEnable;
+    queryFlags = copy_src.queryFlags;
+    pipelineStatistics = copy_src.pipelineStatistics;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkCommandBufferInheritanceInfo& safe_VkCommandBufferInheritanceInfo::operator=(
+    const safe_VkCommandBufferInheritanceInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    renderPass = copy_src.renderPass;
+    subpass = copy_src.subpass;
+    framebuffer = copy_src.framebuffer;
+    occlusionQueryEnable = copy_src.occlusionQueryEnable;
+    queryFlags = copy_src.queryFlags;
+    pipelineStatistics = copy_src.pipelineStatistics;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkCommandBufferInheritanceInfo::~safe_VkCommandBufferInheritanceInfo() { FreePnextChain(pNext); }
+
+void safe_VkCommandBufferInheritanceInfo::initialize(const VkCommandBufferInheritanceInfo* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    renderPass = in_struct->renderPass;
+    subpass = in_struct->subpass;
+    framebuffer = in_struct->framebuffer;
+    occlusionQueryEnable = in_struct->occlusionQueryEnable;
+    queryFlags = in_struct->queryFlags;
+    pipelineStatistics = in_struct->pipelineStatistics;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkCommandBufferInheritanceInfo::initialize(const safe_VkCommandBufferInheritanceInfo* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    renderPass = copy_src->renderPass;
+    subpass = copy_src->subpass;
+    framebuffer = copy_src->framebuffer;
+    occlusionQueryEnable = copy_src->occlusionQueryEnable;
+    queryFlags = copy_src->queryFlags;
+    pipelineStatistics = copy_src->pipelineStatistics;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkCommandBufferBeginInfo::safe_VkCommandBufferBeginInfo(const VkCommandBufferBeginInfo* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags), pInheritanceInfo(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pInheritanceInfo) pInheritanceInfo = new safe_VkCommandBufferInheritanceInfo(in_struct->pInheritanceInfo);
+}
+
+safe_VkCommandBufferBeginInfo::safe_VkCommandBufferBeginInfo()
+    : sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO), pNext(nullptr), flags(), pInheritanceInfo(nullptr) {}
+
+safe_VkCommandBufferBeginInfo::safe_VkCommandBufferBeginInfo(const safe_VkCommandBufferBeginInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pInheritanceInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pInheritanceInfo) pInheritanceInfo = new safe_VkCommandBufferInheritanceInfo(*copy_src.pInheritanceInfo);
+}
+
+safe_VkCommandBufferBeginInfo& safe_VkCommandBufferBeginInfo::operator=(const safe_VkCommandBufferBeginInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pInheritanceInfo) delete pInheritanceInfo;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pInheritanceInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pInheritanceInfo) pInheritanceInfo = new safe_VkCommandBufferInheritanceInfo(*copy_src.pInheritanceInfo);
+
+    return *this;
+}
+
+safe_VkCommandBufferBeginInfo::~safe_VkCommandBufferBeginInfo() {
+    if (pInheritanceInfo) delete pInheritanceInfo;
+    FreePnextChain(pNext);
+}
+
+void safe_VkCommandBufferBeginInfo::initialize(const VkCommandBufferBeginInfo* in_struct,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pInheritanceInfo) delete pInheritanceInfo;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    pInheritanceInfo = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (in_struct->pInheritanceInfo) pInheritanceInfo = new safe_VkCommandBufferInheritanceInfo(in_struct->pInheritanceInfo);
+}
+
+void safe_VkCommandBufferBeginInfo::initialize(const safe_VkCommandBufferBeginInfo* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pInheritanceInfo = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (copy_src->pInheritanceInfo) pInheritanceInfo = new safe_VkCommandBufferInheritanceInfo(*copy_src->pInheritanceInfo);
+}
+
+safe_VkRenderPassBeginInfo::safe_VkRenderPassBeginInfo(const VkRenderPassBeginInfo* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      renderPass(in_struct->renderPass),
+      framebuffer(in_struct->framebuffer),
+      renderArea(in_struct->renderArea),
+      clearValueCount(in_struct->clearValueCount),
+      pClearValues(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pClearValues) {
+        pClearValues = new VkClearValue[in_struct->clearValueCount];
+        memcpy((void*)pClearValues, (void*)in_struct->pClearValues, sizeof(VkClearValue) * in_struct->clearValueCount);
+    }
+}
+
+safe_VkRenderPassBeginInfo::safe_VkRenderPassBeginInfo()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO),
+      pNext(nullptr),
+      renderPass(),
+      framebuffer(),
+      renderArea(),
+      clearValueCount(),
+      pClearValues(nullptr) {}
+
+safe_VkRenderPassBeginInfo::safe_VkRenderPassBeginInfo(const safe_VkRenderPassBeginInfo& copy_src) {
+    sType = copy_src.sType;
+    renderPass = copy_src.renderPass;
+    framebuffer = copy_src.framebuffer;
+    renderArea = copy_src.renderArea;
+    clearValueCount = copy_src.clearValueCount;
+    pClearValues = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pClearValues) {
+        pClearValues = new VkClearValue[copy_src.clearValueCount];
+        memcpy((void*)pClearValues, (void*)copy_src.pClearValues, sizeof(VkClearValue) * copy_src.clearValueCount);
+    }
+}
+
+safe_VkRenderPassBeginInfo& safe_VkRenderPassBeginInfo::operator=(const safe_VkRenderPassBeginInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pClearValues) delete[] pClearValues;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    renderPass = copy_src.renderPass;
+    framebuffer = copy_src.framebuffer;
+    renderArea = copy_src.renderArea;
+    clearValueCount = copy_src.clearValueCount;
+    pClearValues = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pClearValues) {
+        pClearValues = new VkClearValue[copy_src.clearValueCount];
+        memcpy((void*)pClearValues, (void*)copy_src.pClearValues, sizeof(VkClearValue) * copy_src.clearValueCount);
+    }
+
+    return *this;
+}
+
+safe_VkRenderPassBeginInfo::~safe_VkRenderPassBeginInfo() {
+    if (pClearValues) delete[] pClearValues;
+    FreePnextChain(pNext);
+}
+
+void safe_VkRenderPassBeginInfo::initialize(const VkRenderPassBeginInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pClearValues) delete[] pClearValues;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    renderPass = in_struct->renderPass;
+    framebuffer = in_struct->framebuffer;
+    renderArea = in_struct->renderArea;
+    clearValueCount = in_struct->clearValueCount;
+    pClearValues = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pClearValues) {
+        pClearValues = new VkClearValue[in_struct->clearValueCount];
+        memcpy((void*)pClearValues, (void*)in_struct->pClearValues, sizeof(VkClearValue) * in_struct->clearValueCount);
+    }
+}
+
+void safe_VkRenderPassBeginInfo::initialize(const safe_VkRenderPassBeginInfo* copy_src,
+                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    renderPass = copy_src->renderPass;
+    framebuffer = copy_src->framebuffer;
+    renderArea = copy_src->renderArea;
+    clearValueCount = copy_src->clearValueCount;
+    pClearValues = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pClearValues) {
+        pClearValues = new VkClearValue[copy_src->clearValueCount];
+        memcpy((void*)pClearValues, (void*)copy_src->pClearValues, sizeof(VkClearValue) * copy_src->clearValueCount);
+    }
+}
+
+safe_VkPhysicalDeviceSubgroupProperties::safe_VkPhysicalDeviceSubgroupProperties(
+    const VkPhysicalDeviceSubgroupProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      subgroupSize(in_struct->subgroupSize),
+      supportedStages(in_struct->supportedStages),
+      supportedOperations(in_struct->supportedOperations),
+      quadOperationsInAllStages(in_struct->quadOperationsInAllStages) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceSubgroupProperties::safe_VkPhysicalDeviceSubgroupProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES),
+      pNext(nullptr),
+      subgroupSize(),
+      supportedStages(),
+      supportedOperations(),
+      quadOperationsInAllStages() {}
+
+safe_VkPhysicalDeviceSubgroupProperties::safe_VkPhysicalDeviceSubgroupProperties(
+    const safe_VkPhysicalDeviceSubgroupProperties& copy_src) {
+    sType = copy_src.sType;
+    subgroupSize = copy_src.subgroupSize;
+    supportedStages = copy_src.supportedStages;
+    supportedOperations = copy_src.supportedOperations;
+    quadOperationsInAllStages = copy_src.quadOperationsInAllStages;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceSubgroupProperties& safe_VkPhysicalDeviceSubgroupProperties::operator=(
+    const safe_VkPhysicalDeviceSubgroupProperties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    subgroupSize = copy_src.subgroupSize;
+    supportedStages = copy_src.supportedStages;
+    supportedOperations = copy_src.supportedOperations;
+    quadOperationsInAllStages = copy_src.quadOperationsInAllStages;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceSubgroupProperties::~safe_VkPhysicalDeviceSubgroupProperties() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceSubgroupProperties::initialize(const VkPhysicalDeviceSubgroupProperties* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    subgroupSize = in_struct->subgroupSize;
+    supportedStages = in_struct->supportedStages;
+    supportedOperations = in_struct->supportedOperations;
+    quadOperationsInAllStages = in_struct->quadOperationsInAllStages;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceSubgroupProperties::initialize(const safe_VkPhysicalDeviceSubgroupProperties* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    subgroupSize = copy_src->subgroupSize;
+    supportedStages = copy_src->supportedStages;
+    supportedOperations = copy_src->supportedOperations;
+    quadOperationsInAllStages = copy_src->quadOperationsInAllStages;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkBindBufferMemoryInfo::safe_VkBindBufferMemoryInfo(const VkBindBufferMemoryInfo* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), buffer(in_struct->buffer), memory(in_struct->memory), memoryOffset(in_struct->memoryOffset) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkBindBufferMemoryInfo::safe_VkBindBufferMemoryInfo()
+    : sType(VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO), pNext(nullptr), buffer(), memory(), memoryOffset() {}
+
+safe_VkBindBufferMemoryInfo::safe_VkBindBufferMemoryInfo(const safe_VkBindBufferMemoryInfo& copy_src) {
+    sType = copy_src.sType;
+    buffer = copy_src.buffer;
+    memory = copy_src.memory;
+    memoryOffset = copy_src.memoryOffset;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBindBufferMemoryInfo& safe_VkBindBufferMemoryInfo::operator=(const safe_VkBindBufferMemoryInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    buffer = copy_src.buffer;
+    memory = copy_src.memory;
+    memoryOffset = copy_src.memoryOffset;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkBindBufferMemoryInfo::~safe_VkBindBufferMemoryInfo() { FreePnextChain(pNext); }
+
+void safe_VkBindBufferMemoryInfo::initialize(const VkBindBufferMemoryInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    buffer = in_struct->buffer;
+    memory = in_struct->memory;
+    memoryOffset = in_struct->memoryOffset;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkBindBufferMemoryInfo::initialize(const safe_VkBindBufferMemoryInfo* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    buffer = copy_src->buffer;
+    memory = copy_src->memory;
+    memoryOffset = copy_src->memoryOffset;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkBindImageMemoryInfo::safe_VkBindImageMemoryInfo(const VkBindImageMemoryInfo* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), image(in_struct->image), memory(in_struct->memory), memoryOffset(in_struct->memoryOffset) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkBindImageMemoryInfo::safe_VkBindImageMemoryInfo()
+    : sType(VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO), pNext(nullptr), image(), memory(), memoryOffset() {}
+
+safe_VkBindImageMemoryInfo::safe_VkBindImageMemoryInfo(const safe_VkBindImageMemoryInfo& copy_src) {
+    sType = copy_src.sType;
+    image = copy_src.image;
+    memory = copy_src.memory;
+    memoryOffset = copy_src.memoryOffset;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBindImageMemoryInfo& safe_VkBindImageMemoryInfo::operator=(const safe_VkBindImageMemoryInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    image = copy_src.image;
+    memory = copy_src.memory;
+    memoryOffset = copy_src.memoryOffset;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkBindImageMemoryInfo::~safe_VkBindImageMemoryInfo() { FreePnextChain(pNext); }
+
+void safe_VkBindImageMemoryInfo::initialize(const VkBindImageMemoryInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    image = in_struct->image;
+    memory = in_struct->memory;
+    memoryOffset = in_struct->memoryOffset;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkBindImageMemoryInfo::initialize(const safe_VkBindImageMemoryInfo* copy_src,
+                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    image = copy_src->image;
+    memory = copy_src->memory;
+    memoryOffset = copy_src->memoryOffset;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDevice16BitStorageFeatures::safe_VkPhysicalDevice16BitStorageFeatures(
+    const VkPhysicalDevice16BitStorageFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      storageBuffer16BitAccess(in_struct->storageBuffer16BitAccess),
+      uniformAndStorageBuffer16BitAccess(in_struct->uniformAndStorageBuffer16BitAccess),
+      storagePushConstant16(in_struct->storagePushConstant16),
+      storageInputOutput16(in_struct->storageInputOutput16) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevice16BitStorageFeatures::safe_VkPhysicalDevice16BitStorageFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES),
+      pNext(nullptr),
+      storageBuffer16BitAccess(),
+      uniformAndStorageBuffer16BitAccess(),
+      storagePushConstant16(),
+      storageInputOutput16() {}
+
+safe_VkPhysicalDevice16BitStorageFeatures::safe_VkPhysicalDevice16BitStorageFeatures(
+    const safe_VkPhysicalDevice16BitStorageFeatures& copy_src) {
+    sType = copy_src.sType;
+    storageBuffer16BitAccess = copy_src.storageBuffer16BitAccess;
+    uniformAndStorageBuffer16BitAccess = copy_src.uniformAndStorageBuffer16BitAccess;
+    storagePushConstant16 = copy_src.storagePushConstant16;
+    storageInputOutput16 = copy_src.storageInputOutput16;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevice16BitStorageFeatures& safe_VkPhysicalDevice16BitStorageFeatures::operator=(
+    const safe_VkPhysicalDevice16BitStorageFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    storageBuffer16BitAccess = copy_src.storageBuffer16BitAccess;
+    uniformAndStorageBuffer16BitAccess = copy_src.uniformAndStorageBuffer16BitAccess;
+    storagePushConstant16 = copy_src.storagePushConstant16;
+    storageInputOutput16 = copy_src.storageInputOutput16;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevice16BitStorageFeatures::~safe_VkPhysicalDevice16BitStorageFeatures() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDevice16BitStorageFeatures::initialize(const VkPhysicalDevice16BitStorageFeatures* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    storageBuffer16BitAccess = in_struct->storageBuffer16BitAccess;
+    uniformAndStorageBuffer16BitAccess = in_struct->uniformAndStorageBuffer16BitAccess;
+    storagePushConstant16 = in_struct->storagePushConstant16;
+    storageInputOutput16 = in_struct->storageInputOutput16;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevice16BitStorageFeatures::initialize(const safe_VkPhysicalDevice16BitStorageFeatures* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    storageBuffer16BitAccess = copy_src->storageBuffer16BitAccess;
+    uniformAndStorageBuffer16BitAccess = copy_src->uniformAndStorageBuffer16BitAccess;
+    storagePushConstant16 = copy_src->storagePushConstant16;
+    storageInputOutput16 = copy_src->storageInputOutput16;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkMemoryDedicatedRequirements::safe_VkMemoryDedicatedRequirements(const VkMemoryDedicatedRequirements* in_struct,
+                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      prefersDedicatedAllocation(in_struct->prefersDedicatedAllocation),
+      requiresDedicatedAllocation(in_struct->requiresDedicatedAllocation) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMemoryDedicatedRequirements::safe_VkMemoryDedicatedRequirements()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS),
+      pNext(nullptr),
+      prefersDedicatedAllocation(),
+      requiresDedicatedAllocation() {}
+
+safe_VkMemoryDedicatedRequirements::safe_VkMemoryDedicatedRequirements(const safe_VkMemoryDedicatedRequirements& copy_src) {
+    sType = copy_src.sType;
+    prefersDedicatedAllocation = copy_src.prefersDedicatedAllocation;
+    requiresDedicatedAllocation = copy_src.requiresDedicatedAllocation;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMemoryDedicatedRequirements& safe_VkMemoryDedicatedRequirements::operator=(
+    const safe_VkMemoryDedicatedRequirements& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    prefersDedicatedAllocation = copy_src.prefersDedicatedAllocation;
+    requiresDedicatedAllocation = copy_src.requiresDedicatedAllocation;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMemoryDedicatedRequirements::~safe_VkMemoryDedicatedRequirements() { FreePnextChain(pNext); }
+
+void safe_VkMemoryDedicatedRequirements::initialize(const VkMemoryDedicatedRequirements* in_struct,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    prefersDedicatedAllocation = in_struct->prefersDedicatedAllocation;
+    requiresDedicatedAllocation = in_struct->requiresDedicatedAllocation;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMemoryDedicatedRequirements::initialize(const safe_VkMemoryDedicatedRequirements* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    prefersDedicatedAllocation = copy_src->prefersDedicatedAllocation;
+    requiresDedicatedAllocation = copy_src->requiresDedicatedAllocation;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkMemoryDedicatedAllocateInfo::safe_VkMemoryDedicatedAllocateInfo(const VkMemoryDedicatedAllocateInfo* in_struct,
+                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), image(in_struct->image), buffer(in_struct->buffer) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMemoryDedicatedAllocateInfo::safe_VkMemoryDedicatedAllocateInfo()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO), pNext(nullptr), image(), buffer() {}
+
+safe_VkMemoryDedicatedAllocateInfo::safe_VkMemoryDedicatedAllocateInfo(const safe_VkMemoryDedicatedAllocateInfo& copy_src) {
+    sType = copy_src.sType;
+    image = copy_src.image;
+    buffer = copy_src.buffer;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMemoryDedicatedAllocateInfo& safe_VkMemoryDedicatedAllocateInfo::operator=(
+    const safe_VkMemoryDedicatedAllocateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    image = copy_src.image;
+    buffer = copy_src.buffer;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMemoryDedicatedAllocateInfo::~safe_VkMemoryDedicatedAllocateInfo() { FreePnextChain(pNext); }
+
+void safe_VkMemoryDedicatedAllocateInfo::initialize(const VkMemoryDedicatedAllocateInfo* in_struct,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    image = in_struct->image;
+    buffer = in_struct->buffer;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMemoryDedicatedAllocateInfo::initialize(const safe_VkMemoryDedicatedAllocateInfo* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    image = copy_src->image;
+    buffer = copy_src->buffer;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkMemoryAllocateFlagsInfo::safe_VkMemoryAllocateFlagsInfo(const VkMemoryAllocateFlagsInfo* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags), deviceMask(in_struct->deviceMask) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMemoryAllocateFlagsInfo::safe_VkMemoryAllocateFlagsInfo()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO), pNext(nullptr), flags(), deviceMask() {}
+
+safe_VkMemoryAllocateFlagsInfo::safe_VkMemoryAllocateFlagsInfo(const safe_VkMemoryAllocateFlagsInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    deviceMask = copy_src.deviceMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMemoryAllocateFlagsInfo& safe_VkMemoryAllocateFlagsInfo::operator=(const safe_VkMemoryAllocateFlagsInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    deviceMask = copy_src.deviceMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMemoryAllocateFlagsInfo::~safe_VkMemoryAllocateFlagsInfo() { FreePnextChain(pNext); }
+
+void safe_VkMemoryAllocateFlagsInfo::initialize(const VkMemoryAllocateFlagsInfo* in_struct,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    deviceMask = in_struct->deviceMask;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMemoryAllocateFlagsInfo::initialize(const safe_VkMemoryAllocateFlagsInfo* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    deviceMask = copy_src->deviceMask;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDeviceGroupRenderPassBeginInfo::safe_VkDeviceGroupRenderPassBeginInfo(const VkDeviceGroupRenderPassBeginInfo* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType),
+      deviceMask(in_struct->deviceMask),
+      deviceRenderAreaCount(in_struct->deviceRenderAreaCount),
+      pDeviceRenderAreas(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pDeviceRenderAreas) {
+        pDeviceRenderAreas = new VkRect2D[in_struct->deviceRenderAreaCount];
+        memcpy((void*)pDeviceRenderAreas, (void*)in_struct->pDeviceRenderAreas,
+               sizeof(VkRect2D) * in_struct->deviceRenderAreaCount);
+    }
+}
+
+safe_VkDeviceGroupRenderPassBeginInfo::safe_VkDeviceGroupRenderPassBeginInfo()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO),
+      pNext(nullptr),
+      deviceMask(),
+      deviceRenderAreaCount(),
+      pDeviceRenderAreas(nullptr) {}
+
+safe_VkDeviceGroupRenderPassBeginInfo::safe_VkDeviceGroupRenderPassBeginInfo(
+    const safe_VkDeviceGroupRenderPassBeginInfo& copy_src) {
+    sType = copy_src.sType;
+    deviceMask = copy_src.deviceMask;
+    deviceRenderAreaCount = copy_src.deviceRenderAreaCount;
+    pDeviceRenderAreas = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDeviceRenderAreas) {
+        pDeviceRenderAreas = new VkRect2D[copy_src.deviceRenderAreaCount];
+        memcpy((void*)pDeviceRenderAreas, (void*)copy_src.pDeviceRenderAreas, sizeof(VkRect2D) * copy_src.deviceRenderAreaCount);
+    }
+}
+
+safe_VkDeviceGroupRenderPassBeginInfo& safe_VkDeviceGroupRenderPassBeginInfo::operator=(
+    const safe_VkDeviceGroupRenderPassBeginInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pDeviceRenderAreas) delete[] pDeviceRenderAreas;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    deviceMask = copy_src.deviceMask;
+    deviceRenderAreaCount = copy_src.deviceRenderAreaCount;
+    pDeviceRenderAreas = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDeviceRenderAreas) {
+        pDeviceRenderAreas = new VkRect2D[copy_src.deviceRenderAreaCount];
+        memcpy((void*)pDeviceRenderAreas, (void*)copy_src.pDeviceRenderAreas, sizeof(VkRect2D) * copy_src.deviceRenderAreaCount);
+    }
+
+    return *this;
+}
+
+safe_VkDeviceGroupRenderPassBeginInfo::~safe_VkDeviceGroupRenderPassBeginInfo() {
+    if (pDeviceRenderAreas) delete[] pDeviceRenderAreas;
+    FreePnextChain(pNext);
+}
+
+void safe_VkDeviceGroupRenderPassBeginInfo::initialize(const VkDeviceGroupRenderPassBeginInfo* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pDeviceRenderAreas) delete[] pDeviceRenderAreas;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    deviceMask = in_struct->deviceMask;
+    deviceRenderAreaCount = in_struct->deviceRenderAreaCount;
+    pDeviceRenderAreas = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pDeviceRenderAreas) {
+        pDeviceRenderAreas = new VkRect2D[in_struct->deviceRenderAreaCount];
+        memcpy((void*)pDeviceRenderAreas, (void*)in_struct->pDeviceRenderAreas,
+               sizeof(VkRect2D) * in_struct->deviceRenderAreaCount);
+    }
+}
+
+void safe_VkDeviceGroupRenderPassBeginInfo::initialize(const safe_VkDeviceGroupRenderPassBeginInfo* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    deviceMask = copy_src->deviceMask;
+    deviceRenderAreaCount = copy_src->deviceRenderAreaCount;
+    pDeviceRenderAreas = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pDeviceRenderAreas) {
+        pDeviceRenderAreas = new VkRect2D[copy_src->deviceRenderAreaCount];
+        memcpy((void*)pDeviceRenderAreas, (void*)copy_src->pDeviceRenderAreas, sizeof(VkRect2D) * copy_src->deviceRenderAreaCount);
+    }
+}
+
+safe_VkDeviceGroupCommandBufferBeginInfo::safe_VkDeviceGroupCommandBufferBeginInfo(
+    const VkDeviceGroupCommandBufferBeginInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), deviceMask(in_struct->deviceMask) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDeviceGroupCommandBufferBeginInfo::safe_VkDeviceGroupCommandBufferBeginInfo()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO), pNext(nullptr), deviceMask() {}
+
+safe_VkDeviceGroupCommandBufferBeginInfo::safe_VkDeviceGroupCommandBufferBeginInfo(
+    const safe_VkDeviceGroupCommandBufferBeginInfo& copy_src) {
+    sType = copy_src.sType;
+    deviceMask = copy_src.deviceMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDeviceGroupCommandBufferBeginInfo& safe_VkDeviceGroupCommandBufferBeginInfo::operator=(
+    const safe_VkDeviceGroupCommandBufferBeginInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    deviceMask = copy_src.deviceMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDeviceGroupCommandBufferBeginInfo::~safe_VkDeviceGroupCommandBufferBeginInfo() { FreePnextChain(pNext); }
+
+void safe_VkDeviceGroupCommandBufferBeginInfo::initialize(const VkDeviceGroupCommandBufferBeginInfo* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    deviceMask = in_struct->deviceMask;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDeviceGroupCommandBufferBeginInfo::initialize(const safe_VkDeviceGroupCommandBufferBeginInfo* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    deviceMask = copy_src->deviceMask;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDeviceGroupSubmitInfo::safe_VkDeviceGroupSubmitInfo(const VkDeviceGroupSubmitInfo* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      waitSemaphoreCount(in_struct->waitSemaphoreCount),
+      pWaitSemaphoreDeviceIndices(nullptr),
+      commandBufferCount(in_struct->commandBufferCount),
+      pCommandBufferDeviceMasks(nullptr),
+      signalSemaphoreCount(in_struct->signalSemaphoreCount),
+      pSignalSemaphoreDeviceIndices(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pWaitSemaphoreDeviceIndices) {
+        pWaitSemaphoreDeviceIndices = new uint32_t[in_struct->waitSemaphoreCount];
+        memcpy((void*)pWaitSemaphoreDeviceIndices, (void*)in_struct->pWaitSemaphoreDeviceIndices,
+               sizeof(uint32_t) * in_struct->waitSemaphoreCount);
+    }
+
+    if (in_struct->pCommandBufferDeviceMasks) {
+        pCommandBufferDeviceMasks = new uint32_t[in_struct->commandBufferCount];
+        memcpy((void*)pCommandBufferDeviceMasks, (void*)in_struct->pCommandBufferDeviceMasks,
+               sizeof(uint32_t) * in_struct->commandBufferCount);
+    }
+
+    if (in_struct->pSignalSemaphoreDeviceIndices) {
+        pSignalSemaphoreDeviceIndices = new uint32_t[in_struct->signalSemaphoreCount];
+        memcpy((void*)pSignalSemaphoreDeviceIndices, (void*)in_struct->pSignalSemaphoreDeviceIndices,
+               sizeof(uint32_t) * in_struct->signalSemaphoreCount);
+    }
+}
+
+safe_VkDeviceGroupSubmitInfo::safe_VkDeviceGroupSubmitInfo()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO),
+      pNext(nullptr),
+      waitSemaphoreCount(),
+      pWaitSemaphoreDeviceIndices(nullptr),
+      commandBufferCount(),
+      pCommandBufferDeviceMasks(nullptr),
+      signalSemaphoreCount(),
+      pSignalSemaphoreDeviceIndices(nullptr) {}
+
+safe_VkDeviceGroupSubmitInfo::safe_VkDeviceGroupSubmitInfo(const safe_VkDeviceGroupSubmitInfo& copy_src) {
+    sType = copy_src.sType;
+    waitSemaphoreCount = copy_src.waitSemaphoreCount;
+    pWaitSemaphoreDeviceIndices = nullptr;
+    commandBufferCount = copy_src.commandBufferCount;
+    pCommandBufferDeviceMasks = nullptr;
+    signalSemaphoreCount = copy_src.signalSemaphoreCount;
+    pSignalSemaphoreDeviceIndices = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pWaitSemaphoreDeviceIndices) {
+        pWaitSemaphoreDeviceIndices = new uint32_t[copy_src.waitSemaphoreCount];
+        memcpy((void*)pWaitSemaphoreDeviceIndices, (void*)copy_src.pWaitSemaphoreDeviceIndices,
+               sizeof(uint32_t) * copy_src.waitSemaphoreCount);
+    }
+
+    if (copy_src.pCommandBufferDeviceMasks) {
+        pCommandBufferDeviceMasks = new uint32_t[copy_src.commandBufferCount];
+        memcpy((void*)pCommandBufferDeviceMasks, (void*)copy_src.pCommandBufferDeviceMasks,
+               sizeof(uint32_t) * copy_src.commandBufferCount);
+    }
+
+    if (copy_src.pSignalSemaphoreDeviceIndices) {
+        pSignalSemaphoreDeviceIndices = new uint32_t[copy_src.signalSemaphoreCount];
+        memcpy((void*)pSignalSemaphoreDeviceIndices, (void*)copy_src.pSignalSemaphoreDeviceIndices,
+               sizeof(uint32_t) * copy_src.signalSemaphoreCount);
+    }
+}
+
+safe_VkDeviceGroupSubmitInfo& safe_VkDeviceGroupSubmitInfo::operator=(const safe_VkDeviceGroupSubmitInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pWaitSemaphoreDeviceIndices) delete[] pWaitSemaphoreDeviceIndices;
+    if (pCommandBufferDeviceMasks) delete[] pCommandBufferDeviceMasks;
+    if (pSignalSemaphoreDeviceIndices) delete[] pSignalSemaphoreDeviceIndices;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    waitSemaphoreCount = copy_src.waitSemaphoreCount;
+    pWaitSemaphoreDeviceIndices = nullptr;
+    commandBufferCount = copy_src.commandBufferCount;
+    pCommandBufferDeviceMasks = nullptr;
+    signalSemaphoreCount = copy_src.signalSemaphoreCount;
+    pSignalSemaphoreDeviceIndices = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pWaitSemaphoreDeviceIndices) {
+        pWaitSemaphoreDeviceIndices = new uint32_t[copy_src.waitSemaphoreCount];
+        memcpy((void*)pWaitSemaphoreDeviceIndices, (void*)copy_src.pWaitSemaphoreDeviceIndices,
+               sizeof(uint32_t) * copy_src.waitSemaphoreCount);
+    }
+
+    if (copy_src.pCommandBufferDeviceMasks) {
+        pCommandBufferDeviceMasks = new uint32_t[copy_src.commandBufferCount];
+        memcpy((void*)pCommandBufferDeviceMasks, (void*)copy_src.pCommandBufferDeviceMasks,
+               sizeof(uint32_t) * copy_src.commandBufferCount);
+    }
+
+    if (copy_src.pSignalSemaphoreDeviceIndices) {
+        pSignalSemaphoreDeviceIndices = new uint32_t[copy_src.signalSemaphoreCount];
+        memcpy((void*)pSignalSemaphoreDeviceIndices, (void*)copy_src.pSignalSemaphoreDeviceIndices,
+               sizeof(uint32_t) * copy_src.signalSemaphoreCount);
+    }
+
+    return *this;
+}
+
+safe_VkDeviceGroupSubmitInfo::~safe_VkDeviceGroupSubmitInfo() {
+    if (pWaitSemaphoreDeviceIndices) delete[] pWaitSemaphoreDeviceIndices;
+    if (pCommandBufferDeviceMasks) delete[] pCommandBufferDeviceMasks;
+    if (pSignalSemaphoreDeviceIndices) delete[] pSignalSemaphoreDeviceIndices;
+    FreePnextChain(pNext);
+}
+
+void safe_VkDeviceGroupSubmitInfo::initialize(const VkDeviceGroupSubmitInfo* in_struct,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pWaitSemaphoreDeviceIndices) delete[] pWaitSemaphoreDeviceIndices;
+    if (pCommandBufferDeviceMasks) delete[] pCommandBufferDeviceMasks;
+    if (pSignalSemaphoreDeviceIndices) delete[] pSignalSemaphoreDeviceIndices;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    waitSemaphoreCount = in_struct->waitSemaphoreCount;
+    pWaitSemaphoreDeviceIndices = nullptr;
+    commandBufferCount = in_struct->commandBufferCount;
+    pCommandBufferDeviceMasks = nullptr;
+    signalSemaphoreCount = in_struct->signalSemaphoreCount;
+    pSignalSemaphoreDeviceIndices = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pWaitSemaphoreDeviceIndices) {
+        pWaitSemaphoreDeviceIndices = new uint32_t[in_struct->waitSemaphoreCount];
+        memcpy((void*)pWaitSemaphoreDeviceIndices, (void*)in_struct->pWaitSemaphoreDeviceIndices,
+               sizeof(uint32_t) * in_struct->waitSemaphoreCount);
+    }
+
+    if (in_struct->pCommandBufferDeviceMasks) {
+        pCommandBufferDeviceMasks = new uint32_t[in_struct->commandBufferCount];
+        memcpy((void*)pCommandBufferDeviceMasks, (void*)in_struct->pCommandBufferDeviceMasks,
+               sizeof(uint32_t) * in_struct->commandBufferCount);
+    }
+
+    if (in_struct->pSignalSemaphoreDeviceIndices) {
+        pSignalSemaphoreDeviceIndices = new uint32_t[in_struct->signalSemaphoreCount];
+        memcpy((void*)pSignalSemaphoreDeviceIndices, (void*)in_struct->pSignalSemaphoreDeviceIndices,
+               sizeof(uint32_t) * in_struct->signalSemaphoreCount);
+    }
+}
+
+void safe_VkDeviceGroupSubmitInfo::initialize(const safe_VkDeviceGroupSubmitInfo* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    waitSemaphoreCount = copy_src->waitSemaphoreCount;
+    pWaitSemaphoreDeviceIndices = nullptr;
+    commandBufferCount = copy_src->commandBufferCount;
+    pCommandBufferDeviceMasks = nullptr;
+    signalSemaphoreCount = copy_src->signalSemaphoreCount;
+    pSignalSemaphoreDeviceIndices = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pWaitSemaphoreDeviceIndices) {
+        pWaitSemaphoreDeviceIndices = new uint32_t[copy_src->waitSemaphoreCount];
+        memcpy((void*)pWaitSemaphoreDeviceIndices, (void*)copy_src->pWaitSemaphoreDeviceIndices,
+               sizeof(uint32_t) * copy_src->waitSemaphoreCount);
+    }
+
+    if (copy_src->pCommandBufferDeviceMasks) {
+        pCommandBufferDeviceMasks = new uint32_t[copy_src->commandBufferCount];
+        memcpy((void*)pCommandBufferDeviceMasks, (void*)copy_src->pCommandBufferDeviceMasks,
+               sizeof(uint32_t) * copy_src->commandBufferCount);
+    }
+
+    if (copy_src->pSignalSemaphoreDeviceIndices) {
+        pSignalSemaphoreDeviceIndices = new uint32_t[copy_src->signalSemaphoreCount];
+        memcpy((void*)pSignalSemaphoreDeviceIndices, (void*)copy_src->pSignalSemaphoreDeviceIndices,
+               sizeof(uint32_t) * copy_src->signalSemaphoreCount);
+    }
+}
+
+safe_VkDeviceGroupBindSparseInfo::safe_VkDeviceGroupBindSparseInfo(const VkDeviceGroupBindSparseInfo* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      resourceDeviceIndex(in_struct->resourceDeviceIndex),
+      memoryDeviceIndex(in_struct->memoryDeviceIndex) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDeviceGroupBindSparseInfo::safe_VkDeviceGroupBindSparseInfo()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO), pNext(nullptr), resourceDeviceIndex(), memoryDeviceIndex() {}
+
+safe_VkDeviceGroupBindSparseInfo::safe_VkDeviceGroupBindSparseInfo(const safe_VkDeviceGroupBindSparseInfo& copy_src) {
+    sType = copy_src.sType;
+    resourceDeviceIndex = copy_src.resourceDeviceIndex;
+    memoryDeviceIndex = copy_src.memoryDeviceIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDeviceGroupBindSparseInfo& safe_VkDeviceGroupBindSparseInfo::operator=(const safe_VkDeviceGroupBindSparseInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    resourceDeviceIndex = copy_src.resourceDeviceIndex;
+    memoryDeviceIndex = copy_src.memoryDeviceIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDeviceGroupBindSparseInfo::~safe_VkDeviceGroupBindSparseInfo() { FreePnextChain(pNext); }
+
+void safe_VkDeviceGroupBindSparseInfo::initialize(const VkDeviceGroupBindSparseInfo* in_struct,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    resourceDeviceIndex = in_struct->resourceDeviceIndex;
+    memoryDeviceIndex = in_struct->memoryDeviceIndex;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDeviceGroupBindSparseInfo::initialize(const safe_VkDeviceGroupBindSparseInfo* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    resourceDeviceIndex = copy_src->resourceDeviceIndex;
+    memoryDeviceIndex = copy_src->memoryDeviceIndex;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkBindBufferMemoryDeviceGroupInfo::safe_VkBindBufferMemoryDeviceGroupInfo(const VkBindBufferMemoryDeviceGroupInfo* in_struct,
+                                                                               [[maybe_unused]] PNextCopyState* copy_state,
+                                                                               bool copy_pnext)
+    : sType(in_struct->sType), deviceIndexCount(in_struct->deviceIndexCount), pDeviceIndices(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pDeviceIndices) {
+        pDeviceIndices = new uint32_t[in_struct->deviceIndexCount];
+        memcpy((void*)pDeviceIndices, (void*)in_struct->pDeviceIndices, sizeof(uint32_t) * in_struct->deviceIndexCount);
+    }
+}
+
+safe_VkBindBufferMemoryDeviceGroupInfo::safe_VkBindBufferMemoryDeviceGroupInfo()
+    : sType(VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO), pNext(nullptr), deviceIndexCount(), pDeviceIndices(nullptr) {}
+
+safe_VkBindBufferMemoryDeviceGroupInfo::safe_VkBindBufferMemoryDeviceGroupInfo(
+    const safe_VkBindBufferMemoryDeviceGroupInfo& copy_src) {
+    sType = copy_src.sType;
+    deviceIndexCount = copy_src.deviceIndexCount;
+    pDeviceIndices = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDeviceIndices) {
+        pDeviceIndices = new uint32_t[copy_src.deviceIndexCount];
+        memcpy((void*)pDeviceIndices, (void*)copy_src.pDeviceIndices, sizeof(uint32_t) * copy_src.deviceIndexCount);
+    }
+}
+
+safe_VkBindBufferMemoryDeviceGroupInfo& safe_VkBindBufferMemoryDeviceGroupInfo::operator=(
+    const safe_VkBindBufferMemoryDeviceGroupInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pDeviceIndices) delete[] pDeviceIndices;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    deviceIndexCount = copy_src.deviceIndexCount;
+    pDeviceIndices = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDeviceIndices) {
+        pDeviceIndices = new uint32_t[copy_src.deviceIndexCount];
+        memcpy((void*)pDeviceIndices, (void*)copy_src.pDeviceIndices, sizeof(uint32_t) * copy_src.deviceIndexCount);
+    }
+
+    return *this;
+}
+
+safe_VkBindBufferMemoryDeviceGroupInfo::~safe_VkBindBufferMemoryDeviceGroupInfo() {
+    if (pDeviceIndices) delete[] pDeviceIndices;
+    FreePnextChain(pNext);
+}
+
+void safe_VkBindBufferMemoryDeviceGroupInfo::initialize(const VkBindBufferMemoryDeviceGroupInfo* in_struct,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pDeviceIndices) delete[] pDeviceIndices;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    deviceIndexCount = in_struct->deviceIndexCount;
+    pDeviceIndices = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pDeviceIndices) {
+        pDeviceIndices = new uint32_t[in_struct->deviceIndexCount];
+        memcpy((void*)pDeviceIndices, (void*)in_struct->pDeviceIndices, sizeof(uint32_t) * in_struct->deviceIndexCount);
+    }
+}
+
+void safe_VkBindBufferMemoryDeviceGroupInfo::initialize(const safe_VkBindBufferMemoryDeviceGroupInfo* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    deviceIndexCount = copy_src->deviceIndexCount;
+    pDeviceIndices = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pDeviceIndices) {
+        pDeviceIndices = new uint32_t[copy_src->deviceIndexCount];
+        memcpy((void*)pDeviceIndices, (void*)copy_src->pDeviceIndices, sizeof(uint32_t) * copy_src->deviceIndexCount);
+    }
+}
+
+safe_VkBindImageMemoryDeviceGroupInfo::safe_VkBindImageMemoryDeviceGroupInfo(const VkBindImageMemoryDeviceGroupInfo* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType),
+      deviceIndexCount(in_struct->deviceIndexCount),
+      pDeviceIndices(nullptr),
+      splitInstanceBindRegionCount(in_struct->splitInstanceBindRegionCount),
+      pSplitInstanceBindRegions(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pDeviceIndices) {
+        pDeviceIndices = new uint32_t[in_struct->deviceIndexCount];
+        memcpy((void*)pDeviceIndices, (void*)in_struct->pDeviceIndices, sizeof(uint32_t) * in_struct->deviceIndexCount);
+    }
+
+    if (in_struct->pSplitInstanceBindRegions) {
+        pSplitInstanceBindRegions = new VkRect2D[in_struct->splitInstanceBindRegionCount];
+        memcpy((void*)pSplitInstanceBindRegions, (void*)in_struct->pSplitInstanceBindRegions,
+               sizeof(VkRect2D) * in_struct->splitInstanceBindRegionCount);
+    }
+}
+
+safe_VkBindImageMemoryDeviceGroupInfo::safe_VkBindImageMemoryDeviceGroupInfo()
+    : sType(VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO),
+      pNext(nullptr),
+      deviceIndexCount(),
+      pDeviceIndices(nullptr),
+      splitInstanceBindRegionCount(),
+      pSplitInstanceBindRegions(nullptr) {}
+
+safe_VkBindImageMemoryDeviceGroupInfo::safe_VkBindImageMemoryDeviceGroupInfo(
+    const safe_VkBindImageMemoryDeviceGroupInfo& copy_src) {
+    sType = copy_src.sType;
+    deviceIndexCount = copy_src.deviceIndexCount;
+    pDeviceIndices = nullptr;
+    splitInstanceBindRegionCount = copy_src.splitInstanceBindRegionCount;
+    pSplitInstanceBindRegions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDeviceIndices) {
+        pDeviceIndices = new uint32_t[copy_src.deviceIndexCount];
+        memcpy((void*)pDeviceIndices, (void*)copy_src.pDeviceIndices, sizeof(uint32_t) * copy_src.deviceIndexCount);
+    }
+
+    if (copy_src.pSplitInstanceBindRegions) {
+        pSplitInstanceBindRegions = new VkRect2D[copy_src.splitInstanceBindRegionCount];
+        memcpy((void*)pSplitInstanceBindRegions, (void*)copy_src.pSplitInstanceBindRegions,
+               sizeof(VkRect2D) * copy_src.splitInstanceBindRegionCount);
+    }
+}
+
+safe_VkBindImageMemoryDeviceGroupInfo& safe_VkBindImageMemoryDeviceGroupInfo::operator=(
+    const safe_VkBindImageMemoryDeviceGroupInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pDeviceIndices) delete[] pDeviceIndices;
+    if (pSplitInstanceBindRegions) delete[] pSplitInstanceBindRegions;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    deviceIndexCount = copy_src.deviceIndexCount;
+    pDeviceIndices = nullptr;
+    splitInstanceBindRegionCount = copy_src.splitInstanceBindRegionCount;
+    pSplitInstanceBindRegions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDeviceIndices) {
+        pDeviceIndices = new uint32_t[copy_src.deviceIndexCount];
+        memcpy((void*)pDeviceIndices, (void*)copy_src.pDeviceIndices, sizeof(uint32_t) * copy_src.deviceIndexCount);
+    }
+
+    if (copy_src.pSplitInstanceBindRegions) {
+        pSplitInstanceBindRegions = new VkRect2D[copy_src.splitInstanceBindRegionCount];
+        memcpy((void*)pSplitInstanceBindRegions, (void*)copy_src.pSplitInstanceBindRegions,
+               sizeof(VkRect2D) * copy_src.splitInstanceBindRegionCount);
+    }
+
+    return *this;
+}
+
+safe_VkBindImageMemoryDeviceGroupInfo::~safe_VkBindImageMemoryDeviceGroupInfo() {
+    if (pDeviceIndices) delete[] pDeviceIndices;
+    if (pSplitInstanceBindRegions) delete[] pSplitInstanceBindRegions;
+    FreePnextChain(pNext);
+}
+
+void safe_VkBindImageMemoryDeviceGroupInfo::initialize(const VkBindImageMemoryDeviceGroupInfo* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pDeviceIndices) delete[] pDeviceIndices;
+    if (pSplitInstanceBindRegions) delete[] pSplitInstanceBindRegions;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    deviceIndexCount = in_struct->deviceIndexCount;
+    pDeviceIndices = nullptr;
+    splitInstanceBindRegionCount = in_struct->splitInstanceBindRegionCount;
+    pSplitInstanceBindRegions = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pDeviceIndices) {
+        pDeviceIndices = new uint32_t[in_struct->deviceIndexCount];
+        memcpy((void*)pDeviceIndices, (void*)in_struct->pDeviceIndices, sizeof(uint32_t) * in_struct->deviceIndexCount);
+    }
+
+    if (in_struct->pSplitInstanceBindRegions) {
+        pSplitInstanceBindRegions = new VkRect2D[in_struct->splitInstanceBindRegionCount];
+        memcpy((void*)pSplitInstanceBindRegions, (void*)in_struct->pSplitInstanceBindRegions,
+               sizeof(VkRect2D) * in_struct->splitInstanceBindRegionCount);
+    }
+}
+
+void safe_VkBindImageMemoryDeviceGroupInfo::initialize(const safe_VkBindImageMemoryDeviceGroupInfo* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    deviceIndexCount = copy_src->deviceIndexCount;
+    pDeviceIndices = nullptr;
+    splitInstanceBindRegionCount = copy_src->splitInstanceBindRegionCount;
+    pSplitInstanceBindRegions = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pDeviceIndices) {
+        pDeviceIndices = new uint32_t[copy_src->deviceIndexCount];
+        memcpy((void*)pDeviceIndices, (void*)copy_src->pDeviceIndices, sizeof(uint32_t) * copy_src->deviceIndexCount);
+    }
+
+    if (copy_src->pSplitInstanceBindRegions) {
+        pSplitInstanceBindRegions = new VkRect2D[copy_src->splitInstanceBindRegionCount];
+        memcpy((void*)pSplitInstanceBindRegions, (void*)copy_src->pSplitInstanceBindRegions,
+               sizeof(VkRect2D) * copy_src->splitInstanceBindRegionCount);
+    }
+}
+
+safe_VkPhysicalDeviceGroupProperties::safe_VkPhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), physicalDeviceCount(in_struct->physicalDeviceCount), subsetAllocation(in_struct->subsetAllocation) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
+        physicalDevices[i] = in_struct->physicalDevices[i];
+    }
+}
+
+safe_VkPhysicalDeviceGroupProperties::safe_VkPhysicalDeviceGroupProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES), pNext(nullptr), physicalDeviceCount(), subsetAllocation() {}
+
+safe_VkPhysicalDeviceGroupProperties::safe_VkPhysicalDeviceGroupProperties(const safe_VkPhysicalDeviceGroupProperties& copy_src) {
+    sType = copy_src.sType;
+    physicalDeviceCount = copy_src.physicalDeviceCount;
+    subsetAllocation = copy_src.subsetAllocation;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
+        physicalDevices[i] = copy_src.physicalDevices[i];
+    }
+}
+
+safe_VkPhysicalDeviceGroupProperties& safe_VkPhysicalDeviceGroupProperties::operator=(
+    const safe_VkPhysicalDeviceGroupProperties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    physicalDeviceCount = copy_src.physicalDeviceCount;
+    subsetAllocation = copy_src.subsetAllocation;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
+        physicalDevices[i] = copy_src.physicalDevices[i];
+    }
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceGroupProperties::~safe_VkPhysicalDeviceGroupProperties() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceGroupProperties::initialize(const VkPhysicalDeviceGroupProperties* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    physicalDeviceCount = in_struct->physicalDeviceCount;
+    subsetAllocation = in_struct->subsetAllocation;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
+        physicalDevices[i] = in_struct->physicalDevices[i];
+    }
+}
+
+void safe_VkPhysicalDeviceGroupProperties::initialize(const safe_VkPhysicalDeviceGroupProperties* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    physicalDeviceCount = copy_src->physicalDeviceCount;
+    subsetAllocation = copy_src->subsetAllocation;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
+        physicalDevices[i] = copy_src->physicalDevices[i];
+    }
+}
+
+safe_VkDeviceGroupDeviceCreateInfo::safe_VkDeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo* in_struct,
+                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), physicalDeviceCount(in_struct->physicalDeviceCount), pPhysicalDevices(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pPhysicalDevices) {
+        pPhysicalDevices = new VkPhysicalDevice[in_struct->physicalDeviceCount];
+        memcpy((void*)pPhysicalDevices, (void*)in_struct->pPhysicalDevices,
+               sizeof(VkPhysicalDevice) * in_struct->physicalDeviceCount);
+    }
+}
+
+safe_VkDeviceGroupDeviceCreateInfo::safe_VkDeviceGroupDeviceCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO), pNext(nullptr), physicalDeviceCount(), pPhysicalDevices(nullptr) {}
+
+safe_VkDeviceGroupDeviceCreateInfo::safe_VkDeviceGroupDeviceCreateInfo(const safe_VkDeviceGroupDeviceCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    physicalDeviceCount = copy_src.physicalDeviceCount;
+    pPhysicalDevices = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pPhysicalDevices) {
+        pPhysicalDevices = new VkPhysicalDevice[copy_src.physicalDeviceCount];
+        memcpy((void*)pPhysicalDevices, (void*)copy_src.pPhysicalDevices, sizeof(VkPhysicalDevice) * copy_src.physicalDeviceCount);
+    }
+}
+
+safe_VkDeviceGroupDeviceCreateInfo& safe_VkDeviceGroupDeviceCreateInfo::operator=(
+    const safe_VkDeviceGroupDeviceCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pPhysicalDevices) delete[] pPhysicalDevices;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    physicalDeviceCount = copy_src.physicalDeviceCount;
+    pPhysicalDevices = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pPhysicalDevices) {
+        pPhysicalDevices = new VkPhysicalDevice[copy_src.physicalDeviceCount];
+        memcpy((void*)pPhysicalDevices, (void*)copy_src.pPhysicalDevices, sizeof(VkPhysicalDevice) * copy_src.physicalDeviceCount);
+    }
+
+    return *this;
+}
+
+safe_VkDeviceGroupDeviceCreateInfo::~safe_VkDeviceGroupDeviceCreateInfo() {
+    if (pPhysicalDevices) delete[] pPhysicalDevices;
+    FreePnextChain(pNext);
+}
+
+void safe_VkDeviceGroupDeviceCreateInfo::initialize(const VkDeviceGroupDeviceCreateInfo* in_struct,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pPhysicalDevices) delete[] pPhysicalDevices;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    physicalDeviceCount = in_struct->physicalDeviceCount;
+    pPhysicalDevices = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pPhysicalDevices) {
+        pPhysicalDevices = new VkPhysicalDevice[in_struct->physicalDeviceCount];
+        memcpy((void*)pPhysicalDevices, (void*)in_struct->pPhysicalDevices,
+               sizeof(VkPhysicalDevice) * in_struct->physicalDeviceCount);
+    }
+}
+
+void safe_VkDeviceGroupDeviceCreateInfo::initialize(const safe_VkDeviceGroupDeviceCreateInfo* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    physicalDeviceCount = copy_src->physicalDeviceCount;
+    pPhysicalDevices = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pPhysicalDevices) {
+        pPhysicalDevices = new VkPhysicalDevice[copy_src->physicalDeviceCount];
+        memcpy((void*)pPhysicalDevices, (void*)copy_src->pPhysicalDevices,
+               sizeof(VkPhysicalDevice) * copy_src->physicalDeviceCount);
+    }
+}
+
+safe_VkBufferMemoryRequirementsInfo2::safe_VkBufferMemoryRequirementsInfo2(const VkBufferMemoryRequirementsInfo2* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), buffer(in_struct->buffer) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkBufferMemoryRequirementsInfo2::safe_VkBufferMemoryRequirementsInfo2()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2), pNext(nullptr), buffer() {}
+
+safe_VkBufferMemoryRequirementsInfo2::safe_VkBufferMemoryRequirementsInfo2(const safe_VkBufferMemoryRequirementsInfo2& copy_src) {
+    sType = copy_src.sType;
+    buffer = copy_src.buffer;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBufferMemoryRequirementsInfo2& safe_VkBufferMemoryRequirementsInfo2::operator=(
+    const safe_VkBufferMemoryRequirementsInfo2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    buffer = copy_src.buffer;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkBufferMemoryRequirementsInfo2::~safe_VkBufferMemoryRequirementsInfo2() { FreePnextChain(pNext); }
+
+void safe_VkBufferMemoryRequirementsInfo2::initialize(const VkBufferMemoryRequirementsInfo2* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    buffer = in_struct->buffer;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkBufferMemoryRequirementsInfo2::initialize(const safe_VkBufferMemoryRequirementsInfo2* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    buffer = copy_src->buffer;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkImageMemoryRequirementsInfo2::safe_VkImageMemoryRequirementsInfo2(const VkImageMemoryRequirementsInfo2* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType), image(in_struct->image) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImageMemoryRequirementsInfo2::safe_VkImageMemoryRequirementsInfo2()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2), pNext(nullptr), image() {}
+
+safe_VkImageMemoryRequirementsInfo2::safe_VkImageMemoryRequirementsInfo2(const safe_VkImageMemoryRequirementsInfo2& copy_src) {
+    sType = copy_src.sType;
+    image = copy_src.image;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImageMemoryRequirementsInfo2& safe_VkImageMemoryRequirementsInfo2::operator=(
+    const safe_VkImageMemoryRequirementsInfo2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    image = copy_src.image;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImageMemoryRequirementsInfo2::~safe_VkImageMemoryRequirementsInfo2() { FreePnextChain(pNext); }
+
+void safe_VkImageMemoryRequirementsInfo2::initialize(const VkImageMemoryRequirementsInfo2* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    image = in_struct->image;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImageMemoryRequirementsInfo2::initialize(const safe_VkImageMemoryRequirementsInfo2* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    image = copy_src->image;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkImageSparseMemoryRequirementsInfo2::safe_VkImageSparseMemoryRequirementsInfo2(
+    const VkImageSparseMemoryRequirementsInfo2* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), image(in_struct->image) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImageSparseMemoryRequirementsInfo2::safe_VkImageSparseMemoryRequirementsInfo2()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2), pNext(nullptr), image() {}
+
+safe_VkImageSparseMemoryRequirementsInfo2::safe_VkImageSparseMemoryRequirementsInfo2(
+    const safe_VkImageSparseMemoryRequirementsInfo2& copy_src) {
+    sType = copy_src.sType;
+    image = copy_src.image;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImageSparseMemoryRequirementsInfo2& safe_VkImageSparseMemoryRequirementsInfo2::operator=(
+    const safe_VkImageSparseMemoryRequirementsInfo2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    image = copy_src.image;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImageSparseMemoryRequirementsInfo2::~safe_VkImageSparseMemoryRequirementsInfo2() { FreePnextChain(pNext); }
+
+void safe_VkImageSparseMemoryRequirementsInfo2::initialize(const VkImageSparseMemoryRequirementsInfo2* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    image = in_struct->image;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImageSparseMemoryRequirementsInfo2::initialize(const safe_VkImageSparseMemoryRequirementsInfo2* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    image = copy_src->image;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkMemoryRequirements2::safe_VkMemoryRequirements2(const VkMemoryRequirements2* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), memoryRequirements(in_struct->memoryRequirements) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMemoryRequirements2::safe_VkMemoryRequirements2()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2), pNext(nullptr), memoryRequirements() {}
+
+safe_VkMemoryRequirements2::safe_VkMemoryRequirements2(const safe_VkMemoryRequirements2& copy_src) {
+    sType = copy_src.sType;
+    memoryRequirements = copy_src.memoryRequirements;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMemoryRequirements2& safe_VkMemoryRequirements2::operator=(const safe_VkMemoryRequirements2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    memoryRequirements = copy_src.memoryRequirements;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMemoryRequirements2::~safe_VkMemoryRequirements2() { FreePnextChain(pNext); }
+
+void safe_VkMemoryRequirements2::initialize(const VkMemoryRequirements2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    memoryRequirements = in_struct->memoryRequirements;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMemoryRequirements2::initialize(const safe_VkMemoryRequirements2* copy_src,
+                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memoryRequirements = copy_src->memoryRequirements;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSparseImageMemoryRequirements2::safe_VkSparseImageMemoryRequirements2(const VkSparseImageMemoryRequirements2* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType), memoryRequirements(in_struct->memoryRequirements) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSparseImageMemoryRequirements2::safe_VkSparseImageMemoryRequirements2()
+    : sType(VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2), pNext(nullptr), memoryRequirements() {}
+
+safe_VkSparseImageMemoryRequirements2::safe_VkSparseImageMemoryRequirements2(
+    const safe_VkSparseImageMemoryRequirements2& copy_src) {
+    sType = copy_src.sType;
+    memoryRequirements = copy_src.memoryRequirements;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSparseImageMemoryRequirements2& safe_VkSparseImageMemoryRequirements2::operator=(
+    const safe_VkSparseImageMemoryRequirements2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    memoryRequirements = copy_src.memoryRequirements;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSparseImageMemoryRequirements2::~safe_VkSparseImageMemoryRequirements2() { FreePnextChain(pNext); }
+
+void safe_VkSparseImageMemoryRequirements2::initialize(const VkSparseImageMemoryRequirements2* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    memoryRequirements = in_struct->memoryRequirements;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSparseImageMemoryRequirements2::initialize(const safe_VkSparseImageMemoryRequirements2* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memoryRequirements = copy_src->memoryRequirements;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceFeatures2::safe_VkPhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), features(in_struct->features) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceFeatures2::safe_VkPhysicalDeviceFeatures2()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2), pNext(nullptr), features() {}
+
+safe_VkPhysicalDeviceFeatures2::safe_VkPhysicalDeviceFeatures2(const safe_VkPhysicalDeviceFeatures2& copy_src) {
+    sType = copy_src.sType;
+    features = copy_src.features;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceFeatures2& safe_VkPhysicalDeviceFeatures2::operator=(const safe_VkPhysicalDeviceFeatures2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    features = copy_src.features;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceFeatures2::~safe_VkPhysicalDeviceFeatures2() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceFeatures2::initialize(const VkPhysicalDeviceFeatures2* in_struct,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    features = in_struct->features;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceFeatures2::initialize(const safe_VkPhysicalDeviceFeatures2* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    features = copy_src->features;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceProperties2::safe_VkPhysicalDeviceProperties2(const VkPhysicalDeviceProperties2* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), properties(in_struct->properties) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceProperties2::safe_VkPhysicalDeviceProperties2()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2), pNext(nullptr), properties() {}
+
+safe_VkPhysicalDeviceProperties2::safe_VkPhysicalDeviceProperties2(const safe_VkPhysicalDeviceProperties2& copy_src) {
+    sType = copy_src.sType;
+    properties = copy_src.properties;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceProperties2& safe_VkPhysicalDeviceProperties2::operator=(const safe_VkPhysicalDeviceProperties2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    properties = copy_src.properties;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceProperties2::~safe_VkPhysicalDeviceProperties2() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceProperties2::initialize(const VkPhysicalDeviceProperties2* in_struct,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    properties = in_struct->properties;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceProperties2::initialize(const safe_VkPhysicalDeviceProperties2* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    properties = copy_src->properties;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkFormatProperties2::safe_VkFormatProperties2(const VkFormatProperties2* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), formatProperties(in_struct->formatProperties) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkFormatProperties2::safe_VkFormatProperties2()
+    : sType(VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2), pNext(nullptr), formatProperties() {}
+
+safe_VkFormatProperties2::safe_VkFormatProperties2(const safe_VkFormatProperties2& copy_src) {
+    sType = copy_src.sType;
+    formatProperties = copy_src.formatProperties;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkFormatProperties2& safe_VkFormatProperties2::operator=(const safe_VkFormatProperties2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    formatProperties = copy_src.formatProperties;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkFormatProperties2::~safe_VkFormatProperties2() { FreePnextChain(pNext); }
+
+void safe_VkFormatProperties2::initialize(const VkFormatProperties2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    formatProperties = in_struct->formatProperties;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkFormatProperties2::initialize(const safe_VkFormatProperties2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    formatProperties = copy_src->formatProperties;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkImageFormatProperties2::safe_VkImageFormatProperties2(const VkImageFormatProperties2* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), imageFormatProperties(in_struct->imageFormatProperties) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImageFormatProperties2::safe_VkImageFormatProperties2()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2), pNext(nullptr), imageFormatProperties() {}
+
+safe_VkImageFormatProperties2::safe_VkImageFormatProperties2(const safe_VkImageFormatProperties2& copy_src) {
+    sType = copy_src.sType;
+    imageFormatProperties = copy_src.imageFormatProperties;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImageFormatProperties2& safe_VkImageFormatProperties2::operator=(const safe_VkImageFormatProperties2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    imageFormatProperties = copy_src.imageFormatProperties;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImageFormatProperties2::~safe_VkImageFormatProperties2() { FreePnextChain(pNext); }
+
+void safe_VkImageFormatProperties2::initialize(const VkImageFormatProperties2* in_struct,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    imageFormatProperties = in_struct->imageFormatProperties;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImageFormatProperties2::initialize(const safe_VkImageFormatProperties2* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imageFormatProperties = copy_src->imageFormatProperties;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceImageFormatInfo2::safe_VkPhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType),
+      format(in_struct->format),
+      type(in_struct->type),
+      tiling(in_struct->tiling),
+      usage(in_struct->usage),
+      flags(in_struct->flags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceImageFormatInfo2::safe_VkPhysicalDeviceImageFormatInfo2()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2), pNext(nullptr), format(), type(), tiling(), usage(), flags() {}
+
+safe_VkPhysicalDeviceImageFormatInfo2::safe_VkPhysicalDeviceImageFormatInfo2(
+    const safe_VkPhysicalDeviceImageFormatInfo2& copy_src) {
+    sType = copy_src.sType;
+    format = copy_src.format;
+    type = copy_src.type;
+    tiling = copy_src.tiling;
+    usage = copy_src.usage;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceImageFormatInfo2& safe_VkPhysicalDeviceImageFormatInfo2::operator=(
+    const safe_VkPhysicalDeviceImageFormatInfo2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    format = copy_src.format;
+    type = copy_src.type;
+    tiling = copy_src.tiling;
+    usage = copy_src.usage;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceImageFormatInfo2::~safe_VkPhysicalDeviceImageFormatInfo2() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceImageFormatInfo2::initialize(const VkPhysicalDeviceImageFormatInfo2* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    format = in_struct->format;
+    type = in_struct->type;
+    tiling = in_struct->tiling;
+    usage = in_struct->usage;
+    flags = in_struct->flags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceImageFormatInfo2::initialize(const safe_VkPhysicalDeviceImageFormatInfo2* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    format = copy_src->format;
+    type = copy_src->type;
+    tiling = copy_src->tiling;
+    usage = copy_src->usage;
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkQueueFamilyProperties2::safe_VkQueueFamilyProperties2(const VkQueueFamilyProperties2* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), queueFamilyProperties(in_struct->queueFamilyProperties) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkQueueFamilyProperties2::safe_VkQueueFamilyProperties2()
+    : sType(VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2), pNext(nullptr), queueFamilyProperties() {}
+
+safe_VkQueueFamilyProperties2::safe_VkQueueFamilyProperties2(const safe_VkQueueFamilyProperties2& copy_src) {
+    sType = copy_src.sType;
+    queueFamilyProperties = copy_src.queueFamilyProperties;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkQueueFamilyProperties2& safe_VkQueueFamilyProperties2::operator=(const safe_VkQueueFamilyProperties2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    queueFamilyProperties = copy_src.queueFamilyProperties;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkQueueFamilyProperties2::~safe_VkQueueFamilyProperties2() { FreePnextChain(pNext); }
+
+void safe_VkQueueFamilyProperties2::initialize(const VkQueueFamilyProperties2* in_struct,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    queueFamilyProperties = in_struct->queueFamilyProperties;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkQueueFamilyProperties2::initialize(const safe_VkQueueFamilyProperties2* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    queueFamilyProperties = copy_src->queueFamilyProperties;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceMemoryProperties2::safe_VkPhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2* in_struct,
+                                                                               [[maybe_unused]] PNextCopyState* copy_state,
+                                                                               bool copy_pnext)
+    : sType(in_struct->sType), memoryProperties(in_struct->memoryProperties) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMemoryProperties2::safe_VkPhysicalDeviceMemoryProperties2()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2), pNext(nullptr), memoryProperties() {}
+
+safe_VkPhysicalDeviceMemoryProperties2::safe_VkPhysicalDeviceMemoryProperties2(
+    const safe_VkPhysicalDeviceMemoryProperties2& copy_src) {
+    sType = copy_src.sType;
+    memoryProperties = copy_src.memoryProperties;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMemoryProperties2& safe_VkPhysicalDeviceMemoryProperties2::operator=(
+    const safe_VkPhysicalDeviceMemoryProperties2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    memoryProperties = copy_src.memoryProperties;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMemoryProperties2::~safe_VkPhysicalDeviceMemoryProperties2() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceMemoryProperties2::initialize(const VkPhysicalDeviceMemoryProperties2* in_struct,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    memoryProperties = in_struct->memoryProperties;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMemoryProperties2::initialize(const safe_VkPhysicalDeviceMemoryProperties2* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memoryProperties = copy_src->memoryProperties;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSparseImageFormatProperties2::safe_VkSparseImageFormatProperties2(const VkSparseImageFormatProperties2* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType), properties(in_struct->properties) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSparseImageFormatProperties2::safe_VkSparseImageFormatProperties2()
+    : sType(VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2), pNext(nullptr), properties() {}
+
+safe_VkSparseImageFormatProperties2::safe_VkSparseImageFormatProperties2(const safe_VkSparseImageFormatProperties2& copy_src) {
+    sType = copy_src.sType;
+    properties = copy_src.properties;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSparseImageFormatProperties2& safe_VkSparseImageFormatProperties2::operator=(
+    const safe_VkSparseImageFormatProperties2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    properties = copy_src.properties;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSparseImageFormatProperties2::~safe_VkSparseImageFormatProperties2() { FreePnextChain(pNext); }
+
+void safe_VkSparseImageFormatProperties2::initialize(const VkSparseImageFormatProperties2* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    properties = in_struct->properties;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSparseImageFormatProperties2::initialize(const safe_VkSparseImageFormatProperties2* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    properties = copy_src->properties;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceSparseImageFormatInfo2::safe_VkPhysicalDeviceSparseImageFormatInfo2(
+    const VkPhysicalDeviceSparseImageFormatInfo2* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      format(in_struct->format),
+      type(in_struct->type),
+      samples(in_struct->samples),
+      usage(in_struct->usage),
+      tiling(in_struct->tiling) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceSparseImageFormatInfo2::safe_VkPhysicalDeviceSparseImageFormatInfo2()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2),
+      pNext(nullptr),
+      format(),
+      type(),
+      samples(),
+      usage(),
+      tiling() {}
+
+safe_VkPhysicalDeviceSparseImageFormatInfo2::safe_VkPhysicalDeviceSparseImageFormatInfo2(
+    const safe_VkPhysicalDeviceSparseImageFormatInfo2& copy_src) {
+    sType = copy_src.sType;
+    format = copy_src.format;
+    type = copy_src.type;
+    samples = copy_src.samples;
+    usage = copy_src.usage;
+    tiling = copy_src.tiling;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceSparseImageFormatInfo2& safe_VkPhysicalDeviceSparseImageFormatInfo2::operator=(
+    const safe_VkPhysicalDeviceSparseImageFormatInfo2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    format = copy_src.format;
+    type = copy_src.type;
+    samples = copy_src.samples;
+    usage = copy_src.usage;
+    tiling = copy_src.tiling;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceSparseImageFormatInfo2::~safe_VkPhysicalDeviceSparseImageFormatInfo2() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceSparseImageFormatInfo2::initialize(const VkPhysicalDeviceSparseImageFormatInfo2* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    format = in_struct->format;
+    type = in_struct->type;
+    samples = in_struct->samples;
+    usage = in_struct->usage;
+    tiling = in_struct->tiling;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceSparseImageFormatInfo2::initialize(const safe_VkPhysicalDeviceSparseImageFormatInfo2* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    format = copy_src->format;
+    type = copy_src->type;
+    samples = copy_src->samples;
+    usage = copy_src->usage;
+    tiling = copy_src->tiling;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDevicePointClippingProperties::safe_VkPhysicalDevicePointClippingProperties(
+    const VkPhysicalDevicePointClippingProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), pointClippingBehavior(in_struct->pointClippingBehavior) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePointClippingProperties::safe_VkPhysicalDevicePointClippingProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES), pNext(nullptr), pointClippingBehavior() {}
+
+safe_VkPhysicalDevicePointClippingProperties::safe_VkPhysicalDevicePointClippingProperties(
+    const safe_VkPhysicalDevicePointClippingProperties& copy_src) {
+    sType = copy_src.sType;
+    pointClippingBehavior = copy_src.pointClippingBehavior;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePointClippingProperties& safe_VkPhysicalDevicePointClippingProperties::operator=(
+    const safe_VkPhysicalDevicePointClippingProperties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pointClippingBehavior = copy_src.pointClippingBehavior;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePointClippingProperties::~safe_VkPhysicalDevicePointClippingProperties() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDevicePointClippingProperties::initialize(const VkPhysicalDevicePointClippingProperties* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pointClippingBehavior = in_struct->pointClippingBehavior;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePointClippingProperties::initialize(const safe_VkPhysicalDevicePointClippingProperties* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pointClippingBehavior = copy_src->pointClippingBehavior;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkRenderPassInputAttachmentAspectCreateInfo::safe_VkRenderPassInputAttachmentAspectCreateInfo(
+    const VkRenderPassInputAttachmentAspectCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), aspectReferenceCount(in_struct->aspectReferenceCount), pAspectReferences(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pAspectReferences) {
+        pAspectReferences = new VkInputAttachmentAspectReference[in_struct->aspectReferenceCount];
+        memcpy((void*)pAspectReferences, (void*)in_struct->pAspectReferences,
+               sizeof(VkInputAttachmentAspectReference) * in_struct->aspectReferenceCount);
+    }
+}
+
+safe_VkRenderPassInputAttachmentAspectCreateInfo::safe_VkRenderPassInputAttachmentAspectCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO),
+      pNext(nullptr),
+      aspectReferenceCount(),
+      pAspectReferences(nullptr) {}
+
+safe_VkRenderPassInputAttachmentAspectCreateInfo::safe_VkRenderPassInputAttachmentAspectCreateInfo(
+    const safe_VkRenderPassInputAttachmentAspectCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    aspectReferenceCount = copy_src.aspectReferenceCount;
+    pAspectReferences = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pAspectReferences) {
+        pAspectReferences = new VkInputAttachmentAspectReference[copy_src.aspectReferenceCount];
+        memcpy((void*)pAspectReferences, (void*)copy_src.pAspectReferences,
+               sizeof(VkInputAttachmentAspectReference) * copy_src.aspectReferenceCount);
+    }
+}
+
+safe_VkRenderPassInputAttachmentAspectCreateInfo& safe_VkRenderPassInputAttachmentAspectCreateInfo::operator=(
+    const safe_VkRenderPassInputAttachmentAspectCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pAspectReferences) delete[] pAspectReferences;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    aspectReferenceCount = copy_src.aspectReferenceCount;
+    pAspectReferences = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pAspectReferences) {
+        pAspectReferences = new VkInputAttachmentAspectReference[copy_src.aspectReferenceCount];
+        memcpy((void*)pAspectReferences, (void*)copy_src.pAspectReferences,
+               sizeof(VkInputAttachmentAspectReference) * copy_src.aspectReferenceCount);
+    }
+
+    return *this;
+}
+
+safe_VkRenderPassInputAttachmentAspectCreateInfo::~safe_VkRenderPassInputAttachmentAspectCreateInfo() {
+    if (pAspectReferences) delete[] pAspectReferences;
+    FreePnextChain(pNext);
+}
+
+void safe_VkRenderPassInputAttachmentAspectCreateInfo::initialize(const VkRenderPassInputAttachmentAspectCreateInfo* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pAspectReferences) delete[] pAspectReferences;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    aspectReferenceCount = in_struct->aspectReferenceCount;
+    pAspectReferences = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pAspectReferences) {
+        pAspectReferences = new VkInputAttachmentAspectReference[in_struct->aspectReferenceCount];
+        memcpy((void*)pAspectReferences, (void*)in_struct->pAspectReferences,
+               sizeof(VkInputAttachmentAspectReference) * in_struct->aspectReferenceCount);
+    }
+}
+
+void safe_VkRenderPassInputAttachmentAspectCreateInfo::initialize(const safe_VkRenderPassInputAttachmentAspectCreateInfo* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    aspectReferenceCount = copy_src->aspectReferenceCount;
+    pAspectReferences = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pAspectReferences) {
+        pAspectReferences = new VkInputAttachmentAspectReference[copy_src->aspectReferenceCount];
+        memcpy((void*)pAspectReferences, (void*)copy_src->pAspectReferences,
+               sizeof(VkInputAttachmentAspectReference) * copy_src->aspectReferenceCount);
+    }
+}
+
+safe_VkImageViewUsageCreateInfo::safe_VkImageViewUsageCreateInfo(const VkImageViewUsageCreateInfo* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), usage(in_struct->usage) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImageViewUsageCreateInfo::safe_VkImageViewUsageCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO), pNext(nullptr), usage() {}
+
+safe_VkImageViewUsageCreateInfo::safe_VkImageViewUsageCreateInfo(const safe_VkImageViewUsageCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    usage = copy_src.usage;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImageViewUsageCreateInfo& safe_VkImageViewUsageCreateInfo::operator=(const safe_VkImageViewUsageCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    usage = copy_src.usage;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImageViewUsageCreateInfo::~safe_VkImageViewUsageCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkImageViewUsageCreateInfo::initialize(const VkImageViewUsageCreateInfo* in_struct,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    usage = in_struct->usage;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImageViewUsageCreateInfo::initialize(const safe_VkImageViewUsageCreateInfo* copy_src,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    usage = copy_src->usage;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineTessellationDomainOriginStateCreateInfo::safe_VkPipelineTessellationDomainOriginStateCreateInfo(
+    const VkPipelineTessellationDomainOriginStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), domainOrigin(in_struct->domainOrigin) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPipelineTessellationDomainOriginStateCreateInfo::safe_VkPipelineTessellationDomainOriginStateCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO), pNext(nullptr), domainOrigin() {}
+
+safe_VkPipelineTessellationDomainOriginStateCreateInfo::safe_VkPipelineTessellationDomainOriginStateCreateInfo(
+    const safe_VkPipelineTessellationDomainOriginStateCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    domainOrigin = copy_src.domainOrigin;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPipelineTessellationDomainOriginStateCreateInfo& safe_VkPipelineTessellationDomainOriginStateCreateInfo::operator=(
+    const safe_VkPipelineTessellationDomainOriginStateCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    domainOrigin = copy_src.domainOrigin;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineTessellationDomainOriginStateCreateInfo::~safe_VkPipelineTessellationDomainOriginStateCreateInfo() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineTessellationDomainOriginStateCreateInfo::initialize(
+    const VkPipelineTessellationDomainOriginStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    domainOrigin = in_struct->domainOrigin;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPipelineTessellationDomainOriginStateCreateInfo::initialize(
+    const safe_VkPipelineTessellationDomainOriginStateCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    domainOrigin = copy_src->domainOrigin;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkRenderPassMultiviewCreateInfo::safe_VkRenderPassMultiviewCreateInfo(const VkRenderPassMultiviewCreateInfo* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType),
+      subpassCount(in_struct->subpassCount),
+      pViewMasks(nullptr),
+      dependencyCount(in_struct->dependencyCount),
+      pViewOffsets(nullptr),
+      correlationMaskCount(in_struct->correlationMaskCount),
+      pCorrelationMasks(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pViewMasks) {
+        pViewMasks = new uint32_t[in_struct->subpassCount];
+        memcpy((void*)pViewMasks, (void*)in_struct->pViewMasks, sizeof(uint32_t) * in_struct->subpassCount);
+    }
+
+    if (in_struct->pViewOffsets) {
+        pViewOffsets = new int32_t[in_struct->dependencyCount];
+        memcpy((void*)pViewOffsets, (void*)in_struct->pViewOffsets, sizeof(int32_t) * in_struct->dependencyCount);
+    }
+
+    if (in_struct->pCorrelationMasks) {
+        pCorrelationMasks = new uint32_t[in_struct->correlationMaskCount];
+        memcpy((void*)pCorrelationMasks, (void*)in_struct->pCorrelationMasks, sizeof(uint32_t) * in_struct->correlationMaskCount);
+    }
+}
+
+safe_VkRenderPassMultiviewCreateInfo::safe_VkRenderPassMultiviewCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO),
+      pNext(nullptr),
+      subpassCount(),
+      pViewMasks(nullptr),
+      dependencyCount(),
+      pViewOffsets(nullptr),
+      correlationMaskCount(),
+      pCorrelationMasks(nullptr) {}
+
+safe_VkRenderPassMultiviewCreateInfo::safe_VkRenderPassMultiviewCreateInfo(const safe_VkRenderPassMultiviewCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    subpassCount = copy_src.subpassCount;
+    pViewMasks = nullptr;
+    dependencyCount = copy_src.dependencyCount;
+    pViewOffsets = nullptr;
+    correlationMaskCount = copy_src.correlationMaskCount;
+    pCorrelationMasks = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pViewMasks) {
+        pViewMasks = new uint32_t[copy_src.subpassCount];
+        memcpy((void*)pViewMasks, (void*)copy_src.pViewMasks, sizeof(uint32_t) * copy_src.subpassCount);
+    }
+
+    if (copy_src.pViewOffsets) {
+        pViewOffsets = new int32_t[copy_src.dependencyCount];
+        memcpy((void*)pViewOffsets, (void*)copy_src.pViewOffsets, sizeof(int32_t) * copy_src.dependencyCount);
+    }
+
+    if (copy_src.pCorrelationMasks) {
+        pCorrelationMasks = new uint32_t[copy_src.correlationMaskCount];
+        memcpy((void*)pCorrelationMasks, (void*)copy_src.pCorrelationMasks, sizeof(uint32_t) * copy_src.correlationMaskCount);
+    }
+}
+
+safe_VkRenderPassMultiviewCreateInfo& safe_VkRenderPassMultiviewCreateInfo::operator=(
+    const safe_VkRenderPassMultiviewCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pViewMasks) delete[] pViewMasks;
+    if (pViewOffsets) delete[] pViewOffsets;
+    if (pCorrelationMasks) delete[] pCorrelationMasks;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    subpassCount = copy_src.subpassCount;
+    pViewMasks = nullptr;
+    dependencyCount = copy_src.dependencyCount;
+    pViewOffsets = nullptr;
+    correlationMaskCount = copy_src.correlationMaskCount;
+    pCorrelationMasks = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pViewMasks) {
+        pViewMasks = new uint32_t[copy_src.subpassCount];
+        memcpy((void*)pViewMasks, (void*)copy_src.pViewMasks, sizeof(uint32_t) * copy_src.subpassCount);
+    }
+
+    if (copy_src.pViewOffsets) {
+        pViewOffsets = new int32_t[copy_src.dependencyCount];
+        memcpy((void*)pViewOffsets, (void*)copy_src.pViewOffsets, sizeof(int32_t) * copy_src.dependencyCount);
+    }
+
+    if (copy_src.pCorrelationMasks) {
+        pCorrelationMasks = new uint32_t[copy_src.correlationMaskCount];
+        memcpy((void*)pCorrelationMasks, (void*)copy_src.pCorrelationMasks, sizeof(uint32_t) * copy_src.correlationMaskCount);
+    }
+
+    return *this;
+}
+
+safe_VkRenderPassMultiviewCreateInfo::~safe_VkRenderPassMultiviewCreateInfo() {
+    if (pViewMasks) delete[] pViewMasks;
+    if (pViewOffsets) delete[] pViewOffsets;
+    if (pCorrelationMasks) delete[] pCorrelationMasks;
+    FreePnextChain(pNext);
+}
+
+void safe_VkRenderPassMultiviewCreateInfo::initialize(const VkRenderPassMultiviewCreateInfo* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pViewMasks) delete[] pViewMasks;
+    if (pViewOffsets) delete[] pViewOffsets;
+    if (pCorrelationMasks) delete[] pCorrelationMasks;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    subpassCount = in_struct->subpassCount;
+    pViewMasks = nullptr;
+    dependencyCount = in_struct->dependencyCount;
+    pViewOffsets = nullptr;
+    correlationMaskCount = in_struct->correlationMaskCount;
+    pCorrelationMasks = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pViewMasks) {
+        pViewMasks = new uint32_t[in_struct->subpassCount];
+        memcpy((void*)pViewMasks, (void*)in_struct->pViewMasks, sizeof(uint32_t) * in_struct->subpassCount);
+    }
+
+    if (in_struct->pViewOffsets) {
+        pViewOffsets = new int32_t[in_struct->dependencyCount];
+        memcpy((void*)pViewOffsets, (void*)in_struct->pViewOffsets, sizeof(int32_t) * in_struct->dependencyCount);
+    }
+
+    if (in_struct->pCorrelationMasks) {
+        pCorrelationMasks = new uint32_t[in_struct->correlationMaskCount];
+        memcpy((void*)pCorrelationMasks, (void*)in_struct->pCorrelationMasks, sizeof(uint32_t) * in_struct->correlationMaskCount);
+    }
+}
+
+void safe_VkRenderPassMultiviewCreateInfo::initialize(const safe_VkRenderPassMultiviewCreateInfo* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    subpassCount = copy_src->subpassCount;
+    pViewMasks = nullptr;
+    dependencyCount = copy_src->dependencyCount;
+    pViewOffsets = nullptr;
+    correlationMaskCount = copy_src->correlationMaskCount;
+    pCorrelationMasks = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pViewMasks) {
+        pViewMasks = new uint32_t[copy_src->subpassCount];
+        memcpy((void*)pViewMasks, (void*)copy_src->pViewMasks, sizeof(uint32_t) * copy_src->subpassCount);
+    }
+
+    if (copy_src->pViewOffsets) {
+        pViewOffsets = new int32_t[copy_src->dependencyCount];
+        memcpy((void*)pViewOffsets, (void*)copy_src->pViewOffsets, sizeof(int32_t) * copy_src->dependencyCount);
+    }
+
+    if (copy_src->pCorrelationMasks) {
+        pCorrelationMasks = new uint32_t[copy_src->correlationMaskCount];
+        memcpy((void*)pCorrelationMasks, (void*)copy_src->pCorrelationMasks, sizeof(uint32_t) * copy_src->correlationMaskCount);
+    }
+}
+
+safe_VkPhysicalDeviceMultiviewFeatures::safe_VkPhysicalDeviceMultiviewFeatures(const VkPhysicalDeviceMultiviewFeatures* in_struct,
+                                                                               [[maybe_unused]] PNextCopyState* copy_state,
+                                                                               bool copy_pnext)
+    : sType(in_struct->sType),
+      multiview(in_struct->multiview),
+      multiviewGeometryShader(in_struct->multiviewGeometryShader),
+      multiviewTessellationShader(in_struct->multiviewTessellationShader) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMultiviewFeatures::safe_VkPhysicalDeviceMultiviewFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES),
+      pNext(nullptr),
+      multiview(),
+      multiviewGeometryShader(),
+      multiviewTessellationShader() {}
+
+safe_VkPhysicalDeviceMultiviewFeatures::safe_VkPhysicalDeviceMultiviewFeatures(
+    const safe_VkPhysicalDeviceMultiviewFeatures& copy_src) {
+    sType = copy_src.sType;
+    multiview = copy_src.multiview;
+    multiviewGeometryShader = copy_src.multiviewGeometryShader;
+    multiviewTessellationShader = copy_src.multiviewTessellationShader;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMultiviewFeatures& safe_VkPhysicalDeviceMultiviewFeatures::operator=(
+    const safe_VkPhysicalDeviceMultiviewFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    multiview = copy_src.multiview;
+    multiviewGeometryShader = copy_src.multiviewGeometryShader;
+    multiviewTessellationShader = copy_src.multiviewTessellationShader;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMultiviewFeatures::~safe_VkPhysicalDeviceMultiviewFeatures() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceMultiviewFeatures::initialize(const VkPhysicalDeviceMultiviewFeatures* in_struct,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    multiview = in_struct->multiview;
+    multiviewGeometryShader = in_struct->multiviewGeometryShader;
+    multiviewTessellationShader = in_struct->multiviewTessellationShader;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMultiviewFeatures::initialize(const safe_VkPhysicalDeviceMultiviewFeatures* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    multiview = copy_src->multiview;
+    multiviewGeometryShader = copy_src->multiviewGeometryShader;
+    multiviewTessellationShader = copy_src->multiviewTessellationShader;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceMultiviewProperties::safe_VkPhysicalDeviceMultiviewProperties(
+    const VkPhysicalDeviceMultiviewProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      maxMultiviewViewCount(in_struct->maxMultiviewViewCount),
+      maxMultiviewInstanceIndex(in_struct->maxMultiviewInstanceIndex) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMultiviewProperties::safe_VkPhysicalDeviceMultiviewProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES),
+      pNext(nullptr),
+      maxMultiviewViewCount(),
+      maxMultiviewInstanceIndex() {}
+
+safe_VkPhysicalDeviceMultiviewProperties::safe_VkPhysicalDeviceMultiviewProperties(
+    const safe_VkPhysicalDeviceMultiviewProperties& copy_src) {
+    sType = copy_src.sType;
+    maxMultiviewViewCount = copy_src.maxMultiviewViewCount;
+    maxMultiviewInstanceIndex = copy_src.maxMultiviewInstanceIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMultiviewProperties& safe_VkPhysicalDeviceMultiviewProperties::operator=(
+    const safe_VkPhysicalDeviceMultiviewProperties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxMultiviewViewCount = copy_src.maxMultiviewViewCount;
+    maxMultiviewInstanceIndex = copy_src.maxMultiviewInstanceIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMultiviewProperties::~safe_VkPhysicalDeviceMultiviewProperties() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceMultiviewProperties::initialize(const VkPhysicalDeviceMultiviewProperties* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxMultiviewViewCount = in_struct->maxMultiviewViewCount;
+    maxMultiviewInstanceIndex = in_struct->maxMultiviewInstanceIndex;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMultiviewProperties::initialize(const safe_VkPhysicalDeviceMultiviewProperties* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxMultiviewViewCount = copy_src->maxMultiviewViewCount;
+    maxMultiviewInstanceIndex = copy_src->maxMultiviewInstanceIndex;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceVariablePointersFeatures::safe_VkPhysicalDeviceVariablePointersFeatures(
+    const VkPhysicalDeviceVariablePointersFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      variablePointersStorageBuffer(in_struct->variablePointersStorageBuffer),
+      variablePointers(in_struct->variablePointers) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceVariablePointersFeatures::safe_VkPhysicalDeviceVariablePointersFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES),
+      pNext(nullptr),
+      variablePointersStorageBuffer(),
+      variablePointers() {}
+
+safe_VkPhysicalDeviceVariablePointersFeatures::safe_VkPhysicalDeviceVariablePointersFeatures(
+    const safe_VkPhysicalDeviceVariablePointersFeatures& copy_src) {
+    sType = copy_src.sType;
+    variablePointersStorageBuffer = copy_src.variablePointersStorageBuffer;
+    variablePointers = copy_src.variablePointers;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceVariablePointersFeatures& safe_VkPhysicalDeviceVariablePointersFeatures::operator=(
+    const safe_VkPhysicalDeviceVariablePointersFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    variablePointersStorageBuffer = copy_src.variablePointersStorageBuffer;
+    variablePointers = copy_src.variablePointers;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceVariablePointersFeatures::~safe_VkPhysicalDeviceVariablePointersFeatures() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceVariablePointersFeatures::initialize(const VkPhysicalDeviceVariablePointersFeatures* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    variablePointersStorageBuffer = in_struct->variablePointersStorageBuffer;
+    variablePointers = in_struct->variablePointers;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceVariablePointersFeatures::initialize(const safe_VkPhysicalDeviceVariablePointersFeatures* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    variablePointersStorageBuffer = copy_src->variablePointersStorageBuffer;
+    variablePointers = copy_src->variablePointers;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceProtectedMemoryFeatures::safe_VkPhysicalDeviceProtectedMemoryFeatures(
+    const VkPhysicalDeviceProtectedMemoryFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), protectedMemory(in_struct->protectedMemory) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceProtectedMemoryFeatures::safe_VkPhysicalDeviceProtectedMemoryFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES), pNext(nullptr), protectedMemory() {}
+
+safe_VkPhysicalDeviceProtectedMemoryFeatures::safe_VkPhysicalDeviceProtectedMemoryFeatures(
+    const safe_VkPhysicalDeviceProtectedMemoryFeatures& copy_src) {
+    sType = copy_src.sType;
+    protectedMemory = copy_src.protectedMemory;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceProtectedMemoryFeatures& safe_VkPhysicalDeviceProtectedMemoryFeatures::operator=(
+    const safe_VkPhysicalDeviceProtectedMemoryFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    protectedMemory = copy_src.protectedMemory;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceProtectedMemoryFeatures::~safe_VkPhysicalDeviceProtectedMemoryFeatures() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceProtectedMemoryFeatures::initialize(const VkPhysicalDeviceProtectedMemoryFeatures* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    protectedMemory = in_struct->protectedMemory;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceProtectedMemoryFeatures::initialize(const safe_VkPhysicalDeviceProtectedMemoryFeatures* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    protectedMemory = copy_src->protectedMemory;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceProtectedMemoryProperties::safe_VkPhysicalDeviceProtectedMemoryProperties(
+    const VkPhysicalDeviceProtectedMemoryProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), protectedNoFault(in_struct->protectedNoFault) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceProtectedMemoryProperties::safe_VkPhysicalDeviceProtectedMemoryProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES), pNext(nullptr), protectedNoFault() {}
+
+safe_VkPhysicalDeviceProtectedMemoryProperties::safe_VkPhysicalDeviceProtectedMemoryProperties(
+    const safe_VkPhysicalDeviceProtectedMemoryProperties& copy_src) {
+    sType = copy_src.sType;
+    protectedNoFault = copy_src.protectedNoFault;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceProtectedMemoryProperties& safe_VkPhysicalDeviceProtectedMemoryProperties::operator=(
+    const safe_VkPhysicalDeviceProtectedMemoryProperties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    protectedNoFault = copy_src.protectedNoFault;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceProtectedMemoryProperties::~safe_VkPhysicalDeviceProtectedMemoryProperties() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceProtectedMemoryProperties::initialize(const VkPhysicalDeviceProtectedMemoryProperties* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    protectedNoFault = in_struct->protectedNoFault;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceProtectedMemoryProperties::initialize(const safe_VkPhysicalDeviceProtectedMemoryProperties* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    protectedNoFault = copy_src->protectedNoFault;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDeviceQueueInfo2::safe_VkDeviceQueueInfo2(const VkDeviceQueueInfo2* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                                 bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      queueFamilyIndex(in_struct->queueFamilyIndex),
+      queueIndex(in_struct->queueIndex) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDeviceQueueInfo2::safe_VkDeviceQueueInfo2()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2), pNext(nullptr), flags(), queueFamilyIndex(), queueIndex() {}
+
+safe_VkDeviceQueueInfo2::safe_VkDeviceQueueInfo2(const safe_VkDeviceQueueInfo2& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    queueFamilyIndex = copy_src.queueFamilyIndex;
+    queueIndex = copy_src.queueIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDeviceQueueInfo2& safe_VkDeviceQueueInfo2::operator=(const safe_VkDeviceQueueInfo2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    queueFamilyIndex = copy_src.queueFamilyIndex;
+    queueIndex = copy_src.queueIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDeviceQueueInfo2::~safe_VkDeviceQueueInfo2() { FreePnextChain(pNext); }
+
+void safe_VkDeviceQueueInfo2::initialize(const VkDeviceQueueInfo2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    queueFamilyIndex = in_struct->queueFamilyIndex;
+    queueIndex = in_struct->queueIndex;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDeviceQueueInfo2::initialize(const safe_VkDeviceQueueInfo2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    queueFamilyIndex = copy_src->queueFamilyIndex;
+    queueIndex = copy_src->queueIndex;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkProtectedSubmitInfo::safe_VkProtectedSubmitInfo(const VkProtectedSubmitInfo* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), protectedSubmit(in_struct->protectedSubmit) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkProtectedSubmitInfo::safe_VkProtectedSubmitInfo()
+    : sType(VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO), pNext(nullptr), protectedSubmit() {}
+
+safe_VkProtectedSubmitInfo::safe_VkProtectedSubmitInfo(const safe_VkProtectedSubmitInfo& copy_src) {
+    sType = copy_src.sType;
+    protectedSubmit = copy_src.protectedSubmit;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkProtectedSubmitInfo& safe_VkProtectedSubmitInfo::operator=(const safe_VkProtectedSubmitInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    protectedSubmit = copy_src.protectedSubmit;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkProtectedSubmitInfo::~safe_VkProtectedSubmitInfo() { FreePnextChain(pNext); }
+
+void safe_VkProtectedSubmitInfo::initialize(const VkProtectedSubmitInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    protectedSubmit = in_struct->protectedSubmit;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkProtectedSubmitInfo::initialize(const safe_VkProtectedSubmitInfo* copy_src,
+                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    protectedSubmit = copy_src->protectedSubmit;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSamplerYcbcrConversionCreateInfo::safe_VkSamplerYcbcrConversionCreateInfo(
+    const VkSamplerYcbcrConversionCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      format(in_struct->format),
+      ycbcrModel(in_struct->ycbcrModel),
+      ycbcrRange(in_struct->ycbcrRange),
+      components(in_struct->components),
+      xChromaOffset(in_struct->xChromaOffset),
+      yChromaOffset(in_struct->yChromaOffset),
+      chromaFilter(in_struct->chromaFilter),
+      forceExplicitReconstruction(in_struct->forceExplicitReconstruction) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSamplerYcbcrConversionCreateInfo::safe_VkSamplerYcbcrConversionCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO),
+      pNext(nullptr),
+      format(),
+      ycbcrModel(),
+      ycbcrRange(),
+      components(),
+      xChromaOffset(),
+      yChromaOffset(),
+      chromaFilter(),
+      forceExplicitReconstruction() {}
+
+safe_VkSamplerYcbcrConversionCreateInfo::safe_VkSamplerYcbcrConversionCreateInfo(
+    const safe_VkSamplerYcbcrConversionCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    format = copy_src.format;
+    ycbcrModel = copy_src.ycbcrModel;
+    ycbcrRange = copy_src.ycbcrRange;
+    components = copy_src.components;
+    xChromaOffset = copy_src.xChromaOffset;
+    yChromaOffset = copy_src.yChromaOffset;
+    chromaFilter = copy_src.chromaFilter;
+    forceExplicitReconstruction = copy_src.forceExplicitReconstruction;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSamplerYcbcrConversionCreateInfo& safe_VkSamplerYcbcrConversionCreateInfo::operator=(
+    const safe_VkSamplerYcbcrConversionCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    format = copy_src.format;
+    ycbcrModel = copy_src.ycbcrModel;
+    ycbcrRange = copy_src.ycbcrRange;
+    components = copy_src.components;
+    xChromaOffset = copy_src.xChromaOffset;
+    yChromaOffset = copy_src.yChromaOffset;
+    chromaFilter = copy_src.chromaFilter;
+    forceExplicitReconstruction = copy_src.forceExplicitReconstruction;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSamplerYcbcrConversionCreateInfo::~safe_VkSamplerYcbcrConversionCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkSamplerYcbcrConversionCreateInfo::initialize(const VkSamplerYcbcrConversionCreateInfo* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    format = in_struct->format;
+    ycbcrModel = in_struct->ycbcrModel;
+    ycbcrRange = in_struct->ycbcrRange;
+    components = in_struct->components;
+    xChromaOffset = in_struct->xChromaOffset;
+    yChromaOffset = in_struct->yChromaOffset;
+    chromaFilter = in_struct->chromaFilter;
+    forceExplicitReconstruction = in_struct->forceExplicitReconstruction;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSamplerYcbcrConversionCreateInfo::initialize(const safe_VkSamplerYcbcrConversionCreateInfo* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    format = copy_src->format;
+    ycbcrModel = copy_src->ycbcrModel;
+    ycbcrRange = copy_src->ycbcrRange;
+    components = copy_src->components;
+    xChromaOffset = copy_src->xChromaOffset;
+    yChromaOffset = copy_src->yChromaOffset;
+    chromaFilter = copy_src->chromaFilter;
+    forceExplicitReconstruction = copy_src->forceExplicitReconstruction;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSamplerYcbcrConversionInfo::safe_VkSamplerYcbcrConversionInfo(const VkSamplerYcbcrConversionInfo* in_struct,
+                                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), conversion(in_struct->conversion) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSamplerYcbcrConversionInfo::safe_VkSamplerYcbcrConversionInfo()
+    : sType(VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO), pNext(nullptr), conversion() {}
+
+safe_VkSamplerYcbcrConversionInfo::safe_VkSamplerYcbcrConversionInfo(const safe_VkSamplerYcbcrConversionInfo& copy_src) {
+    sType = copy_src.sType;
+    conversion = copy_src.conversion;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSamplerYcbcrConversionInfo& safe_VkSamplerYcbcrConversionInfo::operator=(const safe_VkSamplerYcbcrConversionInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    conversion = copy_src.conversion;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSamplerYcbcrConversionInfo::~safe_VkSamplerYcbcrConversionInfo() { FreePnextChain(pNext); }
+
+void safe_VkSamplerYcbcrConversionInfo::initialize(const VkSamplerYcbcrConversionInfo* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    conversion = in_struct->conversion;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSamplerYcbcrConversionInfo::initialize(const safe_VkSamplerYcbcrConversionInfo* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    conversion = copy_src->conversion;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkBindImagePlaneMemoryInfo::safe_VkBindImagePlaneMemoryInfo(const VkBindImagePlaneMemoryInfo* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), planeAspect(in_struct->planeAspect) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkBindImagePlaneMemoryInfo::safe_VkBindImagePlaneMemoryInfo()
+    : sType(VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO), pNext(nullptr), planeAspect() {}
+
+safe_VkBindImagePlaneMemoryInfo::safe_VkBindImagePlaneMemoryInfo(const safe_VkBindImagePlaneMemoryInfo& copy_src) {
+    sType = copy_src.sType;
+    planeAspect = copy_src.planeAspect;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBindImagePlaneMemoryInfo& safe_VkBindImagePlaneMemoryInfo::operator=(const safe_VkBindImagePlaneMemoryInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    planeAspect = copy_src.planeAspect;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkBindImagePlaneMemoryInfo::~safe_VkBindImagePlaneMemoryInfo() { FreePnextChain(pNext); }
+
+void safe_VkBindImagePlaneMemoryInfo::initialize(const VkBindImagePlaneMemoryInfo* in_struct,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    planeAspect = in_struct->planeAspect;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkBindImagePlaneMemoryInfo::initialize(const safe_VkBindImagePlaneMemoryInfo* copy_src,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    planeAspect = copy_src->planeAspect;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkImagePlaneMemoryRequirementsInfo::safe_VkImagePlaneMemoryRequirementsInfo(
+    const VkImagePlaneMemoryRequirementsInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), planeAspect(in_struct->planeAspect) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImagePlaneMemoryRequirementsInfo::safe_VkImagePlaneMemoryRequirementsInfo()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO), pNext(nullptr), planeAspect() {}
+
+safe_VkImagePlaneMemoryRequirementsInfo::safe_VkImagePlaneMemoryRequirementsInfo(
+    const safe_VkImagePlaneMemoryRequirementsInfo& copy_src) {
+    sType = copy_src.sType;
+    planeAspect = copy_src.planeAspect;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImagePlaneMemoryRequirementsInfo& safe_VkImagePlaneMemoryRequirementsInfo::operator=(
+    const safe_VkImagePlaneMemoryRequirementsInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    planeAspect = copy_src.planeAspect;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImagePlaneMemoryRequirementsInfo::~safe_VkImagePlaneMemoryRequirementsInfo() { FreePnextChain(pNext); }
+
+void safe_VkImagePlaneMemoryRequirementsInfo::initialize(const VkImagePlaneMemoryRequirementsInfo* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    planeAspect = in_struct->planeAspect;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImagePlaneMemoryRequirementsInfo::initialize(const safe_VkImagePlaneMemoryRequirementsInfo* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    planeAspect = copy_src->planeAspect;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures::safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
+    const VkPhysicalDeviceSamplerYcbcrConversionFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), samplerYcbcrConversion(in_struct->samplerYcbcrConversion) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures::safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES), pNext(nullptr), samplerYcbcrConversion() {}
+
+safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures::safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
+    const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures& copy_src) {
+    sType = copy_src.sType;
+    samplerYcbcrConversion = copy_src.samplerYcbcrConversion;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures& safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures::operator=(
+    const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    samplerYcbcrConversion = copy_src.samplerYcbcrConversion;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures::~safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures::initialize(
+    const VkPhysicalDeviceSamplerYcbcrConversionFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    samplerYcbcrConversion = in_struct->samplerYcbcrConversion;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures::initialize(
+    const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    samplerYcbcrConversion = copy_src->samplerYcbcrConversion;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSamplerYcbcrConversionImageFormatProperties::safe_VkSamplerYcbcrConversionImageFormatProperties(
+    const VkSamplerYcbcrConversionImageFormatProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), combinedImageSamplerDescriptorCount(in_struct->combinedImageSamplerDescriptorCount) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSamplerYcbcrConversionImageFormatProperties::safe_VkSamplerYcbcrConversionImageFormatProperties()
+    : sType(VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES),
+      pNext(nullptr),
+      combinedImageSamplerDescriptorCount() {}
+
+safe_VkSamplerYcbcrConversionImageFormatProperties::safe_VkSamplerYcbcrConversionImageFormatProperties(
+    const safe_VkSamplerYcbcrConversionImageFormatProperties& copy_src) {
+    sType = copy_src.sType;
+    combinedImageSamplerDescriptorCount = copy_src.combinedImageSamplerDescriptorCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSamplerYcbcrConversionImageFormatProperties& safe_VkSamplerYcbcrConversionImageFormatProperties::operator=(
+    const safe_VkSamplerYcbcrConversionImageFormatProperties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    combinedImageSamplerDescriptorCount = copy_src.combinedImageSamplerDescriptorCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSamplerYcbcrConversionImageFormatProperties::~safe_VkSamplerYcbcrConversionImageFormatProperties() { FreePnextChain(pNext); }
+
+void safe_VkSamplerYcbcrConversionImageFormatProperties::initialize(const VkSamplerYcbcrConversionImageFormatProperties* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    combinedImageSamplerDescriptorCount = in_struct->combinedImageSamplerDescriptorCount;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSamplerYcbcrConversionImageFormatProperties::initialize(
+    const safe_VkSamplerYcbcrConversionImageFormatProperties* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    combinedImageSamplerDescriptorCount = copy_src->combinedImageSamplerDescriptorCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDescriptorUpdateTemplateCreateInfo::safe_VkDescriptorUpdateTemplateCreateInfo(
+    const VkDescriptorUpdateTemplateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      descriptorUpdateEntryCount(in_struct->descriptorUpdateEntryCount),
+      pDescriptorUpdateEntries(nullptr),
+      templateType(in_struct->templateType),
+      descriptorSetLayout(in_struct->descriptorSetLayout),
+      pipelineBindPoint(in_struct->pipelineBindPoint),
+      pipelineLayout(in_struct->pipelineLayout),
+      set(in_struct->set) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pDescriptorUpdateEntries) {
+        pDescriptorUpdateEntries = new VkDescriptorUpdateTemplateEntry[in_struct->descriptorUpdateEntryCount];
+        memcpy((void*)pDescriptorUpdateEntries, (void*)in_struct->pDescriptorUpdateEntries,
+               sizeof(VkDescriptorUpdateTemplateEntry) * in_struct->descriptorUpdateEntryCount);
+    }
+}
+
+safe_VkDescriptorUpdateTemplateCreateInfo::safe_VkDescriptorUpdateTemplateCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      descriptorUpdateEntryCount(),
+      pDescriptorUpdateEntries(nullptr),
+      templateType(),
+      descriptorSetLayout(),
+      pipelineBindPoint(),
+      pipelineLayout(),
+      set() {}
+
+safe_VkDescriptorUpdateTemplateCreateInfo::safe_VkDescriptorUpdateTemplateCreateInfo(
+    const safe_VkDescriptorUpdateTemplateCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    descriptorUpdateEntryCount = copy_src.descriptorUpdateEntryCount;
+    pDescriptorUpdateEntries = nullptr;
+    templateType = copy_src.templateType;
+    descriptorSetLayout = copy_src.descriptorSetLayout;
+    pipelineBindPoint = copy_src.pipelineBindPoint;
+    pipelineLayout = copy_src.pipelineLayout;
+    set = copy_src.set;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDescriptorUpdateEntries) {
+        pDescriptorUpdateEntries = new VkDescriptorUpdateTemplateEntry[copy_src.descriptorUpdateEntryCount];
+        memcpy((void*)pDescriptorUpdateEntries, (void*)copy_src.pDescriptorUpdateEntries,
+               sizeof(VkDescriptorUpdateTemplateEntry) * copy_src.descriptorUpdateEntryCount);
+    }
+}
+
+safe_VkDescriptorUpdateTemplateCreateInfo& safe_VkDescriptorUpdateTemplateCreateInfo::operator=(
+    const safe_VkDescriptorUpdateTemplateCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pDescriptorUpdateEntries) delete[] pDescriptorUpdateEntries;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    descriptorUpdateEntryCount = copy_src.descriptorUpdateEntryCount;
+    pDescriptorUpdateEntries = nullptr;
+    templateType = copy_src.templateType;
+    descriptorSetLayout = copy_src.descriptorSetLayout;
+    pipelineBindPoint = copy_src.pipelineBindPoint;
+    pipelineLayout = copy_src.pipelineLayout;
+    set = copy_src.set;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDescriptorUpdateEntries) {
+        pDescriptorUpdateEntries = new VkDescriptorUpdateTemplateEntry[copy_src.descriptorUpdateEntryCount];
+        memcpy((void*)pDescriptorUpdateEntries, (void*)copy_src.pDescriptorUpdateEntries,
+               sizeof(VkDescriptorUpdateTemplateEntry) * copy_src.descriptorUpdateEntryCount);
+    }
+
+    return *this;
+}
+
+safe_VkDescriptorUpdateTemplateCreateInfo::~safe_VkDescriptorUpdateTemplateCreateInfo() {
+    if (pDescriptorUpdateEntries) delete[] pDescriptorUpdateEntries;
+    FreePnextChain(pNext);
+}
+
+void safe_VkDescriptorUpdateTemplateCreateInfo::initialize(const VkDescriptorUpdateTemplateCreateInfo* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pDescriptorUpdateEntries) delete[] pDescriptorUpdateEntries;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    descriptorUpdateEntryCount = in_struct->descriptorUpdateEntryCount;
+    pDescriptorUpdateEntries = nullptr;
+    templateType = in_struct->templateType;
+    descriptorSetLayout = in_struct->descriptorSetLayout;
+    pipelineBindPoint = in_struct->pipelineBindPoint;
+    pipelineLayout = in_struct->pipelineLayout;
+    set = in_struct->set;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pDescriptorUpdateEntries) {
+        pDescriptorUpdateEntries = new VkDescriptorUpdateTemplateEntry[in_struct->descriptorUpdateEntryCount];
+        memcpy((void*)pDescriptorUpdateEntries, (void*)in_struct->pDescriptorUpdateEntries,
+               sizeof(VkDescriptorUpdateTemplateEntry) * in_struct->descriptorUpdateEntryCount);
+    }
+}
+
+void safe_VkDescriptorUpdateTemplateCreateInfo::initialize(const safe_VkDescriptorUpdateTemplateCreateInfo* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    descriptorUpdateEntryCount = copy_src->descriptorUpdateEntryCount;
+    pDescriptorUpdateEntries = nullptr;
+    templateType = copy_src->templateType;
+    descriptorSetLayout = copy_src->descriptorSetLayout;
+    pipelineBindPoint = copy_src->pipelineBindPoint;
+    pipelineLayout = copy_src->pipelineLayout;
+    set = copy_src->set;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pDescriptorUpdateEntries) {
+        pDescriptorUpdateEntries = new VkDescriptorUpdateTemplateEntry[copy_src->descriptorUpdateEntryCount];
+        memcpy((void*)pDescriptorUpdateEntries, (void*)copy_src->pDescriptorUpdateEntries,
+               sizeof(VkDescriptorUpdateTemplateEntry) * copy_src->descriptorUpdateEntryCount);
+    }
+}
+
+safe_VkPhysicalDeviceExternalImageFormatInfo::safe_VkPhysicalDeviceExternalImageFormatInfo(
+    const VkPhysicalDeviceExternalImageFormatInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), handleType(in_struct->handleType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceExternalImageFormatInfo::safe_VkPhysicalDeviceExternalImageFormatInfo()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO), pNext(nullptr), handleType() {}
+
+safe_VkPhysicalDeviceExternalImageFormatInfo::safe_VkPhysicalDeviceExternalImageFormatInfo(
+    const safe_VkPhysicalDeviceExternalImageFormatInfo& copy_src) {
+    sType = copy_src.sType;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceExternalImageFormatInfo& safe_VkPhysicalDeviceExternalImageFormatInfo::operator=(
+    const safe_VkPhysicalDeviceExternalImageFormatInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceExternalImageFormatInfo::~safe_VkPhysicalDeviceExternalImageFormatInfo() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceExternalImageFormatInfo::initialize(const VkPhysicalDeviceExternalImageFormatInfo* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    handleType = in_struct->handleType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceExternalImageFormatInfo::initialize(const safe_VkPhysicalDeviceExternalImageFormatInfo* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    handleType = copy_src->handleType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkExternalImageFormatProperties::safe_VkExternalImageFormatProperties(const VkExternalImageFormatProperties* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), externalMemoryProperties(in_struct->externalMemoryProperties) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkExternalImageFormatProperties::safe_VkExternalImageFormatProperties()
+    : sType(VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES), pNext(nullptr), externalMemoryProperties() {}
+
+safe_VkExternalImageFormatProperties::safe_VkExternalImageFormatProperties(const safe_VkExternalImageFormatProperties& copy_src) {
+    sType = copy_src.sType;
+    externalMemoryProperties = copy_src.externalMemoryProperties;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkExternalImageFormatProperties& safe_VkExternalImageFormatProperties::operator=(
+    const safe_VkExternalImageFormatProperties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    externalMemoryProperties = copy_src.externalMemoryProperties;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkExternalImageFormatProperties::~safe_VkExternalImageFormatProperties() { FreePnextChain(pNext); }
+
+void safe_VkExternalImageFormatProperties::initialize(const VkExternalImageFormatProperties* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    externalMemoryProperties = in_struct->externalMemoryProperties;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkExternalImageFormatProperties::initialize(const safe_VkExternalImageFormatProperties* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    externalMemoryProperties = copy_src->externalMemoryProperties;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceExternalBufferInfo::safe_VkPhysicalDeviceExternalBufferInfo(
+    const VkPhysicalDeviceExternalBufferInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags), usage(in_struct->usage), handleType(in_struct->handleType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceExternalBufferInfo::safe_VkPhysicalDeviceExternalBufferInfo()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO), pNext(nullptr), flags(), usage(), handleType() {}
+
+safe_VkPhysicalDeviceExternalBufferInfo::safe_VkPhysicalDeviceExternalBufferInfo(
+    const safe_VkPhysicalDeviceExternalBufferInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    usage = copy_src.usage;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceExternalBufferInfo& safe_VkPhysicalDeviceExternalBufferInfo::operator=(
+    const safe_VkPhysicalDeviceExternalBufferInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    usage = copy_src.usage;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceExternalBufferInfo::~safe_VkPhysicalDeviceExternalBufferInfo() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceExternalBufferInfo::initialize(const VkPhysicalDeviceExternalBufferInfo* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    usage = in_struct->usage;
+    handleType = in_struct->handleType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceExternalBufferInfo::initialize(const safe_VkPhysicalDeviceExternalBufferInfo* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    usage = copy_src->usage;
+    handleType = copy_src->handleType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkExternalBufferProperties::safe_VkExternalBufferProperties(const VkExternalBufferProperties* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), externalMemoryProperties(in_struct->externalMemoryProperties) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkExternalBufferProperties::safe_VkExternalBufferProperties()
+    : sType(VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES), pNext(nullptr), externalMemoryProperties() {}
+
+safe_VkExternalBufferProperties::safe_VkExternalBufferProperties(const safe_VkExternalBufferProperties& copy_src) {
+    sType = copy_src.sType;
+    externalMemoryProperties = copy_src.externalMemoryProperties;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkExternalBufferProperties& safe_VkExternalBufferProperties::operator=(const safe_VkExternalBufferProperties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    externalMemoryProperties = copy_src.externalMemoryProperties;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkExternalBufferProperties::~safe_VkExternalBufferProperties() { FreePnextChain(pNext); }
+
+void safe_VkExternalBufferProperties::initialize(const VkExternalBufferProperties* in_struct,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    externalMemoryProperties = in_struct->externalMemoryProperties;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkExternalBufferProperties::initialize(const safe_VkExternalBufferProperties* copy_src,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    externalMemoryProperties = copy_src->externalMemoryProperties;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceIDProperties::safe_VkPhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties* in_struct,
+                                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), deviceNodeMask(in_struct->deviceNodeMask), deviceLUIDValid(in_struct->deviceLUIDValid) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        deviceUUID[i] = in_struct->deviceUUID[i];
+    }
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        driverUUID[i] = in_struct->driverUUID[i];
+    }
+
+    for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) {
+        deviceLUID[i] = in_struct->deviceLUID[i];
+    }
+}
+
+safe_VkPhysicalDeviceIDProperties::safe_VkPhysicalDeviceIDProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES), pNext(nullptr), deviceNodeMask(), deviceLUIDValid() {}
+
+safe_VkPhysicalDeviceIDProperties::safe_VkPhysicalDeviceIDProperties(const safe_VkPhysicalDeviceIDProperties& copy_src) {
+    sType = copy_src.sType;
+    deviceNodeMask = copy_src.deviceNodeMask;
+    deviceLUIDValid = copy_src.deviceLUIDValid;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        deviceUUID[i] = copy_src.deviceUUID[i];
+    }
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        driverUUID[i] = copy_src.driverUUID[i];
+    }
+
+    for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) {
+        deviceLUID[i] = copy_src.deviceLUID[i];
+    }
+}
+
+safe_VkPhysicalDeviceIDProperties& safe_VkPhysicalDeviceIDProperties::operator=(const safe_VkPhysicalDeviceIDProperties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    deviceNodeMask = copy_src.deviceNodeMask;
+    deviceLUIDValid = copy_src.deviceLUIDValid;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        deviceUUID[i] = copy_src.deviceUUID[i];
+    }
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        driverUUID[i] = copy_src.driverUUID[i];
+    }
+
+    for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) {
+        deviceLUID[i] = copy_src.deviceLUID[i];
+    }
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceIDProperties::~safe_VkPhysicalDeviceIDProperties() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceIDProperties::initialize(const VkPhysicalDeviceIDProperties* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    deviceNodeMask = in_struct->deviceNodeMask;
+    deviceLUIDValid = in_struct->deviceLUIDValid;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        deviceUUID[i] = in_struct->deviceUUID[i];
+    }
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        driverUUID[i] = in_struct->driverUUID[i];
+    }
+
+    for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) {
+        deviceLUID[i] = in_struct->deviceLUID[i];
+    }
+}
+
+void safe_VkPhysicalDeviceIDProperties::initialize(const safe_VkPhysicalDeviceIDProperties* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    deviceNodeMask = copy_src->deviceNodeMask;
+    deviceLUIDValid = copy_src->deviceLUIDValid;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        deviceUUID[i] = copy_src->deviceUUID[i];
+    }
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        driverUUID[i] = copy_src->driverUUID[i];
+    }
+
+    for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) {
+        deviceLUID[i] = copy_src->deviceLUID[i];
+    }
+}
+
+safe_VkExternalMemoryImageCreateInfo::safe_VkExternalMemoryImageCreateInfo(const VkExternalMemoryImageCreateInfo* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), handleTypes(in_struct->handleTypes) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkExternalMemoryImageCreateInfo::safe_VkExternalMemoryImageCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO), pNext(nullptr), handleTypes() {}
+
+safe_VkExternalMemoryImageCreateInfo::safe_VkExternalMemoryImageCreateInfo(const safe_VkExternalMemoryImageCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    handleTypes = copy_src.handleTypes;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkExternalMemoryImageCreateInfo& safe_VkExternalMemoryImageCreateInfo::operator=(
+    const safe_VkExternalMemoryImageCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    handleTypes = copy_src.handleTypes;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkExternalMemoryImageCreateInfo::~safe_VkExternalMemoryImageCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkExternalMemoryImageCreateInfo::initialize(const VkExternalMemoryImageCreateInfo* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    handleTypes = in_struct->handleTypes;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkExternalMemoryImageCreateInfo::initialize(const safe_VkExternalMemoryImageCreateInfo* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    handleTypes = copy_src->handleTypes;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkExternalMemoryBufferCreateInfo::safe_VkExternalMemoryBufferCreateInfo(const VkExternalMemoryBufferCreateInfo* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType), handleTypes(in_struct->handleTypes) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkExternalMemoryBufferCreateInfo::safe_VkExternalMemoryBufferCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO), pNext(nullptr), handleTypes() {}
+
+safe_VkExternalMemoryBufferCreateInfo::safe_VkExternalMemoryBufferCreateInfo(
+    const safe_VkExternalMemoryBufferCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    handleTypes = copy_src.handleTypes;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkExternalMemoryBufferCreateInfo& safe_VkExternalMemoryBufferCreateInfo::operator=(
+    const safe_VkExternalMemoryBufferCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    handleTypes = copy_src.handleTypes;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkExternalMemoryBufferCreateInfo::~safe_VkExternalMemoryBufferCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkExternalMemoryBufferCreateInfo::initialize(const VkExternalMemoryBufferCreateInfo* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    handleTypes = in_struct->handleTypes;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkExternalMemoryBufferCreateInfo::initialize(const safe_VkExternalMemoryBufferCreateInfo* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    handleTypes = copy_src->handleTypes;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkExportMemoryAllocateInfo::safe_VkExportMemoryAllocateInfo(const VkExportMemoryAllocateInfo* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), handleTypes(in_struct->handleTypes) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkExportMemoryAllocateInfo::safe_VkExportMemoryAllocateInfo()
+    : sType(VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO), pNext(nullptr), handleTypes() {}
+
+safe_VkExportMemoryAllocateInfo::safe_VkExportMemoryAllocateInfo(const safe_VkExportMemoryAllocateInfo& copy_src) {
+    sType = copy_src.sType;
+    handleTypes = copy_src.handleTypes;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkExportMemoryAllocateInfo& safe_VkExportMemoryAllocateInfo::operator=(const safe_VkExportMemoryAllocateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    handleTypes = copy_src.handleTypes;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkExportMemoryAllocateInfo::~safe_VkExportMemoryAllocateInfo() { FreePnextChain(pNext); }
+
+void safe_VkExportMemoryAllocateInfo::initialize(const VkExportMemoryAllocateInfo* in_struct,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    handleTypes = in_struct->handleTypes;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkExportMemoryAllocateInfo::initialize(const safe_VkExportMemoryAllocateInfo* copy_src,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    handleTypes = copy_src->handleTypes;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceExternalFenceInfo::safe_VkPhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo* in_struct,
+                                                                               [[maybe_unused]] PNextCopyState* copy_state,
+                                                                               bool copy_pnext)
+    : sType(in_struct->sType), handleType(in_struct->handleType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceExternalFenceInfo::safe_VkPhysicalDeviceExternalFenceInfo()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO), pNext(nullptr), handleType() {}
+
+safe_VkPhysicalDeviceExternalFenceInfo::safe_VkPhysicalDeviceExternalFenceInfo(
+    const safe_VkPhysicalDeviceExternalFenceInfo& copy_src) {
+    sType = copy_src.sType;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceExternalFenceInfo& safe_VkPhysicalDeviceExternalFenceInfo::operator=(
+    const safe_VkPhysicalDeviceExternalFenceInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceExternalFenceInfo::~safe_VkPhysicalDeviceExternalFenceInfo() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceExternalFenceInfo::initialize(const VkPhysicalDeviceExternalFenceInfo* in_struct,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    handleType = in_struct->handleType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceExternalFenceInfo::initialize(const safe_VkPhysicalDeviceExternalFenceInfo* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    handleType = copy_src->handleType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkExternalFenceProperties::safe_VkExternalFenceProperties(const VkExternalFenceProperties* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      exportFromImportedHandleTypes(in_struct->exportFromImportedHandleTypes),
+      compatibleHandleTypes(in_struct->compatibleHandleTypes),
+      externalFenceFeatures(in_struct->externalFenceFeatures) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkExternalFenceProperties::safe_VkExternalFenceProperties()
+    : sType(VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES),
+      pNext(nullptr),
+      exportFromImportedHandleTypes(),
+      compatibleHandleTypes(),
+      externalFenceFeatures() {}
+
+safe_VkExternalFenceProperties::safe_VkExternalFenceProperties(const safe_VkExternalFenceProperties& copy_src) {
+    sType = copy_src.sType;
+    exportFromImportedHandleTypes = copy_src.exportFromImportedHandleTypes;
+    compatibleHandleTypes = copy_src.compatibleHandleTypes;
+    externalFenceFeatures = copy_src.externalFenceFeatures;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkExternalFenceProperties& safe_VkExternalFenceProperties::operator=(const safe_VkExternalFenceProperties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    exportFromImportedHandleTypes = copy_src.exportFromImportedHandleTypes;
+    compatibleHandleTypes = copy_src.compatibleHandleTypes;
+    externalFenceFeatures = copy_src.externalFenceFeatures;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkExternalFenceProperties::~safe_VkExternalFenceProperties() { FreePnextChain(pNext); }
+
+void safe_VkExternalFenceProperties::initialize(const VkExternalFenceProperties* in_struct,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    exportFromImportedHandleTypes = in_struct->exportFromImportedHandleTypes;
+    compatibleHandleTypes = in_struct->compatibleHandleTypes;
+    externalFenceFeatures = in_struct->externalFenceFeatures;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkExternalFenceProperties::initialize(const safe_VkExternalFenceProperties* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    exportFromImportedHandleTypes = copy_src->exportFromImportedHandleTypes;
+    compatibleHandleTypes = copy_src->compatibleHandleTypes;
+    externalFenceFeatures = copy_src->externalFenceFeatures;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkExportFenceCreateInfo::safe_VkExportFenceCreateInfo(const VkExportFenceCreateInfo* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), handleTypes(in_struct->handleTypes) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkExportFenceCreateInfo::safe_VkExportFenceCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO), pNext(nullptr), handleTypes() {}
+
+safe_VkExportFenceCreateInfo::safe_VkExportFenceCreateInfo(const safe_VkExportFenceCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    handleTypes = copy_src.handleTypes;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkExportFenceCreateInfo& safe_VkExportFenceCreateInfo::operator=(const safe_VkExportFenceCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    handleTypes = copy_src.handleTypes;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkExportFenceCreateInfo::~safe_VkExportFenceCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkExportFenceCreateInfo::initialize(const VkExportFenceCreateInfo* in_struct,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    handleTypes = in_struct->handleTypes;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkExportFenceCreateInfo::initialize(const safe_VkExportFenceCreateInfo* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    handleTypes = copy_src->handleTypes;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkExportSemaphoreCreateInfo::safe_VkExportSemaphoreCreateInfo(const VkExportSemaphoreCreateInfo* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), handleTypes(in_struct->handleTypes) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkExportSemaphoreCreateInfo::safe_VkExportSemaphoreCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO), pNext(nullptr), handleTypes() {}
+
+safe_VkExportSemaphoreCreateInfo::safe_VkExportSemaphoreCreateInfo(const safe_VkExportSemaphoreCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    handleTypes = copy_src.handleTypes;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkExportSemaphoreCreateInfo& safe_VkExportSemaphoreCreateInfo::operator=(const safe_VkExportSemaphoreCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    handleTypes = copy_src.handleTypes;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkExportSemaphoreCreateInfo::~safe_VkExportSemaphoreCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkExportSemaphoreCreateInfo::initialize(const VkExportSemaphoreCreateInfo* in_struct,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    handleTypes = in_struct->handleTypes;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkExportSemaphoreCreateInfo::initialize(const safe_VkExportSemaphoreCreateInfo* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    handleTypes = copy_src->handleTypes;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceExternalSemaphoreInfo::safe_VkPhysicalDeviceExternalSemaphoreInfo(
+    const VkPhysicalDeviceExternalSemaphoreInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), handleType(in_struct->handleType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceExternalSemaphoreInfo::safe_VkPhysicalDeviceExternalSemaphoreInfo()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO), pNext(nullptr), handleType() {}
+
+safe_VkPhysicalDeviceExternalSemaphoreInfo::safe_VkPhysicalDeviceExternalSemaphoreInfo(
+    const safe_VkPhysicalDeviceExternalSemaphoreInfo& copy_src) {
+    sType = copy_src.sType;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceExternalSemaphoreInfo& safe_VkPhysicalDeviceExternalSemaphoreInfo::operator=(
+    const safe_VkPhysicalDeviceExternalSemaphoreInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceExternalSemaphoreInfo::~safe_VkPhysicalDeviceExternalSemaphoreInfo() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceExternalSemaphoreInfo::initialize(const VkPhysicalDeviceExternalSemaphoreInfo* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    handleType = in_struct->handleType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceExternalSemaphoreInfo::initialize(const safe_VkPhysicalDeviceExternalSemaphoreInfo* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    handleType = copy_src->handleType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkExternalSemaphoreProperties::safe_VkExternalSemaphoreProperties(const VkExternalSemaphoreProperties* in_struct,
+                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      exportFromImportedHandleTypes(in_struct->exportFromImportedHandleTypes),
+      compatibleHandleTypes(in_struct->compatibleHandleTypes),
+      externalSemaphoreFeatures(in_struct->externalSemaphoreFeatures) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkExternalSemaphoreProperties::safe_VkExternalSemaphoreProperties()
+    : sType(VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES),
+      pNext(nullptr),
+      exportFromImportedHandleTypes(),
+      compatibleHandleTypes(),
+      externalSemaphoreFeatures() {}
+
+safe_VkExternalSemaphoreProperties::safe_VkExternalSemaphoreProperties(const safe_VkExternalSemaphoreProperties& copy_src) {
+    sType = copy_src.sType;
+    exportFromImportedHandleTypes = copy_src.exportFromImportedHandleTypes;
+    compatibleHandleTypes = copy_src.compatibleHandleTypes;
+    externalSemaphoreFeatures = copy_src.externalSemaphoreFeatures;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkExternalSemaphoreProperties& safe_VkExternalSemaphoreProperties::operator=(
+    const safe_VkExternalSemaphoreProperties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    exportFromImportedHandleTypes = copy_src.exportFromImportedHandleTypes;
+    compatibleHandleTypes = copy_src.compatibleHandleTypes;
+    externalSemaphoreFeatures = copy_src.externalSemaphoreFeatures;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkExternalSemaphoreProperties::~safe_VkExternalSemaphoreProperties() { FreePnextChain(pNext); }
+
+void safe_VkExternalSemaphoreProperties::initialize(const VkExternalSemaphoreProperties* in_struct,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    exportFromImportedHandleTypes = in_struct->exportFromImportedHandleTypes;
+    compatibleHandleTypes = in_struct->compatibleHandleTypes;
+    externalSemaphoreFeatures = in_struct->externalSemaphoreFeatures;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkExternalSemaphoreProperties::initialize(const safe_VkExternalSemaphoreProperties* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    exportFromImportedHandleTypes = copy_src->exportFromImportedHandleTypes;
+    compatibleHandleTypes = copy_src->compatibleHandleTypes;
+    externalSemaphoreFeatures = copy_src->externalSemaphoreFeatures;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceMaintenance3Properties::safe_VkPhysicalDeviceMaintenance3Properties(
+    const VkPhysicalDeviceMaintenance3Properties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      maxPerSetDescriptors(in_struct->maxPerSetDescriptors),
+      maxMemoryAllocationSize(in_struct->maxMemoryAllocationSize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMaintenance3Properties::safe_VkPhysicalDeviceMaintenance3Properties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES),
+      pNext(nullptr),
+      maxPerSetDescriptors(),
+      maxMemoryAllocationSize() {}
+
+safe_VkPhysicalDeviceMaintenance3Properties::safe_VkPhysicalDeviceMaintenance3Properties(
+    const safe_VkPhysicalDeviceMaintenance3Properties& copy_src) {
+    sType = copy_src.sType;
+    maxPerSetDescriptors = copy_src.maxPerSetDescriptors;
+    maxMemoryAllocationSize = copy_src.maxMemoryAllocationSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMaintenance3Properties& safe_VkPhysicalDeviceMaintenance3Properties::operator=(
+    const safe_VkPhysicalDeviceMaintenance3Properties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxPerSetDescriptors = copy_src.maxPerSetDescriptors;
+    maxMemoryAllocationSize = copy_src.maxMemoryAllocationSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMaintenance3Properties::~safe_VkPhysicalDeviceMaintenance3Properties() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceMaintenance3Properties::initialize(const VkPhysicalDeviceMaintenance3Properties* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxPerSetDescriptors = in_struct->maxPerSetDescriptors;
+    maxMemoryAllocationSize = in_struct->maxMemoryAllocationSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMaintenance3Properties::initialize(const safe_VkPhysicalDeviceMaintenance3Properties* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxPerSetDescriptors = copy_src->maxPerSetDescriptors;
+    maxMemoryAllocationSize = copy_src->maxMemoryAllocationSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDescriptorSetLayoutSupport::safe_VkDescriptorSetLayoutSupport(const VkDescriptorSetLayoutSupport* in_struct,
+                                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), supported(in_struct->supported) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDescriptorSetLayoutSupport::safe_VkDescriptorSetLayoutSupport()
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT), pNext(nullptr), supported() {}
+
+safe_VkDescriptorSetLayoutSupport::safe_VkDescriptorSetLayoutSupport(const safe_VkDescriptorSetLayoutSupport& copy_src) {
+    sType = copy_src.sType;
+    supported = copy_src.supported;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDescriptorSetLayoutSupport& safe_VkDescriptorSetLayoutSupport::operator=(const safe_VkDescriptorSetLayoutSupport& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    supported = copy_src.supported;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDescriptorSetLayoutSupport::~safe_VkDescriptorSetLayoutSupport() { FreePnextChain(pNext); }
+
+void safe_VkDescriptorSetLayoutSupport::initialize(const VkDescriptorSetLayoutSupport* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    supported = in_struct->supported;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDescriptorSetLayoutSupport::initialize(const safe_VkDescriptorSetLayoutSupport* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    supported = copy_src->supported;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceShaderDrawParametersFeatures::safe_VkPhysicalDeviceShaderDrawParametersFeatures(
+    const VkPhysicalDeviceShaderDrawParametersFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), shaderDrawParameters(in_struct->shaderDrawParameters) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderDrawParametersFeatures::safe_VkPhysicalDeviceShaderDrawParametersFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES), pNext(nullptr), shaderDrawParameters() {}
+
+safe_VkPhysicalDeviceShaderDrawParametersFeatures::safe_VkPhysicalDeviceShaderDrawParametersFeatures(
+    const safe_VkPhysicalDeviceShaderDrawParametersFeatures& copy_src) {
+    sType = copy_src.sType;
+    shaderDrawParameters = copy_src.shaderDrawParameters;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderDrawParametersFeatures& safe_VkPhysicalDeviceShaderDrawParametersFeatures::operator=(
+    const safe_VkPhysicalDeviceShaderDrawParametersFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderDrawParameters = copy_src.shaderDrawParameters;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderDrawParametersFeatures::~safe_VkPhysicalDeviceShaderDrawParametersFeatures() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceShaderDrawParametersFeatures::initialize(const VkPhysicalDeviceShaderDrawParametersFeatures* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderDrawParameters = in_struct->shaderDrawParameters;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderDrawParametersFeatures::initialize(
+    const safe_VkPhysicalDeviceShaderDrawParametersFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderDrawParameters = copy_src->shaderDrawParameters;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceVulkan11Features::safe_VkPhysicalDeviceVulkan11Features(const VkPhysicalDeviceVulkan11Features* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType),
+      storageBuffer16BitAccess(in_struct->storageBuffer16BitAccess),
+      uniformAndStorageBuffer16BitAccess(in_struct->uniformAndStorageBuffer16BitAccess),
+      storagePushConstant16(in_struct->storagePushConstant16),
+      storageInputOutput16(in_struct->storageInputOutput16),
+      multiview(in_struct->multiview),
+      multiviewGeometryShader(in_struct->multiviewGeometryShader),
+      multiviewTessellationShader(in_struct->multiviewTessellationShader),
+      variablePointersStorageBuffer(in_struct->variablePointersStorageBuffer),
+      variablePointers(in_struct->variablePointers),
+      protectedMemory(in_struct->protectedMemory),
+      samplerYcbcrConversion(in_struct->samplerYcbcrConversion),
+      shaderDrawParameters(in_struct->shaderDrawParameters) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceVulkan11Features::safe_VkPhysicalDeviceVulkan11Features()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES),
+      pNext(nullptr),
+      storageBuffer16BitAccess(),
+      uniformAndStorageBuffer16BitAccess(),
+      storagePushConstant16(),
+      storageInputOutput16(),
+      multiview(),
+      multiviewGeometryShader(),
+      multiviewTessellationShader(),
+      variablePointersStorageBuffer(),
+      variablePointers(),
+      protectedMemory(),
+      samplerYcbcrConversion(),
+      shaderDrawParameters() {}
+
+safe_VkPhysicalDeviceVulkan11Features::safe_VkPhysicalDeviceVulkan11Features(
+    const safe_VkPhysicalDeviceVulkan11Features& copy_src) {
+    sType = copy_src.sType;
+    storageBuffer16BitAccess = copy_src.storageBuffer16BitAccess;
+    uniformAndStorageBuffer16BitAccess = copy_src.uniformAndStorageBuffer16BitAccess;
+    storagePushConstant16 = copy_src.storagePushConstant16;
+    storageInputOutput16 = copy_src.storageInputOutput16;
+    multiview = copy_src.multiview;
+    multiviewGeometryShader = copy_src.multiviewGeometryShader;
+    multiviewTessellationShader = copy_src.multiviewTessellationShader;
+    variablePointersStorageBuffer = copy_src.variablePointersStorageBuffer;
+    variablePointers = copy_src.variablePointers;
+    protectedMemory = copy_src.protectedMemory;
+    samplerYcbcrConversion = copy_src.samplerYcbcrConversion;
+    shaderDrawParameters = copy_src.shaderDrawParameters;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceVulkan11Features& safe_VkPhysicalDeviceVulkan11Features::operator=(
+    const safe_VkPhysicalDeviceVulkan11Features& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    storageBuffer16BitAccess = copy_src.storageBuffer16BitAccess;
+    uniformAndStorageBuffer16BitAccess = copy_src.uniformAndStorageBuffer16BitAccess;
+    storagePushConstant16 = copy_src.storagePushConstant16;
+    storageInputOutput16 = copy_src.storageInputOutput16;
+    multiview = copy_src.multiview;
+    multiviewGeometryShader = copy_src.multiviewGeometryShader;
+    multiviewTessellationShader = copy_src.multiviewTessellationShader;
+    variablePointersStorageBuffer = copy_src.variablePointersStorageBuffer;
+    variablePointers = copy_src.variablePointers;
+    protectedMemory = copy_src.protectedMemory;
+    samplerYcbcrConversion = copy_src.samplerYcbcrConversion;
+    shaderDrawParameters = copy_src.shaderDrawParameters;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceVulkan11Features::~safe_VkPhysicalDeviceVulkan11Features() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceVulkan11Features::initialize(const VkPhysicalDeviceVulkan11Features* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    storageBuffer16BitAccess = in_struct->storageBuffer16BitAccess;
+    uniformAndStorageBuffer16BitAccess = in_struct->uniformAndStorageBuffer16BitAccess;
+    storagePushConstant16 = in_struct->storagePushConstant16;
+    storageInputOutput16 = in_struct->storageInputOutput16;
+    multiview = in_struct->multiview;
+    multiviewGeometryShader = in_struct->multiviewGeometryShader;
+    multiviewTessellationShader = in_struct->multiviewTessellationShader;
+    variablePointersStorageBuffer = in_struct->variablePointersStorageBuffer;
+    variablePointers = in_struct->variablePointers;
+    protectedMemory = in_struct->protectedMemory;
+    samplerYcbcrConversion = in_struct->samplerYcbcrConversion;
+    shaderDrawParameters = in_struct->shaderDrawParameters;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceVulkan11Features::initialize(const safe_VkPhysicalDeviceVulkan11Features* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    storageBuffer16BitAccess = copy_src->storageBuffer16BitAccess;
+    uniformAndStorageBuffer16BitAccess = copy_src->uniformAndStorageBuffer16BitAccess;
+    storagePushConstant16 = copy_src->storagePushConstant16;
+    storageInputOutput16 = copy_src->storageInputOutput16;
+    multiview = copy_src->multiview;
+    multiviewGeometryShader = copy_src->multiviewGeometryShader;
+    multiviewTessellationShader = copy_src->multiviewTessellationShader;
+    variablePointersStorageBuffer = copy_src->variablePointersStorageBuffer;
+    variablePointers = copy_src->variablePointers;
+    protectedMemory = copy_src->protectedMemory;
+    samplerYcbcrConversion = copy_src->samplerYcbcrConversion;
+    shaderDrawParameters = copy_src->shaderDrawParameters;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceVulkan11Properties::safe_VkPhysicalDeviceVulkan11Properties(
+    const VkPhysicalDeviceVulkan11Properties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      deviceNodeMask(in_struct->deviceNodeMask),
+      deviceLUIDValid(in_struct->deviceLUIDValid),
+      subgroupSize(in_struct->subgroupSize),
+      subgroupSupportedStages(in_struct->subgroupSupportedStages),
+      subgroupSupportedOperations(in_struct->subgroupSupportedOperations),
+      subgroupQuadOperationsInAllStages(in_struct->subgroupQuadOperationsInAllStages),
+      pointClippingBehavior(in_struct->pointClippingBehavior),
+      maxMultiviewViewCount(in_struct->maxMultiviewViewCount),
+      maxMultiviewInstanceIndex(in_struct->maxMultiviewInstanceIndex),
+      protectedNoFault(in_struct->protectedNoFault),
+      maxPerSetDescriptors(in_struct->maxPerSetDescriptors),
+      maxMemoryAllocationSize(in_struct->maxMemoryAllocationSize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        deviceUUID[i] = in_struct->deviceUUID[i];
+    }
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        driverUUID[i] = in_struct->driverUUID[i];
+    }
+
+    for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) {
+        deviceLUID[i] = in_struct->deviceLUID[i];
+    }
+}
+
+safe_VkPhysicalDeviceVulkan11Properties::safe_VkPhysicalDeviceVulkan11Properties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES),
+      pNext(nullptr),
+      deviceNodeMask(),
+      deviceLUIDValid(),
+      subgroupSize(),
+      subgroupSupportedStages(),
+      subgroupSupportedOperations(),
+      subgroupQuadOperationsInAllStages(),
+      pointClippingBehavior(),
+      maxMultiviewViewCount(),
+      maxMultiviewInstanceIndex(),
+      protectedNoFault(),
+      maxPerSetDescriptors(),
+      maxMemoryAllocationSize() {}
+
+safe_VkPhysicalDeviceVulkan11Properties::safe_VkPhysicalDeviceVulkan11Properties(
+    const safe_VkPhysicalDeviceVulkan11Properties& copy_src) {
+    sType = copy_src.sType;
+    deviceNodeMask = copy_src.deviceNodeMask;
+    deviceLUIDValid = copy_src.deviceLUIDValid;
+    subgroupSize = copy_src.subgroupSize;
+    subgroupSupportedStages = copy_src.subgroupSupportedStages;
+    subgroupSupportedOperations = copy_src.subgroupSupportedOperations;
+    subgroupQuadOperationsInAllStages = copy_src.subgroupQuadOperationsInAllStages;
+    pointClippingBehavior = copy_src.pointClippingBehavior;
+    maxMultiviewViewCount = copy_src.maxMultiviewViewCount;
+    maxMultiviewInstanceIndex = copy_src.maxMultiviewInstanceIndex;
+    protectedNoFault = copy_src.protectedNoFault;
+    maxPerSetDescriptors = copy_src.maxPerSetDescriptors;
+    maxMemoryAllocationSize = copy_src.maxMemoryAllocationSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        deviceUUID[i] = copy_src.deviceUUID[i];
+    }
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        driverUUID[i] = copy_src.driverUUID[i];
+    }
+
+    for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) {
+        deviceLUID[i] = copy_src.deviceLUID[i];
+    }
+}
+
+safe_VkPhysicalDeviceVulkan11Properties& safe_VkPhysicalDeviceVulkan11Properties::operator=(
+    const safe_VkPhysicalDeviceVulkan11Properties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    deviceNodeMask = copy_src.deviceNodeMask;
+    deviceLUIDValid = copy_src.deviceLUIDValid;
+    subgroupSize = copy_src.subgroupSize;
+    subgroupSupportedStages = copy_src.subgroupSupportedStages;
+    subgroupSupportedOperations = copy_src.subgroupSupportedOperations;
+    subgroupQuadOperationsInAllStages = copy_src.subgroupQuadOperationsInAllStages;
+    pointClippingBehavior = copy_src.pointClippingBehavior;
+    maxMultiviewViewCount = copy_src.maxMultiviewViewCount;
+    maxMultiviewInstanceIndex = copy_src.maxMultiviewInstanceIndex;
+    protectedNoFault = copy_src.protectedNoFault;
+    maxPerSetDescriptors = copy_src.maxPerSetDescriptors;
+    maxMemoryAllocationSize = copy_src.maxMemoryAllocationSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        deviceUUID[i] = copy_src.deviceUUID[i];
+    }
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        driverUUID[i] = copy_src.driverUUID[i];
+    }
+
+    for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) {
+        deviceLUID[i] = copy_src.deviceLUID[i];
+    }
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceVulkan11Properties::~safe_VkPhysicalDeviceVulkan11Properties() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceVulkan11Properties::initialize(const VkPhysicalDeviceVulkan11Properties* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    deviceNodeMask = in_struct->deviceNodeMask;
+    deviceLUIDValid = in_struct->deviceLUIDValid;
+    subgroupSize = in_struct->subgroupSize;
+    subgroupSupportedStages = in_struct->subgroupSupportedStages;
+    subgroupSupportedOperations = in_struct->subgroupSupportedOperations;
+    subgroupQuadOperationsInAllStages = in_struct->subgroupQuadOperationsInAllStages;
+    pointClippingBehavior = in_struct->pointClippingBehavior;
+    maxMultiviewViewCount = in_struct->maxMultiviewViewCount;
+    maxMultiviewInstanceIndex = in_struct->maxMultiviewInstanceIndex;
+    protectedNoFault = in_struct->protectedNoFault;
+    maxPerSetDescriptors = in_struct->maxPerSetDescriptors;
+    maxMemoryAllocationSize = in_struct->maxMemoryAllocationSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        deviceUUID[i] = in_struct->deviceUUID[i];
+    }
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        driverUUID[i] = in_struct->driverUUID[i];
+    }
+
+    for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) {
+        deviceLUID[i] = in_struct->deviceLUID[i];
+    }
+}
+
+void safe_VkPhysicalDeviceVulkan11Properties::initialize(const safe_VkPhysicalDeviceVulkan11Properties* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    deviceNodeMask = copy_src->deviceNodeMask;
+    deviceLUIDValid = copy_src->deviceLUIDValid;
+    subgroupSize = copy_src->subgroupSize;
+    subgroupSupportedStages = copy_src->subgroupSupportedStages;
+    subgroupSupportedOperations = copy_src->subgroupSupportedOperations;
+    subgroupQuadOperationsInAllStages = copy_src->subgroupQuadOperationsInAllStages;
+    pointClippingBehavior = copy_src->pointClippingBehavior;
+    maxMultiviewViewCount = copy_src->maxMultiviewViewCount;
+    maxMultiviewInstanceIndex = copy_src->maxMultiviewInstanceIndex;
+    protectedNoFault = copy_src->protectedNoFault;
+    maxPerSetDescriptors = copy_src->maxPerSetDescriptors;
+    maxMemoryAllocationSize = copy_src->maxMemoryAllocationSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        deviceUUID[i] = copy_src->deviceUUID[i];
+    }
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        driverUUID[i] = copy_src->driverUUID[i];
+    }
+
+    for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) {
+        deviceLUID[i] = copy_src->deviceLUID[i];
+    }
+}
+
+safe_VkPhysicalDeviceVulkan12Features::safe_VkPhysicalDeviceVulkan12Features(const VkPhysicalDeviceVulkan12Features* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType),
+      samplerMirrorClampToEdge(in_struct->samplerMirrorClampToEdge),
+      drawIndirectCount(in_struct->drawIndirectCount),
+      storageBuffer8BitAccess(in_struct->storageBuffer8BitAccess),
+      uniformAndStorageBuffer8BitAccess(in_struct->uniformAndStorageBuffer8BitAccess),
+      storagePushConstant8(in_struct->storagePushConstant8),
+      shaderBufferInt64Atomics(in_struct->shaderBufferInt64Atomics),
+      shaderSharedInt64Atomics(in_struct->shaderSharedInt64Atomics),
+      shaderFloat16(in_struct->shaderFloat16),
+      shaderInt8(in_struct->shaderInt8),
+      descriptorIndexing(in_struct->descriptorIndexing),
+      shaderInputAttachmentArrayDynamicIndexing(in_struct->shaderInputAttachmentArrayDynamicIndexing),
+      shaderUniformTexelBufferArrayDynamicIndexing(in_struct->shaderUniformTexelBufferArrayDynamicIndexing),
+      shaderStorageTexelBufferArrayDynamicIndexing(in_struct->shaderStorageTexelBufferArrayDynamicIndexing),
+      shaderUniformBufferArrayNonUniformIndexing(in_struct->shaderUniformBufferArrayNonUniformIndexing),
+      shaderSampledImageArrayNonUniformIndexing(in_struct->shaderSampledImageArrayNonUniformIndexing),
+      shaderStorageBufferArrayNonUniformIndexing(in_struct->shaderStorageBufferArrayNonUniformIndexing),
+      shaderStorageImageArrayNonUniformIndexing(in_struct->shaderStorageImageArrayNonUniformIndexing),
+      shaderInputAttachmentArrayNonUniformIndexing(in_struct->shaderInputAttachmentArrayNonUniformIndexing),
+      shaderUniformTexelBufferArrayNonUniformIndexing(in_struct->shaderUniformTexelBufferArrayNonUniformIndexing),
+      shaderStorageTexelBufferArrayNonUniformIndexing(in_struct->shaderStorageTexelBufferArrayNonUniformIndexing),
+      descriptorBindingUniformBufferUpdateAfterBind(in_struct->descriptorBindingUniformBufferUpdateAfterBind),
+      descriptorBindingSampledImageUpdateAfterBind(in_struct->descriptorBindingSampledImageUpdateAfterBind),
+      descriptorBindingStorageImageUpdateAfterBind(in_struct->descriptorBindingStorageImageUpdateAfterBind),
+      descriptorBindingStorageBufferUpdateAfterBind(in_struct->descriptorBindingStorageBufferUpdateAfterBind),
+      descriptorBindingUniformTexelBufferUpdateAfterBind(in_struct->descriptorBindingUniformTexelBufferUpdateAfterBind),
+      descriptorBindingStorageTexelBufferUpdateAfterBind(in_struct->descriptorBindingStorageTexelBufferUpdateAfterBind),
+      descriptorBindingUpdateUnusedWhilePending(in_struct->descriptorBindingUpdateUnusedWhilePending),
+      descriptorBindingPartiallyBound(in_struct->descriptorBindingPartiallyBound),
+      descriptorBindingVariableDescriptorCount(in_struct->descriptorBindingVariableDescriptorCount),
+      runtimeDescriptorArray(in_struct->runtimeDescriptorArray),
+      samplerFilterMinmax(in_struct->samplerFilterMinmax),
+      scalarBlockLayout(in_struct->scalarBlockLayout),
+      imagelessFramebuffer(in_struct->imagelessFramebuffer),
+      uniformBufferStandardLayout(in_struct->uniformBufferStandardLayout),
+      shaderSubgroupExtendedTypes(in_struct->shaderSubgroupExtendedTypes),
+      separateDepthStencilLayouts(in_struct->separateDepthStencilLayouts),
+      hostQueryReset(in_struct->hostQueryReset),
+      timelineSemaphore(in_struct->timelineSemaphore),
+      bufferDeviceAddress(in_struct->bufferDeviceAddress),
+      bufferDeviceAddressCaptureReplay(in_struct->bufferDeviceAddressCaptureReplay),
+      bufferDeviceAddressMultiDevice(in_struct->bufferDeviceAddressMultiDevice),
+      vulkanMemoryModel(in_struct->vulkanMemoryModel),
+      vulkanMemoryModelDeviceScope(in_struct->vulkanMemoryModelDeviceScope),
+      vulkanMemoryModelAvailabilityVisibilityChains(in_struct->vulkanMemoryModelAvailabilityVisibilityChains),
+      shaderOutputViewportIndex(in_struct->shaderOutputViewportIndex),
+      shaderOutputLayer(in_struct->shaderOutputLayer),
+      subgroupBroadcastDynamicId(in_struct->subgroupBroadcastDynamicId) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceVulkan12Features::safe_VkPhysicalDeviceVulkan12Features()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES),
+      pNext(nullptr),
+      samplerMirrorClampToEdge(),
+      drawIndirectCount(),
+      storageBuffer8BitAccess(),
+      uniformAndStorageBuffer8BitAccess(),
+      storagePushConstant8(),
+      shaderBufferInt64Atomics(),
+      shaderSharedInt64Atomics(),
+      shaderFloat16(),
+      shaderInt8(),
+      descriptorIndexing(),
+      shaderInputAttachmentArrayDynamicIndexing(),
+      shaderUniformTexelBufferArrayDynamicIndexing(),
+      shaderStorageTexelBufferArrayDynamicIndexing(),
+      shaderUniformBufferArrayNonUniformIndexing(),
+      shaderSampledImageArrayNonUniformIndexing(),
+      shaderStorageBufferArrayNonUniformIndexing(),
+      shaderStorageImageArrayNonUniformIndexing(),
+      shaderInputAttachmentArrayNonUniformIndexing(),
+      shaderUniformTexelBufferArrayNonUniformIndexing(),
+      shaderStorageTexelBufferArrayNonUniformIndexing(),
+      descriptorBindingUniformBufferUpdateAfterBind(),
+      descriptorBindingSampledImageUpdateAfterBind(),
+      descriptorBindingStorageImageUpdateAfterBind(),
+      descriptorBindingStorageBufferUpdateAfterBind(),
+      descriptorBindingUniformTexelBufferUpdateAfterBind(),
+      descriptorBindingStorageTexelBufferUpdateAfterBind(),
+      descriptorBindingUpdateUnusedWhilePending(),
+      descriptorBindingPartiallyBound(),
+      descriptorBindingVariableDescriptorCount(),
+      runtimeDescriptorArray(),
+      samplerFilterMinmax(),
+      scalarBlockLayout(),
+      imagelessFramebuffer(),
+      uniformBufferStandardLayout(),
+      shaderSubgroupExtendedTypes(),
+      separateDepthStencilLayouts(),
+      hostQueryReset(),
+      timelineSemaphore(),
+      bufferDeviceAddress(),
+      bufferDeviceAddressCaptureReplay(),
+      bufferDeviceAddressMultiDevice(),
+      vulkanMemoryModel(),
+      vulkanMemoryModelDeviceScope(),
+      vulkanMemoryModelAvailabilityVisibilityChains(),
+      shaderOutputViewportIndex(),
+      shaderOutputLayer(),
+      subgroupBroadcastDynamicId() {}
+
+safe_VkPhysicalDeviceVulkan12Features::safe_VkPhysicalDeviceVulkan12Features(
+    const safe_VkPhysicalDeviceVulkan12Features& copy_src) {
+    sType = copy_src.sType;
+    samplerMirrorClampToEdge = copy_src.samplerMirrorClampToEdge;
+    drawIndirectCount = copy_src.drawIndirectCount;
+    storageBuffer8BitAccess = copy_src.storageBuffer8BitAccess;
+    uniformAndStorageBuffer8BitAccess = copy_src.uniformAndStorageBuffer8BitAccess;
+    storagePushConstant8 = copy_src.storagePushConstant8;
+    shaderBufferInt64Atomics = copy_src.shaderBufferInt64Atomics;
+    shaderSharedInt64Atomics = copy_src.shaderSharedInt64Atomics;
+    shaderFloat16 = copy_src.shaderFloat16;
+    shaderInt8 = copy_src.shaderInt8;
+    descriptorIndexing = copy_src.descriptorIndexing;
+    shaderInputAttachmentArrayDynamicIndexing = copy_src.shaderInputAttachmentArrayDynamicIndexing;
+    shaderUniformTexelBufferArrayDynamicIndexing = copy_src.shaderUniformTexelBufferArrayDynamicIndexing;
+    shaderStorageTexelBufferArrayDynamicIndexing = copy_src.shaderStorageTexelBufferArrayDynamicIndexing;
+    shaderUniformBufferArrayNonUniformIndexing = copy_src.shaderUniformBufferArrayNonUniformIndexing;
+    shaderSampledImageArrayNonUniformIndexing = copy_src.shaderSampledImageArrayNonUniformIndexing;
+    shaderStorageBufferArrayNonUniformIndexing = copy_src.shaderStorageBufferArrayNonUniformIndexing;
+    shaderStorageImageArrayNonUniformIndexing = copy_src.shaderStorageImageArrayNonUniformIndexing;
+    shaderInputAttachmentArrayNonUniformIndexing = copy_src.shaderInputAttachmentArrayNonUniformIndexing;
+    shaderUniformTexelBufferArrayNonUniformIndexing = copy_src.shaderUniformTexelBufferArrayNonUniformIndexing;
+    shaderStorageTexelBufferArrayNonUniformIndexing = copy_src.shaderStorageTexelBufferArrayNonUniformIndexing;
+    descriptorBindingUniformBufferUpdateAfterBind = copy_src.descriptorBindingUniformBufferUpdateAfterBind;
+    descriptorBindingSampledImageUpdateAfterBind = copy_src.descriptorBindingSampledImageUpdateAfterBind;
+    descriptorBindingStorageImageUpdateAfterBind = copy_src.descriptorBindingStorageImageUpdateAfterBind;
+    descriptorBindingStorageBufferUpdateAfterBind = copy_src.descriptorBindingStorageBufferUpdateAfterBind;
+    descriptorBindingUniformTexelBufferUpdateAfterBind = copy_src.descriptorBindingUniformTexelBufferUpdateAfterBind;
+    descriptorBindingStorageTexelBufferUpdateAfterBind = copy_src.descriptorBindingStorageTexelBufferUpdateAfterBind;
+    descriptorBindingUpdateUnusedWhilePending = copy_src.descriptorBindingUpdateUnusedWhilePending;
+    descriptorBindingPartiallyBound = copy_src.descriptorBindingPartiallyBound;
+    descriptorBindingVariableDescriptorCount = copy_src.descriptorBindingVariableDescriptorCount;
+    runtimeDescriptorArray = copy_src.runtimeDescriptorArray;
+    samplerFilterMinmax = copy_src.samplerFilterMinmax;
+    scalarBlockLayout = copy_src.scalarBlockLayout;
+    imagelessFramebuffer = copy_src.imagelessFramebuffer;
+    uniformBufferStandardLayout = copy_src.uniformBufferStandardLayout;
+    shaderSubgroupExtendedTypes = copy_src.shaderSubgroupExtendedTypes;
+    separateDepthStencilLayouts = copy_src.separateDepthStencilLayouts;
+    hostQueryReset = copy_src.hostQueryReset;
+    timelineSemaphore = copy_src.timelineSemaphore;
+    bufferDeviceAddress = copy_src.bufferDeviceAddress;
+    bufferDeviceAddressCaptureReplay = copy_src.bufferDeviceAddressCaptureReplay;
+    bufferDeviceAddressMultiDevice = copy_src.bufferDeviceAddressMultiDevice;
+    vulkanMemoryModel = copy_src.vulkanMemoryModel;
+    vulkanMemoryModelDeviceScope = copy_src.vulkanMemoryModelDeviceScope;
+    vulkanMemoryModelAvailabilityVisibilityChains = copy_src.vulkanMemoryModelAvailabilityVisibilityChains;
+    shaderOutputViewportIndex = copy_src.shaderOutputViewportIndex;
+    shaderOutputLayer = copy_src.shaderOutputLayer;
+    subgroupBroadcastDynamicId = copy_src.subgroupBroadcastDynamicId;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceVulkan12Features& safe_VkPhysicalDeviceVulkan12Features::operator=(
+    const safe_VkPhysicalDeviceVulkan12Features& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    samplerMirrorClampToEdge = copy_src.samplerMirrorClampToEdge;
+    drawIndirectCount = copy_src.drawIndirectCount;
+    storageBuffer8BitAccess = copy_src.storageBuffer8BitAccess;
+    uniformAndStorageBuffer8BitAccess = copy_src.uniformAndStorageBuffer8BitAccess;
+    storagePushConstant8 = copy_src.storagePushConstant8;
+    shaderBufferInt64Atomics = copy_src.shaderBufferInt64Atomics;
+    shaderSharedInt64Atomics = copy_src.shaderSharedInt64Atomics;
+    shaderFloat16 = copy_src.shaderFloat16;
+    shaderInt8 = copy_src.shaderInt8;
+    descriptorIndexing = copy_src.descriptorIndexing;
+    shaderInputAttachmentArrayDynamicIndexing = copy_src.shaderInputAttachmentArrayDynamicIndexing;
+    shaderUniformTexelBufferArrayDynamicIndexing = copy_src.shaderUniformTexelBufferArrayDynamicIndexing;
+    shaderStorageTexelBufferArrayDynamicIndexing = copy_src.shaderStorageTexelBufferArrayDynamicIndexing;
+    shaderUniformBufferArrayNonUniformIndexing = copy_src.shaderUniformBufferArrayNonUniformIndexing;
+    shaderSampledImageArrayNonUniformIndexing = copy_src.shaderSampledImageArrayNonUniformIndexing;
+    shaderStorageBufferArrayNonUniformIndexing = copy_src.shaderStorageBufferArrayNonUniformIndexing;
+    shaderStorageImageArrayNonUniformIndexing = copy_src.shaderStorageImageArrayNonUniformIndexing;
+    shaderInputAttachmentArrayNonUniformIndexing = copy_src.shaderInputAttachmentArrayNonUniformIndexing;
+    shaderUniformTexelBufferArrayNonUniformIndexing = copy_src.shaderUniformTexelBufferArrayNonUniformIndexing;
+    shaderStorageTexelBufferArrayNonUniformIndexing = copy_src.shaderStorageTexelBufferArrayNonUniformIndexing;
+    descriptorBindingUniformBufferUpdateAfterBind = copy_src.descriptorBindingUniformBufferUpdateAfterBind;
+    descriptorBindingSampledImageUpdateAfterBind = copy_src.descriptorBindingSampledImageUpdateAfterBind;
+    descriptorBindingStorageImageUpdateAfterBind = copy_src.descriptorBindingStorageImageUpdateAfterBind;
+    descriptorBindingStorageBufferUpdateAfterBind = copy_src.descriptorBindingStorageBufferUpdateAfterBind;
+    descriptorBindingUniformTexelBufferUpdateAfterBind = copy_src.descriptorBindingUniformTexelBufferUpdateAfterBind;
+    descriptorBindingStorageTexelBufferUpdateAfterBind = copy_src.descriptorBindingStorageTexelBufferUpdateAfterBind;
+    descriptorBindingUpdateUnusedWhilePending = copy_src.descriptorBindingUpdateUnusedWhilePending;
+    descriptorBindingPartiallyBound = copy_src.descriptorBindingPartiallyBound;
+    descriptorBindingVariableDescriptorCount = copy_src.descriptorBindingVariableDescriptorCount;
+    runtimeDescriptorArray = copy_src.runtimeDescriptorArray;
+    samplerFilterMinmax = copy_src.samplerFilterMinmax;
+    scalarBlockLayout = copy_src.scalarBlockLayout;
+    imagelessFramebuffer = copy_src.imagelessFramebuffer;
+    uniformBufferStandardLayout = copy_src.uniformBufferStandardLayout;
+    shaderSubgroupExtendedTypes = copy_src.shaderSubgroupExtendedTypes;
+    separateDepthStencilLayouts = copy_src.separateDepthStencilLayouts;
+    hostQueryReset = copy_src.hostQueryReset;
+    timelineSemaphore = copy_src.timelineSemaphore;
+    bufferDeviceAddress = copy_src.bufferDeviceAddress;
+    bufferDeviceAddressCaptureReplay = copy_src.bufferDeviceAddressCaptureReplay;
+    bufferDeviceAddressMultiDevice = copy_src.bufferDeviceAddressMultiDevice;
+    vulkanMemoryModel = copy_src.vulkanMemoryModel;
+    vulkanMemoryModelDeviceScope = copy_src.vulkanMemoryModelDeviceScope;
+    vulkanMemoryModelAvailabilityVisibilityChains = copy_src.vulkanMemoryModelAvailabilityVisibilityChains;
+    shaderOutputViewportIndex = copy_src.shaderOutputViewportIndex;
+    shaderOutputLayer = copy_src.shaderOutputLayer;
+    subgroupBroadcastDynamicId = copy_src.subgroupBroadcastDynamicId;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceVulkan12Features::~safe_VkPhysicalDeviceVulkan12Features() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceVulkan12Features::initialize(const VkPhysicalDeviceVulkan12Features* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    samplerMirrorClampToEdge = in_struct->samplerMirrorClampToEdge;
+    drawIndirectCount = in_struct->drawIndirectCount;
+    storageBuffer8BitAccess = in_struct->storageBuffer8BitAccess;
+    uniformAndStorageBuffer8BitAccess = in_struct->uniformAndStorageBuffer8BitAccess;
+    storagePushConstant8 = in_struct->storagePushConstant8;
+    shaderBufferInt64Atomics = in_struct->shaderBufferInt64Atomics;
+    shaderSharedInt64Atomics = in_struct->shaderSharedInt64Atomics;
+    shaderFloat16 = in_struct->shaderFloat16;
+    shaderInt8 = in_struct->shaderInt8;
+    descriptorIndexing = in_struct->descriptorIndexing;
+    shaderInputAttachmentArrayDynamicIndexing = in_struct->shaderInputAttachmentArrayDynamicIndexing;
+    shaderUniformTexelBufferArrayDynamicIndexing = in_struct->shaderUniformTexelBufferArrayDynamicIndexing;
+    shaderStorageTexelBufferArrayDynamicIndexing = in_struct->shaderStorageTexelBufferArrayDynamicIndexing;
+    shaderUniformBufferArrayNonUniformIndexing = in_struct->shaderUniformBufferArrayNonUniformIndexing;
+    shaderSampledImageArrayNonUniformIndexing = in_struct->shaderSampledImageArrayNonUniformIndexing;
+    shaderStorageBufferArrayNonUniformIndexing = in_struct->shaderStorageBufferArrayNonUniformIndexing;
+    shaderStorageImageArrayNonUniformIndexing = in_struct->shaderStorageImageArrayNonUniformIndexing;
+    shaderInputAttachmentArrayNonUniformIndexing = in_struct->shaderInputAttachmentArrayNonUniformIndexing;
+    shaderUniformTexelBufferArrayNonUniformIndexing = in_struct->shaderUniformTexelBufferArrayNonUniformIndexing;
+    shaderStorageTexelBufferArrayNonUniformIndexing = in_struct->shaderStorageTexelBufferArrayNonUniformIndexing;
+    descriptorBindingUniformBufferUpdateAfterBind = in_struct->descriptorBindingUniformBufferUpdateAfterBind;
+    descriptorBindingSampledImageUpdateAfterBind = in_struct->descriptorBindingSampledImageUpdateAfterBind;
+    descriptorBindingStorageImageUpdateAfterBind = in_struct->descriptorBindingStorageImageUpdateAfterBind;
+    descriptorBindingStorageBufferUpdateAfterBind = in_struct->descriptorBindingStorageBufferUpdateAfterBind;
+    descriptorBindingUniformTexelBufferUpdateAfterBind = in_struct->descriptorBindingUniformTexelBufferUpdateAfterBind;
+    descriptorBindingStorageTexelBufferUpdateAfterBind = in_struct->descriptorBindingStorageTexelBufferUpdateAfterBind;
+    descriptorBindingUpdateUnusedWhilePending = in_struct->descriptorBindingUpdateUnusedWhilePending;
+    descriptorBindingPartiallyBound = in_struct->descriptorBindingPartiallyBound;
+    descriptorBindingVariableDescriptorCount = in_struct->descriptorBindingVariableDescriptorCount;
+    runtimeDescriptorArray = in_struct->runtimeDescriptorArray;
+    samplerFilterMinmax = in_struct->samplerFilterMinmax;
+    scalarBlockLayout = in_struct->scalarBlockLayout;
+    imagelessFramebuffer = in_struct->imagelessFramebuffer;
+    uniformBufferStandardLayout = in_struct->uniformBufferStandardLayout;
+    shaderSubgroupExtendedTypes = in_struct->shaderSubgroupExtendedTypes;
+    separateDepthStencilLayouts = in_struct->separateDepthStencilLayouts;
+    hostQueryReset = in_struct->hostQueryReset;
+    timelineSemaphore = in_struct->timelineSemaphore;
+    bufferDeviceAddress = in_struct->bufferDeviceAddress;
+    bufferDeviceAddressCaptureReplay = in_struct->bufferDeviceAddressCaptureReplay;
+    bufferDeviceAddressMultiDevice = in_struct->bufferDeviceAddressMultiDevice;
+    vulkanMemoryModel = in_struct->vulkanMemoryModel;
+    vulkanMemoryModelDeviceScope = in_struct->vulkanMemoryModelDeviceScope;
+    vulkanMemoryModelAvailabilityVisibilityChains = in_struct->vulkanMemoryModelAvailabilityVisibilityChains;
+    shaderOutputViewportIndex = in_struct->shaderOutputViewportIndex;
+    shaderOutputLayer = in_struct->shaderOutputLayer;
+    subgroupBroadcastDynamicId = in_struct->subgroupBroadcastDynamicId;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceVulkan12Features::initialize(const safe_VkPhysicalDeviceVulkan12Features* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    samplerMirrorClampToEdge = copy_src->samplerMirrorClampToEdge;
+    drawIndirectCount = copy_src->drawIndirectCount;
+    storageBuffer8BitAccess = copy_src->storageBuffer8BitAccess;
+    uniformAndStorageBuffer8BitAccess = copy_src->uniformAndStorageBuffer8BitAccess;
+    storagePushConstant8 = copy_src->storagePushConstant8;
+    shaderBufferInt64Atomics = copy_src->shaderBufferInt64Atomics;
+    shaderSharedInt64Atomics = copy_src->shaderSharedInt64Atomics;
+    shaderFloat16 = copy_src->shaderFloat16;
+    shaderInt8 = copy_src->shaderInt8;
+    descriptorIndexing = copy_src->descriptorIndexing;
+    shaderInputAttachmentArrayDynamicIndexing = copy_src->shaderInputAttachmentArrayDynamicIndexing;
+    shaderUniformTexelBufferArrayDynamicIndexing = copy_src->shaderUniformTexelBufferArrayDynamicIndexing;
+    shaderStorageTexelBufferArrayDynamicIndexing = copy_src->shaderStorageTexelBufferArrayDynamicIndexing;
+    shaderUniformBufferArrayNonUniformIndexing = copy_src->shaderUniformBufferArrayNonUniformIndexing;
+    shaderSampledImageArrayNonUniformIndexing = copy_src->shaderSampledImageArrayNonUniformIndexing;
+    shaderStorageBufferArrayNonUniformIndexing = copy_src->shaderStorageBufferArrayNonUniformIndexing;
+    shaderStorageImageArrayNonUniformIndexing = copy_src->shaderStorageImageArrayNonUniformIndexing;
+    shaderInputAttachmentArrayNonUniformIndexing = copy_src->shaderInputAttachmentArrayNonUniformIndexing;
+    shaderUniformTexelBufferArrayNonUniformIndexing = copy_src->shaderUniformTexelBufferArrayNonUniformIndexing;
+    shaderStorageTexelBufferArrayNonUniformIndexing = copy_src->shaderStorageTexelBufferArrayNonUniformIndexing;
+    descriptorBindingUniformBufferUpdateAfterBind = copy_src->descriptorBindingUniformBufferUpdateAfterBind;
+    descriptorBindingSampledImageUpdateAfterBind = copy_src->descriptorBindingSampledImageUpdateAfterBind;
+    descriptorBindingStorageImageUpdateAfterBind = copy_src->descriptorBindingStorageImageUpdateAfterBind;
+    descriptorBindingStorageBufferUpdateAfterBind = copy_src->descriptorBindingStorageBufferUpdateAfterBind;
+    descriptorBindingUniformTexelBufferUpdateAfterBind = copy_src->descriptorBindingUniformTexelBufferUpdateAfterBind;
+    descriptorBindingStorageTexelBufferUpdateAfterBind = copy_src->descriptorBindingStorageTexelBufferUpdateAfterBind;
+    descriptorBindingUpdateUnusedWhilePending = copy_src->descriptorBindingUpdateUnusedWhilePending;
+    descriptorBindingPartiallyBound = copy_src->descriptorBindingPartiallyBound;
+    descriptorBindingVariableDescriptorCount = copy_src->descriptorBindingVariableDescriptorCount;
+    runtimeDescriptorArray = copy_src->runtimeDescriptorArray;
+    samplerFilterMinmax = copy_src->samplerFilterMinmax;
+    scalarBlockLayout = copy_src->scalarBlockLayout;
+    imagelessFramebuffer = copy_src->imagelessFramebuffer;
+    uniformBufferStandardLayout = copy_src->uniformBufferStandardLayout;
+    shaderSubgroupExtendedTypes = copy_src->shaderSubgroupExtendedTypes;
+    separateDepthStencilLayouts = copy_src->separateDepthStencilLayouts;
+    hostQueryReset = copy_src->hostQueryReset;
+    timelineSemaphore = copy_src->timelineSemaphore;
+    bufferDeviceAddress = copy_src->bufferDeviceAddress;
+    bufferDeviceAddressCaptureReplay = copy_src->bufferDeviceAddressCaptureReplay;
+    bufferDeviceAddressMultiDevice = copy_src->bufferDeviceAddressMultiDevice;
+    vulkanMemoryModel = copy_src->vulkanMemoryModel;
+    vulkanMemoryModelDeviceScope = copy_src->vulkanMemoryModelDeviceScope;
+    vulkanMemoryModelAvailabilityVisibilityChains = copy_src->vulkanMemoryModelAvailabilityVisibilityChains;
+    shaderOutputViewportIndex = copy_src->shaderOutputViewportIndex;
+    shaderOutputLayer = copy_src->shaderOutputLayer;
+    subgroupBroadcastDynamicId = copy_src->subgroupBroadcastDynamicId;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceVulkan12Properties::safe_VkPhysicalDeviceVulkan12Properties(
+    const VkPhysicalDeviceVulkan12Properties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      driverID(in_struct->driverID),
+      conformanceVersion(in_struct->conformanceVersion),
+      denormBehaviorIndependence(in_struct->denormBehaviorIndependence),
+      roundingModeIndependence(in_struct->roundingModeIndependence),
+      shaderSignedZeroInfNanPreserveFloat16(in_struct->shaderSignedZeroInfNanPreserveFloat16),
+      shaderSignedZeroInfNanPreserveFloat32(in_struct->shaderSignedZeroInfNanPreserveFloat32),
+      shaderSignedZeroInfNanPreserveFloat64(in_struct->shaderSignedZeroInfNanPreserveFloat64),
+      shaderDenormPreserveFloat16(in_struct->shaderDenormPreserveFloat16),
+      shaderDenormPreserveFloat32(in_struct->shaderDenormPreserveFloat32),
+      shaderDenormPreserveFloat64(in_struct->shaderDenormPreserveFloat64),
+      shaderDenormFlushToZeroFloat16(in_struct->shaderDenormFlushToZeroFloat16),
+      shaderDenormFlushToZeroFloat32(in_struct->shaderDenormFlushToZeroFloat32),
+      shaderDenormFlushToZeroFloat64(in_struct->shaderDenormFlushToZeroFloat64),
+      shaderRoundingModeRTEFloat16(in_struct->shaderRoundingModeRTEFloat16),
+      shaderRoundingModeRTEFloat32(in_struct->shaderRoundingModeRTEFloat32),
+      shaderRoundingModeRTEFloat64(in_struct->shaderRoundingModeRTEFloat64),
+      shaderRoundingModeRTZFloat16(in_struct->shaderRoundingModeRTZFloat16),
+      shaderRoundingModeRTZFloat32(in_struct->shaderRoundingModeRTZFloat32),
+      shaderRoundingModeRTZFloat64(in_struct->shaderRoundingModeRTZFloat64),
+      maxUpdateAfterBindDescriptorsInAllPools(in_struct->maxUpdateAfterBindDescriptorsInAllPools),
+      shaderUniformBufferArrayNonUniformIndexingNative(in_struct->shaderUniformBufferArrayNonUniformIndexingNative),
+      shaderSampledImageArrayNonUniformIndexingNative(in_struct->shaderSampledImageArrayNonUniformIndexingNative),
+      shaderStorageBufferArrayNonUniformIndexingNative(in_struct->shaderStorageBufferArrayNonUniformIndexingNative),
+      shaderStorageImageArrayNonUniformIndexingNative(in_struct->shaderStorageImageArrayNonUniformIndexingNative),
+      shaderInputAttachmentArrayNonUniformIndexingNative(in_struct->shaderInputAttachmentArrayNonUniformIndexingNative),
+      robustBufferAccessUpdateAfterBind(in_struct->robustBufferAccessUpdateAfterBind),
+      quadDivergentImplicitLod(in_struct->quadDivergentImplicitLod),
+      maxPerStageDescriptorUpdateAfterBindSamplers(in_struct->maxPerStageDescriptorUpdateAfterBindSamplers),
+      maxPerStageDescriptorUpdateAfterBindUniformBuffers(in_struct->maxPerStageDescriptorUpdateAfterBindUniformBuffers),
+      maxPerStageDescriptorUpdateAfterBindStorageBuffers(in_struct->maxPerStageDescriptorUpdateAfterBindStorageBuffers),
+      maxPerStageDescriptorUpdateAfterBindSampledImages(in_struct->maxPerStageDescriptorUpdateAfterBindSampledImages),
+      maxPerStageDescriptorUpdateAfterBindStorageImages(in_struct->maxPerStageDescriptorUpdateAfterBindStorageImages),
+      maxPerStageDescriptorUpdateAfterBindInputAttachments(in_struct->maxPerStageDescriptorUpdateAfterBindInputAttachments),
+      maxPerStageUpdateAfterBindResources(in_struct->maxPerStageUpdateAfterBindResources),
+      maxDescriptorSetUpdateAfterBindSamplers(in_struct->maxDescriptorSetUpdateAfterBindSamplers),
+      maxDescriptorSetUpdateAfterBindUniformBuffers(in_struct->maxDescriptorSetUpdateAfterBindUniformBuffers),
+      maxDescriptorSetUpdateAfterBindUniformBuffersDynamic(in_struct->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic),
+      maxDescriptorSetUpdateAfterBindStorageBuffers(in_struct->maxDescriptorSetUpdateAfterBindStorageBuffers),
+      maxDescriptorSetUpdateAfterBindStorageBuffersDynamic(in_struct->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic),
+      maxDescriptorSetUpdateAfterBindSampledImages(in_struct->maxDescriptorSetUpdateAfterBindSampledImages),
+      maxDescriptorSetUpdateAfterBindStorageImages(in_struct->maxDescriptorSetUpdateAfterBindStorageImages),
+      maxDescriptorSetUpdateAfterBindInputAttachments(in_struct->maxDescriptorSetUpdateAfterBindInputAttachments),
+      supportedDepthResolveModes(in_struct->supportedDepthResolveModes),
+      supportedStencilResolveModes(in_struct->supportedStencilResolveModes),
+      independentResolveNone(in_struct->independentResolveNone),
+      independentResolve(in_struct->independentResolve),
+      filterMinmaxSingleComponentFormats(in_struct->filterMinmaxSingleComponentFormats),
+      filterMinmaxImageComponentMapping(in_struct->filterMinmaxImageComponentMapping),
+      maxTimelineSemaphoreValueDifference(in_struct->maxTimelineSemaphoreValueDifference),
+      framebufferIntegerColorSampleCounts(in_struct->framebufferIntegerColorSampleCounts) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) {
+        driverName[i] = in_struct->driverName[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) {
+        driverInfo[i] = in_struct->driverInfo[i];
+    }
+}
+
+safe_VkPhysicalDeviceVulkan12Properties::safe_VkPhysicalDeviceVulkan12Properties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES),
+      pNext(nullptr),
+      driverID(),
+      conformanceVersion(),
+      denormBehaviorIndependence(),
+      roundingModeIndependence(),
+      shaderSignedZeroInfNanPreserveFloat16(),
+      shaderSignedZeroInfNanPreserveFloat32(),
+      shaderSignedZeroInfNanPreserveFloat64(),
+      shaderDenormPreserveFloat16(),
+      shaderDenormPreserveFloat32(),
+      shaderDenormPreserveFloat64(),
+      shaderDenormFlushToZeroFloat16(),
+      shaderDenormFlushToZeroFloat32(),
+      shaderDenormFlushToZeroFloat64(),
+      shaderRoundingModeRTEFloat16(),
+      shaderRoundingModeRTEFloat32(),
+      shaderRoundingModeRTEFloat64(),
+      shaderRoundingModeRTZFloat16(),
+      shaderRoundingModeRTZFloat32(),
+      shaderRoundingModeRTZFloat64(),
+      maxUpdateAfterBindDescriptorsInAllPools(),
+      shaderUniformBufferArrayNonUniformIndexingNative(),
+      shaderSampledImageArrayNonUniformIndexingNative(),
+      shaderStorageBufferArrayNonUniformIndexingNative(),
+      shaderStorageImageArrayNonUniformIndexingNative(),
+      shaderInputAttachmentArrayNonUniformIndexingNative(),
+      robustBufferAccessUpdateAfterBind(),
+      quadDivergentImplicitLod(),
+      maxPerStageDescriptorUpdateAfterBindSamplers(),
+      maxPerStageDescriptorUpdateAfterBindUniformBuffers(),
+      maxPerStageDescriptorUpdateAfterBindStorageBuffers(),
+      maxPerStageDescriptorUpdateAfterBindSampledImages(),
+      maxPerStageDescriptorUpdateAfterBindStorageImages(),
+      maxPerStageDescriptorUpdateAfterBindInputAttachments(),
+      maxPerStageUpdateAfterBindResources(),
+      maxDescriptorSetUpdateAfterBindSamplers(),
+      maxDescriptorSetUpdateAfterBindUniformBuffers(),
+      maxDescriptorSetUpdateAfterBindUniformBuffersDynamic(),
+      maxDescriptorSetUpdateAfterBindStorageBuffers(),
+      maxDescriptorSetUpdateAfterBindStorageBuffersDynamic(),
+      maxDescriptorSetUpdateAfterBindSampledImages(),
+      maxDescriptorSetUpdateAfterBindStorageImages(),
+      maxDescriptorSetUpdateAfterBindInputAttachments(),
+      supportedDepthResolveModes(),
+      supportedStencilResolveModes(),
+      independentResolveNone(),
+      independentResolve(),
+      filterMinmaxSingleComponentFormats(),
+      filterMinmaxImageComponentMapping(),
+      maxTimelineSemaphoreValueDifference(),
+      framebufferIntegerColorSampleCounts() {}
+
+safe_VkPhysicalDeviceVulkan12Properties::safe_VkPhysicalDeviceVulkan12Properties(
+    const safe_VkPhysicalDeviceVulkan12Properties& copy_src) {
+    sType = copy_src.sType;
+    driverID = copy_src.driverID;
+    conformanceVersion = copy_src.conformanceVersion;
+    denormBehaviorIndependence = copy_src.denormBehaviorIndependence;
+    roundingModeIndependence = copy_src.roundingModeIndependence;
+    shaderSignedZeroInfNanPreserveFloat16 = copy_src.shaderSignedZeroInfNanPreserveFloat16;
+    shaderSignedZeroInfNanPreserveFloat32 = copy_src.shaderSignedZeroInfNanPreserveFloat32;
+    shaderSignedZeroInfNanPreserveFloat64 = copy_src.shaderSignedZeroInfNanPreserveFloat64;
+    shaderDenormPreserveFloat16 = copy_src.shaderDenormPreserveFloat16;
+    shaderDenormPreserveFloat32 = copy_src.shaderDenormPreserveFloat32;
+    shaderDenormPreserveFloat64 = copy_src.shaderDenormPreserveFloat64;
+    shaderDenormFlushToZeroFloat16 = copy_src.shaderDenormFlushToZeroFloat16;
+    shaderDenormFlushToZeroFloat32 = copy_src.shaderDenormFlushToZeroFloat32;
+    shaderDenormFlushToZeroFloat64 = copy_src.shaderDenormFlushToZeroFloat64;
+    shaderRoundingModeRTEFloat16 = copy_src.shaderRoundingModeRTEFloat16;
+    shaderRoundingModeRTEFloat32 = copy_src.shaderRoundingModeRTEFloat32;
+    shaderRoundingModeRTEFloat64 = copy_src.shaderRoundingModeRTEFloat64;
+    shaderRoundingModeRTZFloat16 = copy_src.shaderRoundingModeRTZFloat16;
+    shaderRoundingModeRTZFloat32 = copy_src.shaderRoundingModeRTZFloat32;
+    shaderRoundingModeRTZFloat64 = copy_src.shaderRoundingModeRTZFloat64;
+    maxUpdateAfterBindDescriptorsInAllPools = copy_src.maxUpdateAfterBindDescriptorsInAllPools;
+    shaderUniformBufferArrayNonUniformIndexingNative = copy_src.shaderUniformBufferArrayNonUniformIndexingNative;
+    shaderSampledImageArrayNonUniformIndexingNative = copy_src.shaderSampledImageArrayNonUniformIndexingNative;
+    shaderStorageBufferArrayNonUniformIndexingNative = copy_src.shaderStorageBufferArrayNonUniformIndexingNative;
+    shaderStorageImageArrayNonUniformIndexingNative = copy_src.shaderStorageImageArrayNonUniformIndexingNative;
+    shaderInputAttachmentArrayNonUniformIndexingNative = copy_src.shaderInputAttachmentArrayNonUniformIndexingNative;
+    robustBufferAccessUpdateAfterBind = copy_src.robustBufferAccessUpdateAfterBind;
+    quadDivergentImplicitLod = copy_src.quadDivergentImplicitLod;
+    maxPerStageDescriptorUpdateAfterBindSamplers = copy_src.maxPerStageDescriptorUpdateAfterBindSamplers;
+    maxPerStageDescriptorUpdateAfterBindUniformBuffers = copy_src.maxPerStageDescriptorUpdateAfterBindUniformBuffers;
+    maxPerStageDescriptorUpdateAfterBindStorageBuffers = copy_src.maxPerStageDescriptorUpdateAfterBindStorageBuffers;
+    maxPerStageDescriptorUpdateAfterBindSampledImages = copy_src.maxPerStageDescriptorUpdateAfterBindSampledImages;
+    maxPerStageDescriptorUpdateAfterBindStorageImages = copy_src.maxPerStageDescriptorUpdateAfterBindStorageImages;
+    maxPerStageDescriptorUpdateAfterBindInputAttachments = copy_src.maxPerStageDescriptorUpdateAfterBindInputAttachments;
+    maxPerStageUpdateAfterBindResources = copy_src.maxPerStageUpdateAfterBindResources;
+    maxDescriptorSetUpdateAfterBindSamplers = copy_src.maxDescriptorSetUpdateAfterBindSamplers;
+    maxDescriptorSetUpdateAfterBindUniformBuffers = copy_src.maxDescriptorSetUpdateAfterBindUniformBuffers;
+    maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = copy_src.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
+    maxDescriptorSetUpdateAfterBindStorageBuffers = copy_src.maxDescriptorSetUpdateAfterBindStorageBuffers;
+    maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = copy_src.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
+    maxDescriptorSetUpdateAfterBindSampledImages = copy_src.maxDescriptorSetUpdateAfterBindSampledImages;
+    maxDescriptorSetUpdateAfterBindStorageImages = copy_src.maxDescriptorSetUpdateAfterBindStorageImages;
+    maxDescriptorSetUpdateAfterBindInputAttachments = copy_src.maxDescriptorSetUpdateAfterBindInputAttachments;
+    supportedDepthResolveModes = copy_src.supportedDepthResolveModes;
+    supportedStencilResolveModes = copy_src.supportedStencilResolveModes;
+    independentResolveNone = copy_src.independentResolveNone;
+    independentResolve = copy_src.independentResolve;
+    filterMinmaxSingleComponentFormats = copy_src.filterMinmaxSingleComponentFormats;
+    filterMinmaxImageComponentMapping = copy_src.filterMinmaxImageComponentMapping;
+    maxTimelineSemaphoreValueDifference = copy_src.maxTimelineSemaphoreValueDifference;
+    framebufferIntegerColorSampleCounts = copy_src.framebufferIntegerColorSampleCounts;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) {
+        driverName[i] = copy_src.driverName[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) {
+        driverInfo[i] = copy_src.driverInfo[i];
+    }
+}
+
+safe_VkPhysicalDeviceVulkan12Properties& safe_VkPhysicalDeviceVulkan12Properties::operator=(
+    const safe_VkPhysicalDeviceVulkan12Properties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    driverID = copy_src.driverID;
+    conformanceVersion = copy_src.conformanceVersion;
+    denormBehaviorIndependence = copy_src.denormBehaviorIndependence;
+    roundingModeIndependence = copy_src.roundingModeIndependence;
+    shaderSignedZeroInfNanPreserveFloat16 = copy_src.shaderSignedZeroInfNanPreserveFloat16;
+    shaderSignedZeroInfNanPreserveFloat32 = copy_src.shaderSignedZeroInfNanPreserveFloat32;
+    shaderSignedZeroInfNanPreserveFloat64 = copy_src.shaderSignedZeroInfNanPreserveFloat64;
+    shaderDenormPreserveFloat16 = copy_src.shaderDenormPreserveFloat16;
+    shaderDenormPreserveFloat32 = copy_src.shaderDenormPreserveFloat32;
+    shaderDenormPreserveFloat64 = copy_src.shaderDenormPreserveFloat64;
+    shaderDenormFlushToZeroFloat16 = copy_src.shaderDenormFlushToZeroFloat16;
+    shaderDenormFlushToZeroFloat32 = copy_src.shaderDenormFlushToZeroFloat32;
+    shaderDenormFlushToZeroFloat64 = copy_src.shaderDenormFlushToZeroFloat64;
+    shaderRoundingModeRTEFloat16 = copy_src.shaderRoundingModeRTEFloat16;
+    shaderRoundingModeRTEFloat32 = copy_src.shaderRoundingModeRTEFloat32;
+    shaderRoundingModeRTEFloat64 = copy_src.shaderRoundingModeRTEFloat64;
+    shaderRoundingModeRTZFloat16 = copy_src.shaderRoundingModeRTZFloat16;
+    shaderRoundingModeRTZFloat32 = copy_src.shaderRoundingModeRTZFloat32;
+    shaderRoundingModeRTZFloat64 = copy_src.shaderRoundingModeRTZFloat64;
+    maxUpdateAfterBindDescriptorsInAllPools = copy_src.maxUpdateAfterBindDescriptorsInAllPools;
+    shaderUniformBufferArrayNonUniformIndexingNative = copy_src.shaderUniformBufferArrayNonUniformIndexingNative;
+    shaderSampledImageArrayNonUniformIndexingNative = copy_src.shaderSampledImageArrayNonUniformIndexingNative;
+    shaderStorageBufferArrayNonUniformIndexingNative = copy_src.shaderStorageBufferArrayNonUniformIndexingNative;
+    shaderStorageImageArrayNonUniformIndexingNative = copy_src.shaderStorageImageArrayNonUniformIndexingNative;
+    shaderInputAttachmentArrayNonUniformIndexingNative = copy_src.shaderInputAttachmentArrayNonUniformIndexingNative;
+    robustBufferAccessUpdateAfterBind = copy_src.robustBufferAccessUpdateAfterBind;
+    quadDivergentImplicitLod = copy_src.quadDivergentImplicitLod;
+    maxPerStageDescriptorUpdateAfterBindSamplers = copy_src.maxPerStageDescriptorUpdateAfterBindSamplers;
+    maxPerStageDescriptorUpdateAfterBindUniformBuffers = copy_src.maxPerStageDescriptorUpdateAfterBindUniformBuffers;
+    maxPerStageDescriptorUpdateAfterBindStorageBuffers = copy_src.maxPerStageDescriptorUpdateAfterBindStorageBuffers;
+    maxPerStageDescriptorUpdateAfterBindSampledImages = copy_src.maxPerStageDescriptorUpdateAfterBindSampledImages;
+    maxPerStageDescriptorUpdateAfterBindStorageImages = copy_src.maxPerStageDescriptorUpdateAfterBindStorageImages;
+    maxPerStageDescriptorUpdateAfterBindInputAttachments = copy_src.maxPerStageDescriptorUpdateAfterBindInputAttachments;
+    maxPerStageUpdateAfterBindResources = copy_src.maxPerStageUpdateAfterBindResources;
+    maxDescriptorSetUpdateAfterBindSamplers = copy_src.maxDescriptorSetUpdateAfterBindSamplers;
+    maxDescriptorSetUpdateAfterBindUniformBuffers = copy_src.maxDescriptorSetUpdateAfterBindUniformBuffers;
+    maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = copy_src.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
+    maxDescriptorSetUpdateAfterBindStorageBuffers = copy_src.maxDescriptorSetUpdateAfterBindStorageBuffers;
+    maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = copy_src.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
+    maxDescriptorSetUpdateAfterBindSampledImages = copy_src.maxDescriptorSetUpdateAfterBindSampledImages;
+    maxDescriptorSetUpdateAfterBindStorageImages = copy_src.maxDescriptorSetUpdateAfterBindStorageImages;
+    maxDescriptorSetUpdateAfterBindInputAttachments = copy_src.maxDescriptorSetUpdateAfterBindInputAttachments;
+    supportedDepthResolveModes = copy_src.supportedDepthResolveModes;
+    supportedStencilResolveModes = copy_src.supportedStencilResolveModes;
+    independentResolveNone = copy_src.independentResolveNone;
+    independentResolve = copy_src.independentResolve;
+    filterMinmaxSingleComponentFormats = copy_src.filterMinmaxSingleComponentFormats;
+    filterMinmaxImageComponentMapping = copy_src.filterMinmaxImageComponentMapping;
+    maxTimelineSemaphoreValueDifference = copy_src.maxTimelineSemaphoreValueDifference;
+    framebufferIntegerColorSampleCounts = copy_src.framebufferIntegerColorSampleCounts;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) {
+        driverName[i] = copy_src.driverName[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) {
+        driverInfo[i] = copy_src.driverInfo[i];
+    }
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceVulkan12Properties::~safe_VkPhysicalDeviceVulkan12Properties() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceVulkan12Properties::initialize(const VkPhysicalDeviceVulkan12Properties* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    driverID = in_struct->driverID;
+    conformanceVersion = in_struct->conformanceVersion;
+    denormBehaviorIndependence = in_struct->denormBehaviorIndependence;
+    roundingModeIndependence = in_struct->roundingModeIndependence;
+    shaderSignedZeroInfNanPreserveFloat16 = in_struct->shaderSignedZeroInfNanPreserveFloat16;
+    shaderSignedZeroInfNanPreserveFloat32 = in_struct->shaderSignedZeroInfNanPreserveFloat32;
+    shaderSignedZeroInfNanPreserveFloat64 = in_struct->shaderSignedZeroInfNanPreserveFloat64;
+    shaderDenormPreserveFloat16 = in_struct->shaderDenormPreserveFloat16;
+    shaderDenormPreserveFloat32 = in_struct->shaderDenormPreserveFloat32;
+    shaderDenormPreserveFloat64 = in_struct->shaderDenormPreserveFloat64;
+    shaderDenormFlushToZeroFloat16 = in_struct->shaderDenormFlushToZeroFloat16;
+    shaderDenormFlushToZeroFloat32 = in_struct->shaderDenormFlushToZeroFloat32;
+    shaderDenormFlushToZeroFloat64 = in_struct->shaderDenormFlushToZeroFloat64;
+    shaderRoundingModeRTEFloat16 = in_struct->shaderRoundingModeRTEFloat16;
+    shaderRoundingModeRTEFloat32 = in_struct->shaderRoundingModeRTEFloat32;
+    shaderRoundingModeRTEFloat64 = in_struct->shaderRoundingModeRTEFloat64;
+    shaderRoundingModeRTZFloat16 = in_struct->shaderRoundingModeRTZFloat16;
+    shaderRoundingModeRTZFloat32 = in_struct->shaderRoundingModeRTZFloat32;
+    shaderRoundingModeRTZFloat64 = in_struct->shaderRoundingModeRTZFloat64;
+    maxUpdateAfterBindDescriptorsInAllPools = in_struct->maxUpdateAfterBindDescriptorsInAllPools;
+    shaderUniformBufferArrayNonUniformIndexingNative = in_struct->shaderUniformBufferArrayNonUniformIndexingNative;
+    shaderSampledImageArrayNonUniformIndexingNative = in_struct->shaderSampledImageArrayNonUniformIndexingNative;
+    shaderStorageBufferArrayNonUniformIndexingNative = in_struct->shaderStorageBufferArrayNonUniformIndexingNative;
+    shaderStorageImageArrayNonUniformIndexingNative = in_struct->shaderStorageImageArrayNonUniformIndexingNative;
+    shaderInputAttachmentArrayNonUniformIndexingNative = in_struct->shaderInputAttachmentArrayNonUniformIndexingNative;
+    robustBufferAccessUpdateAfterBind = in_struct->robustBufferAccessUpdateAfterBind;
+    quadDivergentImplicitLod = in_struct->quadDivergentImplicitLod;
+    maxPerStageDescriptorUpdateAfterBindSamplers = in_struct->maxPerStageDescriptorUpdateAfterBindSamplers;
+    maxPerStageDescriptorUpdateAfterBindUniformBuffers = in_struct->maxPerStageDescriptorUpdateAfterBindUniformBuffers;
+    maxPerStageDescriptorUpdateAfterBindStorageBuffers = in_struct->maxPerStageDescriptorUpdateAfterBindStorageBuffers;
+    maxPerStageDescriptorUpdateAfterBindSampledImages = in_struct->maxPerStageDescriptorUpdateAfterBindSampledImages;
+    maxPerStageDescriptorUpdateAfterBindStorageImages = in_struct->maxPerStageDescriptorUpdateAfterBindStorageImages;
+    maxPerStageDescriptorUpdateAfterBindInputAttachments = in_struct->maxPerStageDescriptorUpdateAfterBindInputAttachments;
+    maxPerStageUpdateAfterBindResources = in_struct->maxPerStageUpdateAfterBindResources;
+    maxDescriptorSetUpdateAfterBindSamplers = in_struct->maxDescriptorSetUpdateAfterBindSamplers;
+    maxDescriptorSetUpdateAfterBindUniformBuffers = in_struct->maxDescriptorSetUpdateAfterBindUniformBuffers;
+    maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = in_struct->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
+    maxDescriptorSetUpdateAfterBindStorageBuffers = in_struct->maxDescriptorSetUpdateAfterBindStorageBuffers;
+    maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = in_struct->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
+    maxDescriptorSetUpdateAfterBindSampledImages = in_struct->maxDescriptorSetUpdateAfterBindSampledImages;
+    maxDescriptorSetUpdateAfterBindStorageImages = in_struct->maxDescriptorSetUpdateAfterBindStorageImages;
+    maxDescriptorSetUpdateAfterBindInputAttachments = in_struct->maxDescriptorSetUpdateAfterBindInputAttachments;
+    supportedDepthResolveModes = in_struct->supportedDepthResolveModes;
+    supportedStencilResolveModes = in_struct->supportedStencilResolveModes;
+    independentResolveNone = in_struct->independentResolveNone;
+    independentResolve = in_struct->independentResolve;
+    filterMinmaxSingleComponentFormats = in_struct->filterMinmaxSingleComponentFormats;
+    filterMinmaxImageComponentMapping = in_struct->filterMinmaxImageComponentMapping;
+    maxTimelineSemaphoreValueDifference = in_struct->maxTimelineSemaphoreValueDifference;
+    framebufferIntegerColorSampleCounts = in_struct->framebufferIntegerColorSampleCounts;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) {
+        driverName[i] = in_struct->driverName[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) {
+        driverInfo[i] = in_struct->driverInfo[i];
+    }
+}
+
+void safe_VkPhysicalDeviceVulkan12Properties::initialize(const safe_VkPhysicalDeviceVulkan12Properties* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    driverID = copy_src->driverID;
+    conformanceVersion = copy_src->conformanceVersion;
+    denormBehaviorIndependence = copy_src->denormBehaviorIndependence;
+    roundingModeIndependence = copy_src->roundingModeIndependence;
+    shaderSignedZeroInfNanPreserveFloat16 = copy_src->shaderSignedZeroInfNanPreserveFloat16;
+    shaderSignedZeroInfNanPreserveFloat32 = copy_src->shaderSignedZeroInfNanPreserveFloat32;
+    shaderSignedZeroInfNanPreserveFloat64 = copy_src->shaderSignedZeroInfNanPreserveFloat64;
+    shaderDenormPreserveFloat16 = copy_src->shaderDenormPreserveFloat16;
+    shaderDenormPreserveFloat32 = copy_src->shaderDenormPreserveFloat32;
+    shaderDenormPreserveFloat64 = copy_src->shaderDenormPreserveFloat64;
+    shaderDenormFlushToZeroFloat16 = copy_src->shaderDenormFlushToZeroFloat16;
+    shaderDenormFlushToZeroFloat32 = copy_src->shaderDenormFlushToZeroFloat32;
+    shaderDenormFlushToZeroFloat64 = copy_src->shaderDenormFlushToZeroFloat64;
+    shaderRoundingModeRTEFloat16 = copy_src->shaderRoundingModeRTEFloat16;
+    shaderRoundingModeRTEFloat32 = copy_src->shaderRoundingModeRTEFloat32;
+    shaderRoundingModeRTEFloat64 = copy_src->shaderRoundingModeRTEFloat64;
+    shaderRoundingModeRTZFloat16 = copy_src->shaderRoundingModeRTZFloat16;
+    shaderRoundingModeRTZFloat32 = copy_src->shaderRoundingModeRTZFloat32;
+    shaderRoundingModeRTZFloat64 = copy_src->shaderRoundingModeRTZFloat64;
+    maxUpdateAfterBindDescriptorsInAllPools = copy_src->maxUpdateAfterBindDescriptorsInAllPools;
+    shaderUniformBufferArrayNonUniformIndexingNative = copy_src->shaderUniformBufferArrayNonUniformIndexingNative;
+    shaderSampledImageArrayNonUniformIndexingNative = copy_src->shaderSampledImageArrayNonUniformIndexingNative;
+    shaderStorageBufferArrayNonUniformIndexingNative = copy_src->shaderStorageBufferArrayNonUniformIndexingNative;
+    shaderStorageImageArrayNonUniformIndexingNative = copy_src->shaderStorageImageArrayNonUniformIndexingNative;
+    shaderInputAttachmentArrayNonUniformIndexingNative = copy_src->shaderInputAttachmentArrayNonUniformIndexingNative;
+    robustBufferAccessUpdateAfterBind = copy_src->robustBufferAccessUpdateAfterBind;
+    quadDivergentImplicitLod = copy_src->quadDivergentImplicitLod;
+    maxPerStageDescriptorUpdateAfterBindSamplers = copy_src->maxPerStageDescriptorUpdateAfterBindSamplers;
+    maxPerStageDescriptorUpdateAfterBindUniformBuffers = copy_src->maxPerStageDescriptorUpdateAfterBindUniformBuffers;
+    maxPerStageDescriptorUpdateAfterBindStorageBuffers = copy_src->maxPerStageDescriptorUpdateAfterBindStorageBuffers;
+    maxPerStageDescriptorUpdateAfterBindSampledImages = copy_src->maxPerStageDescriptorUpdateAfterBindSampledImages;
+    maxPerStageDescriptorUpdateAfterBindStorageImages = copy_src->maxPerStageDescriptorUpdateAfterBindStorageImages;
+    maxPerStageDescriptorUpdateAfterBindInputAttachments = copy_src->maxPerStageDescriptorUpdateAfterBindInputAttachments;
+    maxPerStageUpdateAfterBindResources = copy_src->maxPerStageUpdateAfterBindResources;
+    maxDescriptorSetUpdateAfterBindSamplers = copy_src->maxDescriptorSetUpdateAfterBindSamplers;
+    maxDescriptorSetUpdateAfterBindUniformBuffers = copy_src->maxDescriptorSetUpdateAfterBindUniformBuffers;
+    maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = copy_src->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
+    maxDescriptorSetUpdateAfterBindStorageBuffers = copy_src->maxDescriptorSetUpdateAfterBindStorageBuffers;
+    maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = copy_src->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
+    maxDescriptorSetUpdateAfterBindSampledImages = copy_src->maxDescriptorSetUpdateAfterBindSampledImages;
+    maxDescriptorSetUpdateAfterBindStorageImages = copy_src->maxDescriptorSetUpdateAfterBindStorageImages;
+    maxDescriptorSetUpdateAfterBindInputAttachments = copy_src->maxDescriptorSetUpdateAfterBindInputAttachments;
+    supportedDepthResolveModes = copy_src->supportedDepthResolveModes;
+    supportedStencilResolveModes = copy_src->supportedStencilResolveModes;
+    independentResolveNone = copy_src->independentResolveNone;
+    independentResolve = copy_src->independentResolve;
+    filterMinmaxSingleComponentFormats = copy_src->filterMinmaxSingleComponentFormats;
+    filterMinmaxImageComponentMapping = copy_src->filterMinmaxImageComponentMapping;
+    maxTimelineSemaphoreValueDifference = copy_src->maxTimelineSemaphoreValueDifference;
+    framebufferIntegerColorSampleCounts = copy_src->framebufferIntegerColorSampleCounts;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) {
+        driverName[i] = copy_src->driverName[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) {
+        driverInfo[i] = copy_src->driverInfo[i];
+    }
+}
+
+safe_VkImageFormatListCreateInfo::safe_VkImageFormatListCreateInfo(const VkImageFormatListCreateInfo* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), viewFormatCount(in_struct->viewFormatCount), pViewFormats(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pViewFormats) {
+        pViewFormats = new VkFormat[in_struct->viewFormatCount];
+        memcpy((void*)pViewFormats, (void*)in_struct->pViewFormats, sizeof(VkFormat) * in_struct->viewFormatCount);
+    }
+}
+
+safe_VkImageFormatListCreateInfo::safe_VkImageFormatListCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO), pNext(nullptr), viewFormatCount(), pViewFormats(nullptr) {}
+
+safe_VkImageFormatListCreateInfo::safe_VkImageFormatListCreateInfo(const safe_VkImageFormatListCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    viewFormatCount = copy_src.viewFormatCount;
+    pViewFormats = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pViewFormats) {
+        pViewFormats = new VkFormat[copy_src.viewFormatCount];
+        memcpy((void*)pViewFormats, (void*)copy_src.pViewFormats, sizeof(VkFormat) * copy_src.viewFormatCount);
+    }
+}
+
+safe_VkImageFormatListCreateInfo& safe_VkImageFormatListCreateInfo::operator=(const safe_VkImageFormatListCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pViewFormats) delete[] pViewFormats;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    viewFormatCount = copy_src.viewFormatCount;
+    pViewFormats = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pViewFormats) {
+        pViewFormats = new VkFormat[copy_src.viewFormatCount];
+        memcpy((void*)pViewFormats, (void*)copy_src.pViewFormats, sizeof(VkFormat) * copy_src.viewFormatCount);
+    }
+
+    return *this;
+}
+
+safe_VkImageFormatListCreateInfo::~safe_VkImageFormatListCreateInfo() {
+    if (pViewFormats) delete[] pViewFormats;
+    FreePnextChain(pNext);
+}
+
+void safe_VkImageFormatListCreateInfo::initialize(const VkImageFormatListCreateInfo* in_struct,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pViewFormats) delete[] pViewFormats;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    viewFormatCount = in_struct->viewFormatCount;
+    pViewFormats = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pViewFormats) {
+        pViewFormats = new VkFormat[in_struct->viewFormatCount];
+        memcpy((void*)pViewFormats, (void*)in_struct->pViewFormats, sizeof(VkFormat) * in_struct->viewFormatCount);
+    }
+}
+
+void safe_VkImageFormatListCreateInfo::initialize(const safe_VkImageFormatListCreateInfo* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    viewFormatCount = copy_src->viewFormatCount;
+    pViewFormats = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pViewFormats) {
+        pViewFormats = new VkFormat[copy_src->viewFormatCount];
+        memcpy((void*)pViewFormats, (void*)copy_src->pViewFormats, sizeof(VkFormat) * copy_src->viewFormatCount);
+    }
+}
+
+safe_VkAttachmentDescription2::safe_VkAttachmentDescription2(const VkAttachmentDescription2* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      format(in_struct->format),
+      samples(in_struct->samples),
+      loadOp(in_struct->loadOp),
+      storeOp(in_struct->storeOp),
+      stencilLoadOp(in_struct->stencilLoadOp),
+      stencilStoreOp(in_struct->stencilStoreOp),
+      initialLayout(in_struct->initialLayout),
+      finalLayout(in_struct->finalLayout) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkAttachmentDescription2::safe_VkAttachmentDescription2()
+    : sType(VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2),
+      pNext(nullptr),
+      flags(),
+      format(),
+      samples(),
+      loadOp(),
+      storeOp(),
+      stencilLoadOp(),
+      stencilStoreOp(),
+      initialLayout(),
+      finalLayout() {}
+
+safe_VkAttachmentDescription2::safe_VkAttachmentDescription2(const safe_VkAttachmentDescription2& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    format = copy_src.format;
+    samples = copy_src.samples;
+    loadOp = copy_src.loadOp;
+    storeOp = copy_src.storeOp;
+    stencilLoadOp = copy_src.stencilLoadOp;
+    stencilStoreOp = copy_src.stencilStoreOp;
+    initialLayout = copy_src.initialLayout;
+    finalLayout = copy_src.finalLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkAttachmentDescription2& safe_VkAttachmentDescription2::operator=(const safe_VkAttachmentDescription2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    format = copy_src.format;
+    samples = copy_src.samples;
+    loadOp = copy_src.loadOp;
+    storeOp = copy_src.storeOp;
+    stencilLoadOp = copy_src.stencilLoadOp;
+    stencilStoreOp = copy_src.stencilStoreOp;
+    initialLayout = copy_src.initialLayout;
+    finalLayout = copy_src.finalLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkAttachmentDescription2::~safe_VkAttachmentDescription2() { FreePnextChain(pNext); }
+
+void safe_VkAttachmentDescription2::initialize(const VkAttachmentDescription2* in_struct,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    format = in_struct->format;
+    samples = in_struct->samples;
+    loadOp = in_struct->loadOp;
+    storeOp = in_struct->storeOp;
+    stencilLoadOp = in_struct->stencilLoadOp;
+    stencilStoreOp = in_struct->stencilStoreOp;
+    initialLayout = in_struct->initialLayout;
+    finalLayout = in_struct->finalLayout;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkAttachmentDescription2::initialize(const safe_VkAttachmentDescription2* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    format = copy_src->format;
+    samples = copy_src->samples;
+    loadOp = copy_src->loadOp;
+    storeOp = copy_src->storeOp;
+    stencilLoadOp = copy_src->stencilLoadOp;
+    stencilStoreOp = copy_src->stencilStoreOp;
+    initialLayout = copy_src->initialLayout;
+    finalLayout = copy_src->finalLayout;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkAttachmentReference2::safe_VkAttachmentReference2(const VkAttachmentReference2* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), attachment(in_struct->attachment), layout(in_struct->layout), aspectMask(in_struct->aspectMask) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkAttachmentReference2::safe_VkAttachmentReference2()
+    : sType(VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2), pNext(nullptr), attachment(), layout(), aspectMask() {}
+
+safe_VkAttachmentReference2::safe_VkAttachmentReference2(const safe_VkAttachmentReference2& copy_src) {
+    sType = copy_src.sType;
+    attachment = copy_src.attachment;
+    layout = copy_src.layout;
+    aspectMask = copy_src.aspectMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkAttachmentReference2& safe_VkAttachmentReference2::operator=(const safe_VkAttachmentReference2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    attachment = copy_src.attachment;
+    layout = copy_src.layout;
+    aspectMask = copy_src.aspectMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkAttachmentReference2::~safe_VkAttachmentReference2() { FreePnextChain(pNext); }
+
+void safe_VkAttachmentReference2::initialize(const VkAttachmentReference2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    attachment = in_struct->attachment;
+    layout = in_struct->layout;
+    aspectMask = in_struct->aspectMask;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkAttachmentReference2::initialize(const safe_VkAttachmentReference2* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    attachment = copy_src->attachment;
+    layout = copy_src->layout;
+    aspectMask = copy_src->aspectMask;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSubpassDescription2::safe_VkSubpassDescription2(const VkSubpassDescription2* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      pipelineBindPoint(in_struct->pipelineBindPoint),
+      viewMask(in_struct->viewMask),
+      inputAttachmentCount(in_struct->inputAttachmentCount),
+      pInputAttachments(nullptr),
+      colorAttachmentCount(in_struct->colorAttachmentCount),
+      pColorAttachments(nullptr),
+      pResolveAttachments(nullptr),
+      pDepthStencilAttachment(nullptr),
+      preserveAttachmentCount(in_struct->preserveAttachmentCount),
+      pPreserveAttachments(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (inputAttachmentCount && in_struct->pInputAttachments) {
+        pInputAttachments = new safe_VkAttachmentReference2[inputAttachmentCount];
+        for (uint32_t i = 0; i < inputAttachmentCount; ++i) {
+            pInputAttachments[i].initialize(&in_struct->pInputAttachments[i]);
+        }
+    }
+    if (colorAttachmentCount && in_struct->pColorAttachments) {
+        pColorAttachments = new safe_VkAttachmentReference2[colorAttachmentCount];
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
+            pColorAttachments[i].initialize(&in_struct->pColorAttachments[i]);
+        }
+    }
+    if (colorAttachmentCount && in_struct->pResolveAttachments) {
+        pResolveAttachments = new safe_VkAttachmentReference2[colorAttachmentCount];
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
+            pResolveAttachments[i].initialize(&in_struct->pResolveAttachments[i]);
+        }
+    }
+    if (in_struct->pDepthStencilAttachment)
+        pDepthStencilAttachment = new safe_VkAttachmentReference2(in_struct->pDepthStencilAttachment);
+
+    if (in_struct->pPreserveAttachments) {
+        pPreserveAttachments = new uint32_t[in_struct->preserveAttachmentCount];
+        memcpy((void*)pPreserveAttachments, (void*)in_struct->pPreserveAttachments,
+               sizeof(uint32_t) * in_struct->preserveAttachmentCount);
+    }
+}
+
+safe_VkSubpassDescription2::safe_VkSubpassDescription2()
+    : sType(VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2),
+      pNext(nullptr),
+      flags(),
+      pipelineBindPoint(),
+      viewMask(),
+      inputAttachmentCount(),
+      pInputAttachments(nullptr),
+      colorAttachmentCount(),
+      pColorAttachments(nullptr),
+      pResolveAttachments(nullptr),
+      pDepthStencilAttachment(nullptr),
+      preserveAttachmentCount(),
+      pPreserveAttachments(nullptr) {}
+
+safe_VkSubpassDescription2::safe_VkSubpassDescription2(const safe_VkSubpassDescription2& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pipelineBindPoint = copy_src.pipelineBindPoint;
+    viewMask = copy_src.viewMask;
+    inputAttachmentCount = copy_src.inputAttachmentCount;
+    pInputAttachments = nullptr;
+    colorAttachmentCount = copy_src.colorAttachmentCount;
+    pColorAttachments = nullptr;
+    pResolveAttachments = nullptr;
+    pDepthStencilAttachment = nullptr;
+    preserveAttachmentCount = copy_src.preserveAttachmentCount;
+    pPreserveAttachments = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (inputAttachmentCount && copy_src.pInputAttachments) {
+        pInputAttachments = new safe_VkAttachmentReference2[inputAttachmentCount];
+        for (uint32_t i = 0; i < inputAttachmentCount; ++i) {
+            pInputAttachments[i].initialize(&copy_src.pInputAttachments[i]);
+        }
+    }
+    if (colorAttachmentCount && copy_src.pColorAttachments) {
+        pColorAttachments = new safe_VkAttachmentReference2[colorAttachmentCount];
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
+            pColorAttachments[i].initialize(&copy_src.pColorAttachments[i]);
+        }
+    }
+    if (colorAttachmentCount && copy_src.pResolveAttachments) {
+        pResolveAttachments = new safe_VkAttachmentReference2[colorAttachmentCount];
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
+            pResolveAttachments[i].initialize(&copy_src.pResolveAttachments[i]);
+        }
+    }
+    if (copy_src.pDepthStencilAttachment)
+        pDepthStencilAttachment = new safe_VkAttachmentReference2(*copy_src.pDepthStencilAttachment);
+
+    if (copy_src.pPreserveAttachments) {
+        pPreserveAttachments = new uint32_t[copy_src.preserveAttachmentCount];
+        memcpy((void*)pPreserveAttachments, (void*)copy_src.pPreserveAttachments,
+               sizeof(uint32_t) * copy_src.preserveAttachmentCount);
+    }
+}
+
+safe_VkSubpassDescription2& safe_VkSubpassDescription2::operator=(const safe_VkSubpassDescription2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pInputAttachments) delete[] pInputAttachments;
+    if (pColorAttachments) delete[] pColorAttachments;
+    if (pResolveAttachments) delete[] pResolveAttachments;
+    if (pDepthStencilAttachment) delete pDepthStencilAttachment;
+    if (pPreserveAttachments) delete[] pPreserveAttachments;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pipelineBindPoint = copy_src.pipelineBindPoint;
+    viewMask = copy_src.viewMask;
+    inputAttachmentCount = copy_src.inputAttachmentCount;
+    pInputAttachments = nullptr;
+    colorAttachmentCount = copy_src.colorAttachmentCount;
+    pColorAttachments = nullptr;
+    pResolveAttachments = nullptr;
+    pDepthStencilAttachment = nullptr;
+    preserveAttachmentCount = copy_src.preserveAttachmentCount;
+    pPreserveAttachments = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (inputAttachmentCount && copy_src.pInputAttachments) {
+        pInputAttachments = new safe_VkAttachmentReference2[inputAttachmentCount];
+        for (uint32_t i = 0; i < inputAttachmentCount; ++i) {
+            pInputAttachments[i].initialize(&copy_src.pInputAttachments[i]);
+        }
+    }
+    if (colorAttachmentCount && copy_src.pColorAttachments) {
+        pColorAttachments = new safe_VkAttachmentReference2[colorAttachmentCount];
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
+            pColorAttachments[i].initialize(&copy_src.pColorAttachments[i]);
+        }
+    }
+    if (colorAttachmentCount && copy_src.pResolveAttachments) {
+        pResolveAttachments = new safe_VkAttachmentReference2[colorAttachmentCount];
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
+            pResolveAttachments[i].initialize(&copy_src.pResolveAttachments[i]);
+        }
+    }
+    if (copy_src.pDepthStencilAttachment)
+        pDepthStencilAttachment = new safe_VkAttachmentReference2(*copy_src.pDepthStencilAttachment);
+
+    if (copy_src.pPreserveAttachments) {
+        pPreserveAttachments = new uint32_t[copy_src.preserveAttachmentCount];
+        memcpy((void*)pPreserveAttachments, (void*)copy_src.pPreserveAttachments,
+               sizeof(uint32_t) * copy_src.preserveAttachmentCount);
+    }
+
+    return *this;
+}
+
+safe_VkSubpassDescription2::~safe_VkSubpassDescription2() {
+    if (pInputAttachments) delete[] pInputAttachments;
+    if (pColorAttachments) delete[] pColorAttachments;
+    if (pResolveAttachments) delete[] pResolveAttachments;
+    if (pDepthStencilAttachment) delete pDepthStencilAttachment;
+    if (pPreserveAttachments) delete[] pPreserveAttachments;
+    FreePnextChain(pNext);
+}
+
+void safe_VkSubpassDescription2::initialize(const VkSubpassDescription2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pInputAttachments) delete[] pInputAttachments;
+    if (pColorAttachments) delete[] pColorAttachments;
+    if (pResolveAttachments) delete[] pResolveAttachments;
+    if (pDepthStencilAttachment) delete pDepthStencilAttachment;
+    if (pPreserveAttachments) delete[] pPreserveAttachments;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    pipelineBindPoint = in_struct->pipelineBindPoint;
+    viewMask = in_struct->viewMask;
+    inputAttachmentCount = in_struct->inputAttachmentCount;
+    pInputAttachments = nullptr;
+    colorAttachmentCount = in_struct->colorAttachmentCount;
+    pColorAttachments = nullptr;
+    pResolveAttachments = nullptr;
+    pDepthStencilAttachment = nullptr;
+    preserveAttachmentCount = in_struct->preserveAttachmentCount;
+    pPreserveAttachments = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (inputAttachmentCount && in_struct->pInputAttachments) {
+        pInputAttachments = new safe_VkAttachmentReference2[inputAttachmentCount];
+        for (uint32_t i = 0; i < inputAttachmentCount; ++i) {
+            pInputAttachments[i].initialize(&in_struct->pInputAttachments[i]);
+        }
+    }
+    if (colorAttachmentCount && in_struct->pColorAttachments) {
+        pColorAttachments = new safe_VkAttachmentReference2[colorAttachmentCount];
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
+            pColorAttachments[i].initialize(&in_struct->pColorAttachments[i]);
+        }
+    }
+    if (colorAttachmentCount && in_struct->pResolveAttachments) {
+        pResolveAttachments = new safe_VkAttachmentReference2[colorAttachmentCount];
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
+            pResolveAttachments[i].initialize(&in_struct->pResolveAttachments[i]);
+        }
+    }
+    if (in_struct->pDepthStencilAttachment)
+        pDepthStencilAttachment = new safe_VkAttachmentReference2(in_struct->pDepthStencilAttachment);
+
+    if (in_struct->pPreserveAttachments) {
+        pPreserveAttachments = new uint32_t[in_struct->preserveAttachmentCount];
+        memcpy((void*)pPreserveAttachments, (void*)in_struct->pPreserveAttachments,
+               sizeof(uint32_t) * in_struct->preserveAttachmentCount);
+    }
+}
+
+void safe_VkSubpassDescription2::initialize(const safe_VkSubpassDescription2* copy_src,
+                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pipelineBindPoint = copy_src->pipelineBindPoint;
+    viewMask = copy_src->viewMask;
+    inputAttachmentCount = copy_src->inputAttachmentCount;
+    pInputAttachments = nullptr;
+    colorAttachmentCount = copy_src->colorAttachmentCount;
+    pColorAttachments = nullptr;
+    pResolveAttachments = nullptr;
+    pDepthStencilAttachment = nullptr;
+    preserveAttachmentCount = copy_src->preserveAttachmentCount;
+    pPreserveAttachments = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (inputAttachmentCount && copy_src->pInputAttachments) {
+        pInputAttachments = new safe_VkAttachmentReference2[inputAttachmentCount];
+        for (uint32_t i = 0; i < inputAttachmentCount; ++i) {
+            pInputAttachments[i].initialize(&copy_src->pInputAttachments[i]);
+        }
+    }
+    if (colorAttachmentCount && copy_src->pColorAttachments) {
+        pColorAttachments = new safe_VkAttachmentReference2[colorAttachmentCount];
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
+            pColorAttachments[i].initialize(&copy_src->pColorAttachments[i]);
+        }
+    }
+    if (colorAttachmentCount && copy_src->pResolveAttachments) {
+        pResolveAttachments = new safe_VkAttachmentReference2[colorAttachmentCount];
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
+            pResolveAttachments[i].initialize(&copy_src->pResolveAttachments[i]);
+        }
+    }
+    if (copy_src->pDepthStencilAttachment)
+        pDepthStencilAttachment = new safe_VkAttachmentReference2(*copy_src->pDepthStencilAttachment);
+
+    if (copy_src->pPreserveAttachments) {
+        pPreserveAttachments = new uint32_t[copy_src->preserveAttachmentCount];
+        memcpy((void*)pPreserveAttachments, (void*)copy_src->pPreserveAttachments,
+               sizeof(uint32_t) * copy_src->preserveAttachmentCount);
+    }
+}
+
+safe_VkSubpassDependency2::safe_VkSubpassDependency2(const VkSubpassDependency2* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      srcSubpass(in_struct->srcSubpass),
+      dstSubpass(in_struct->dstSubpass),
+      srcStageMask(in_struct->srcStageMask),
+      dstStageMask(in_struct->dstStageMask),
+      srcAccessMask(in_struct->srcAccessMask),
+      dstAccessMask(in_struct->dstAccessMask),
+      dependencyFlags(in_struct->dependencyFlags),
+      viewOffset(in_struct->viewOffset) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSubpassDependency2::safe_VkSubpassDependency2()
+    : sType(VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2),
+      pNext(nullptr),
+      srcSubpass(),
+      dstSubpass(),
+      srcStageMask(),
+      dstStageMask(),
+      srcAccessMask(),
+      dstAccessMask(),
+      dependencyFlags(),
+      viewOffset() {}
+
+safe_VkSubpassDependency2::safe_VkSubpassDependency2(const safe_VkSubpassDependency2& copy_src) {
+    sType = copy_src.sType;
+    srcSubpass = copy_src.srcSubpass;
+    dstSubpass = copy_src.dstSubpass;
+    srcStageMask = copy_src.srcStageMask;
+    dstStageMask = copy_src.dstStageMask;
+    srcAccessMask = copy_src.srcAccessMask;
+    dstAccessMask = copy_src.dstAccessMask;
+    dependencyFlags = copy_src.dependencyFlags;
+    viewOffset = copy_src.viewOffset;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSubpassDependency2& safe_VkSubpassDependency2::operator=(const safe_VkSubpassDependency2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    srcSubpass = copy_src.srcSubpass;
+    dstSubpass = copy_src.dstSubpass;
+    srcStageMask = copy_src.srcStageMask;
+    dstStageMask = copy_src.dstStageMask;
+    srcAccessMask = copy_src.srcAccessMask;
+    dstAccessMask = copy_src.dstAccessMask;
+    dependencyFlags = copy_src.dependencyFlags;
+    viewOffset = copy_src.viewOffset;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSubpassDependency2::~safe_VkSubpassDependency2() { FreePnextChain(pNext); }
+
+void safe_VkSubpassDependency2::initialize(const VkSubpassDependency2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    srcSubpass = in_struct->srcSubpass;
+    dstSubpass = in_struct->dstSubpass;
+    srcStageMask = in_struct->srcStageMask;
+    dstStageMask = in_struct->dstStageMask;
+    srcAccessMask = in_struct->srcAccessMask;
+    dstAccessMask = in_struct->dstAccessMask;
+    dependencyFlags = in_struct->dependencyFlags;
+    viewOffset = in_struct->viewOffset;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSubpassDependency2::initialize(const safe_VkSubpassDependency2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    srcSubpass = copy_src->srcSubpass;
+    dstSubpass = copy_src->dstSubpass;
+    srcStageMask = copy_src->srcStageMask;
+    dstStageMask = copy_src->dstStageMask;
+    srcAccessMask = copy_src->srcAccessMask;
+    dstAccessMask = copy_src->dstAccessMask;
+    dependencyFlags = copy_src->dependencyFlags;
+    viewOffset = copy_src->viewOffset;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkRenderPassCreateInfo2::safe_VkRenderPassCreateInfo2(const VkRenderPassCreateInfo2* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      attachmentCount(in_struct->attachmentCount),
+      pAttachments(nullptr),
+      subpassCount(in_struct->subpassCount),
+      pSubpasses(nullptr),
+      dependencyCount(in_struct->dependencyCount),
+      pDependencies(nullptr),
+      correlatedViewMaskCount(in_struct->correlatedViewMaskCount),
+      pCorrelatedViewMasks(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (attachmentCount && in_struct->pAttachments) {
+        pAttachments = new safe_VkAttachmentDescription2[attachmentCount];
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
+            pAttachments[i].initialize(&in_struct->pAttachments[i]);
+        }
+    }
+    if (subpassCount && in_struct->pSubpasses) {
+        pSubpasses = new safe_VkSubpassDescription2[subpassCount];
+        for (uint32_t i = 0; i < subpassCount; ++i) {
+            pSubpasses[i].initialize(&in_struct->pSubpasses[i]);
+        }
+    }
+    if (dependencyCount && in_struct->pDependencies) {
+        pDependencies = new safe_VkSubpassDependency2[dependencyCount];
+        for (uint32_t i = 0; i < dependencyCount; ++i) {
+            pDependencies[i].initialize(&in_struct->pDependencies[i]);
+        }
+    }
+
+    if (in_struct->pCorrelatedViewMasks) {
+        pCorrelatedViewMasks = new uint32_t[in_struct->correlatedViewMaskCount];
+        memcpy((void*)pCorrelatedViewMasks, (void*)in_struct->pCorrelatedViewMasks,
+               sizeof(uint32_t) * in_struct->correlatedViewMaskCount);
+    }
+}
+
+safe_VkRenderPassCreateInfo2::safe_VkRenderPassCreateInfo2()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2),
+      pNext(nullptr),
+      flags(),
+      attachmentCount(),
+      pAttachments(nullptr),
+      subpassCount(),
+      pSubpasses(nullptr),
+      dependencyCount(),
+      pDependencies(nullptr),
+      correlatedViewMaskCount(),
+      pCorrelatedViewMasks(nullptr) {}
+
+safe_VkRenderPassCreateInfo2::safe_VkRenderPassCreateInfo2(const safe_VkRenderPassCreateInfo2& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    attachmentCount = copy_src.attachmentCount;
+    pAttachments = nullptr;
+    subpassCount = copy_src.subpassCount;
+    pSubpasses = nullptr;
+    dependencyCount = copy_src.dependencyCount;
+    pDependencies = nullptr;
+    correlatedViewMaskCount = copy_src.correlatedViewMaskCount;
+    pCorrelatedViewMasks = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (attachmentCount && copy_src.pAttachments) {
+        pAttachments = new safe_VkAttachmentDescription2[attachmentCount];
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
+            pAttachments[i].initialize(&copy_src.pAttachments[i]);
+        }
+    }
+    if (subpassCount && copy_src.pSubpasses) {
+        pSubpasses = new safe_VkSubpassDescription2[subpassCount];
+        for (uint32_t i = 0; i < subpassCount; ++i) {
+            pSubpasses[i].initialize(&copy_src.pSubpasses[i]);
+        }
+    }
+    if (dependencyCount && copy_src.pDependencies) {
+        pDependencies = new safe_VkSubpassDependency2[dependencyCount];
+        for (uint32_t i = 0; i < dependencyCount; ++i) {
+            pDependencies[i].initialize(&copy_src.pDependencies[i]);
+        }
+    }
+
+    if (copy_src.pCorrelatedViewMasks) {
+        pCorrelatedViewMasks = new uint32_t[copy_src.correlatedViewMaskCount];
+        memcpy((void*)pCorrelatedViewMasks, (void*)copy_src.pCorrelatedViewMasks,
+               sizeof(uint32_t) * copy_src.correlatedViewMaskCount);
+    }
+}
+
+safe_VkRenderPassCreateInfo2& safe_VkRenderPassCreateInfo2::operator=(const safe_VkRenderPassCreateInfo2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pAttachments) delete[] pAttachments;
+    if (pSubpasses) delete[] pSubpasses;
+    if (pDependencies) delete[] pDependencies;
+    if (pCorrelatedViewMasks) delete[] pCorrelatedViewMasks;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    attachmentCount = copy_src.attachmentCount;
+    pAttachments = nullptr;
+    subpassCount = copy_src.subpassCount;
+    pSubpasses = nullptr;
+    dependencyCount = copy_src.dependencyCount;
+    pDependencies = nullptr;
+    correlatedViewMaskCount = copy_src.correlatedViewMaskCount;
+    pCorrelatedViewMasks = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (attachmentCount && copy_src.pAttachments) {
+        pAttachments = new safe_VkAttachmentDescription2[attachmentCount];
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
+            pAttachments[i].initialize(&copy_src.pAttachments[i]);
+        }
+    }
+    if (subpassCount && copy_src.pSubpasses) {
+        pSubpasses = new safe_VkSubpassDescription2[subpassCount];
+        for (uint32_t i = 0; i < subpassCount; ++i) {
+            pSubpasses[i].initialize(&copy_src.pSubpasses[i]);
+        }
+    }
+    if (dependencyCount && copy_src.pDependencies) {
+        pDependencies = new safe_VkSubpassDependency2[dependencyCount];
+        for (uint32_t i = 0; i < dependencyCount; ++i) {
+            pDependencies[i].initialize(&copy_src.pDependencies[i]);
+        }
+    }
+
+    if (copy_src.pCorrelatedViewMasks) {
+        pCorrelatedViewMasks = new uint32_t[copy_src.correlatedViewMaskCount];
+        memcpy((void*)pCorrelatedViewMasks, (void*)copy_src.pCorrelatedViewMasks,
+               sizeof(uint32_t) * copy_src.correlatedViewMaskCount);
+    }
+
+    return *this;
+}
+
+safe_VkRenderPassCreateInfo2::~safe_VkRenderPassCreateInfo2() {
+    if (pAttachments) delete[] pAttachments;
+    if (pSubpasses) delete[] pSubpasses;
+    if (pDependencies) delete[] pDependencies;
+    if (pCorrelatedViewMasks) delete[] pCorrelatedViewMasks;
+    FreePnextChain(pNext);
+}
+
+void safe_VkRenderPassCreateInfo2::initialize(const VkRenderPassCreateInfo2* in_struct,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pAttachments) delete[] pAttachments;
+    if (pSubpasses) delete[] pSubpasses;
+    if (pDependencies) delete[] pDependencies;
+    if (pCorrelatedViewMasks) delete[] pCorrelatedViewMasks;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    attachmentCount = in_struct->attachmentCount;
+    pAttachments = nullptr;
+    subpassCount = in_struct->subpassCount;
+    pSubpasses = nullptr;
+    dependencyCount = in_struct->dependencyCount;
+    pDependencies = nullptr;
+    correlatedViewMaskCount = in_struct->correlatedViewMaskCount;
+    pCorrelatedViewMasks = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (attachmentCount && in_struct->pAttachments) {
+        pAttachments = new safe_VkAttachmentDescription2[attachmentCount];
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
+            pAttachments[i].initialize(&in_struct->pAttachments[i]);
+        }
+    }
+    if (subpassCount && in_struct->pSubpasses) {
+        pSubpasses = new safe_VkSubpassDescription2[subpassCount];
+        for (uint32_t i = 0; i < subpassCount; ++i) {
+            pSubpasses[i].initialize(&in_struct->pSubpasses[i]);
+        }
+    }
+    if (dependencyCount && in_struct->pDependencies) {
+        pDependencies = new safe_VkSubpassDependency2[dependencyCount];
+        for (uint32_t i = 0; i < dependencyCount; ++i) {
+            pDependencies[i].initialize(&in_struct->pDependencies[i]);
+        }
+    }
+
+    if (in_struct->pCorrelatedViewMasks) {
+        pCorrelatedViewMasks = new uint32_t[in_struct->correlatedViewMaskCount];
+        memcpy((void*)pCorrelatedViewMasks, (void*)in_struct->pCorrelatedViewMasks,
+               sizeof(uint32_t) * in_struct->correlatedViewMaskCount);
+    }
+}
+
+void safe_VkRenderPassCreateInfo2::initialize(const safe_VkRenderPassCreateInfo2* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    attachmentCount = copy_src->attachmentCount;
+    pAttachments = nullptr;
+    subpassCount = copy_src->subpassCount;
+    pSubpasses = nullptr;
+    dependencyCount = copy_src->dependencyCount;
+    pDependencies = nullptr;
+    correlatedViewMaskCount = copy_src->correlatedViewMaskCount;
+    pCorrelatedViewMasks = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (attachmentCount && copy_src->pAttachments) {
+        pAttachments = new safe_VkAttachmentDescription2[attachmentCount];
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
+            pAttachments[i].initialize(&copy_src->pAttachments[i]);
+        }
+    }
+    if (subpassCount && copy_src->pSubpasses) {
+        pSubpasses = new safe_VkSubpassDescription2[subpassCount];
+        for (uint32_t i = 0; i < subpassCount; ++i) {
+            pSubpasses[i].initialize(&copy_src->pSubpasses[i]);
+        }
+    }
+    if (dependencyCount && copy_src->pDependencies) {
+        pDependencies = new safe_VkSubpassDependency2[dependencyCount];
+        for (uint32_t i = 0; i < dependencyCount; ++i) {
+            pDependencies[i].initialize(&copy_src->pDependencies[i]);
+        }
+    }
+
+    if (copy_src->pCorrelatedViewMasks) {
+        pCorrelatedViewMasks = new uint32_t[copy_src->correlatedViewMaskCount];
+        memcpy((void*)pCorrelatedViewMasks, (void*)copy_src->pCorrelatedViewMasks,
+               sizeof(uint32_t) * copy_src->correlatedViewMaskCount);
+    }
+}
+
+safe_VkSubpassBeginInfo::safe_VkSubpassBeginInfo(const VkSubpassBeginInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                                 bool copy_pnext)
+    : sType(in_struct->sType), contents(in_struct->contents) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSubpassBeginInfo::safe_VkSubpassBeginInfo() : sType(VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO), pNext(nullptr), contents() {}
+
+safe_VkSubpassBeginInfo::safe_VkSubpassBeginInfo(const safe_VkSubpassBeginInfo& copy_src) {
+    sType = copy_src.sType;
+    contents = copy_src.contents;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSubpassBeginInfo& safe_VkSubpassBeginInfo::operator=(const safe_VkSubpassBeginInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    contents = copy_src.contents;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSubpassBeginInfo::~safe_VkSubpassBeginInfo() { FreePnextChain(pNext); }
+
+void safe_VkSubpassBeginInfo::initialize(const VkSubpassBeginInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    contents = in_struct->contents;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSubpassBeginInfo::initialize(const safe_VkSubpassBeginInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    contents = copy_src->contents;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSubpassEndInfo::safe_VkSubpassEndInfo(const VkSubpassEndInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                             bool copy_pnext)
+    : sType(in_struct->sType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSubpassEndInfo::safe_VkSubpassEndInfo() : sType(VK_STRUCTURE_TYPE_SUBPASS_END_INFO), pNext(nullptr) {}
+
+safe_VkSubpassEndInfo::safe_VkSubpassEndInfo(const safe_VkSubpassEndInfo& copy_src) {
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSubpassEndInfo& safe_VkSubpassEndInfo::operator=(const safe_VkSubpassEndInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSubpassEndInfo::~safe_VkSubpassEndInfo() { FreePnextChain(pNext); }
+
+void safe_VkSubpassEndInfo::initialize(const VkSubpassEndInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSubpassEndInfo::initialize(const safe_VkSubpassEndInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDevice8BitStorageFeatures::safe_VkPhysicalDevice8BitStorageFeatures(
+    const VkPhysicalDevice8BitStorageFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      storageBuffer8BitAccess(in_struct->storageBuffer8BitAccess),
+      uniformAndStorageBuffer8BitAccess(in_struct->uniformAndStorageBuffer8BitAccess),
+      storagePushConstant8(in_struct->storagePushConstant8) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevice8BitStorageFeatures::safe_VkPhysicalDevice8BitStorageFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES),
+      pNext(nullptr),
+      storageBuffer8BitAccess(),
+      uniformAndStorageBuffer8BitAccess(),
+      storagePushConstant8() {}
+
+safe_VkPhysicalDevice8BitStorageFeatures::safe_VkPhysicalDevice8BitStorageFeatures(
+    const safe_VkPhysicalDevice8BitStorageFeatures& copy_src) {
+    sType = copy_src.sType;
+    storageBuffer8BitAccess = copy_src.storageBuffer8BitAccess;
+    uniformAndStorageBuffer8BitAccess = copy_src.uniformAndStorageBuffer8BitAccess;
+    storagePushConstant8 = copy_src.storagePushConstant8;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevice8BitStorageFeatures& safe_VkPhysicalDevice8BitStorageFeatures::operator=(
+    const safe_VkPhysicalDevice8BitStorageFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    storageBuffer8BitAccess = copy_src.storageBuffer8BitAccess;
+    uniformAndStorageBuffer8BitAccess = copy_src.uniformAndStorageBuffer8BitAccess;
+    storagePushConstant8 = copy_src.storagePushConstant8;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevice8BitStorageFeatures::~safe_VkPhysicalDevice8BitStorageFeatures() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDevice8BitStorageFeatures::initialize(const VkPhysicalDevice8BitStorageFeatures* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    storageBuffer8BitAccess = in_struct->storageBuffer8BitAccess;
+    uniformAndStorageBuffer8BitAccess = in_struct->uniformAndStorageBuffer8BitAccess;
+    storagePushConstant8 = in_struct->storagePushConstant8;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevice8BitStorageFeatures::initialize(const safe_VkPhysicalDevice8BitStorageFeatures* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    storageBuffer8BitAccess = copy_src->storageBuffer8BitAccess;
+    uniformAndStorageBuffer8BitAccess = copy_src->uniformAndStorageBuffer8BitAccess;
+    storagePushConstant8 = copy_src->storagePushConstant8;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceDriverProperties::safe_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType), driverID(in_struct->driverID), conformanceVersion(in_struct->conformanceVersion) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) {
+        driverName[i] = in_struct->driverName[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) {
+        driverInfo[i] = in_struct->driverInfo[i];
+    }
+}
+
+safe_VkPhysicalDeviceDriverProperties::safe_VkPhysicalDeviceDriverProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES), pNext(nullptr), driverID(), conformanceVersion() {}
+
+safe_VkPhysicalDeviceDriverProperties::safe_VkPhysicalDeviceDriverProperties(
+    const safe_VkPhysicalDeviceDriverProperties& copy_src) {
+    sType = copy_src.sType;
+    driverID = copy_src.driverID;
+    conformanceVersion = copy_src.conformanceVersion;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) {
+        driverName[i] = copy_src.driverName[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) {
+        driverInfo[i] = copy_src.driverInfo[i];
+    }
+}
+
+safe_VkPhysicalDeviceDriverProperties& safe_VkPhysicalDeviceDriverProperties::operator=(
+    const safe_VkPhysicalDeviceDriverProperties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    driverID = copy_src.driverID;
+    conformanceVersion = copy_src.conformanceVersion;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) {
+        driverName[i] = copy_src.driverName[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) {
+        driverInfo[i] = copy_src.driverInfo[i];
+    }
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDriverProperties::~safe_VkPhysicalDeviceDriverProperties() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceDriverProperties::initialize(const VkPhysicalDeviceDriverProperties* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    driverID = in_struct->driverID;
+    conformanceVersion = in_struct->conformanceVersion;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) {
+        driverName[i] = in_struct->driverName[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) {
+        driverInfo[i] = in_struct->driverInfo[i];
+    }
+}
+
+void safe_VkPhysicalDeviceDriverProperties::initialize(const safe_VkPhysicalDeviceDriverProperties* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    driverID = copy_src->driverID;
+    conformanceVersion = copy_src->conformanceVersion;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i) {
+        driverName[i] = copy_src->driverName[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i) {
+        driverInfo[i] = copy_src->driverInfo[i];
+    }
+}
+
+safe_VkPhysicalDeviceShaderAtomicInt64Features::safe_VkPhysicalDeviceShaderAtomicInt64Features(
+    const VkPhysicalDeviceShaderAtomicInt64Features* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      shaderBufferInt64Atomics(in_struct->shaderBufferInt64Atomics),
+      shaderSharedInt64Atomics(in_struct->shaderSharedInt64Atomics) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderAtomicInt64Features::safe_VkPhysicalDeviceShaderAtomicInt64Features()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES),
+      pNext(nullptr),
+      shaderBufferInt64Atomics(),
+      shaderSharedInt64Atomics() {}
+
+safe_VkPhysicalDeviceShaderAtomicInt64Features::safe_VkPhysicalDeviceShaderAtomicInt64Features(
+    const safe_VkPhysicalDeviceShaderAtomicInt64Features& copy_src) {
+    sType = copy_src.sType;
+    shaderBufferInt64Atomics = copy_src.shaderBufferInt64Atomics;
+    shaderSharedInt64Atomics = copy_src.shaderSharedInt64Atomics;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderAtomicInt64Features& safe_VkPhysicalDeviceShaderAtomicInt64Features::operator=(
+    const safe_VkPhysicalDeviceShaderAtomicInt64Features& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderBufferInt64Atomics = copy_src.shaderBufferInt64Atomics;
+    shaderSharedInt64Atomics = copy_src.shaderSharedInt64Atomics;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderAtomicInt64Features::~safe_VkPhysicalDeviceShaderAtomicInt64Features() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceShaderAtomicInt64Features::initialize(const VkPhysicalDeviceShaderAtomicInt64Features* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderBufferInt64Atomics = in_struct->shaderBufferInt64Atomics;
+    shaderSharedInt64Atomics = in_struct->shaderSharedInt64Atomics;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderAtomicInt64Features::initialize(const safe_VkPhysicalDeviceShaderAtomicInt64Features* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderBufferInt64Atomics = copy_src->shaderBufferInt64Atomics;
+    shaderSharedInt64Atomics = copy_src->shaderSharedInt64Atomics;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceShaderFloat16Int8Features::safe_VkPhysicalDeviceShaderFloat16Int8Features(
+    const VkPhysicalDeviceShaderFloat16Int8Features* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), shaderFloat16(in_struct->shaderFloat16), shaderInt8(in_struct->shaderInt8) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderFloat16Int8Features::safe_VkPhysicalDeviceShaderFloat16Int8Features()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES), pNext(nullptr), shaderFloat16(), shaderInt8() {}
+
+safe_VkPhysicalDeviceShaderFloat16Int8Features::safe_VkPhysicalDeviceShaderFloat16Int8Features(
+    const safe_VkPhysicalDeviceShaderFloat16Int8Features& copy_src) {
+    sType = copy_src.sType;
+    shaderFloat16 = copy_src.shaderFloat16;
+    shaderInt8 = copy_src.shaderInt8;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderFloat16Int8Features& safe_VkPhysicalDeviceShaderFloat16Int8Features::operator=(
+    const safe_VkPhysicalDeviceShaderFloat16Int8Features& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderFloat16 = copy_src.shaderFloat16;
+    shaderInt8 = copy_src.shaderInt8;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderFloat16Int8Features::~safe_VkPhysicalDeviceShaderFloat16Int8Features() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceShaderFloat16Int8Features::initialize(const VkPhysicalDeviceShaderFloat16Int8Features* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderFloat16 = in_struct->shaderFloat16;
+    shaderInt8 = in_struct->shaderInt8;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderFloat16Int8Features::initialize(const safe_VkPhysicalDeviceShaderFloat16Int8Features* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderFloat16 = copy_src->shaderFloat16;
+    shaderInt8 = copy_src->shaderInt8;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceFloatControlsProperties::safe_VkPhysicalDeviceFloatControlsProperties(
+    const VkPhysicalDeviceFloatControlsProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      denormBehaviorIndependence(in_struct->denormBehaviorIndependence),
+      roundingModeIndependence(in_struct->roundingModeIndependence),
+      shaderSignedZeroInfNanPreserveFloat16(in_struct->shaderSignedZeroInfNanPreserveFloat16),
+      shaderSignedZeroInfNanPreserveFloat32(in_struct->shaderSignedZeroInfNanPreserveFloat32),
+      shaderSignedZeroInfNanPreserveFloat64(in_struct->shaderSignedZeroInfNanPreserveFloat64),
+      shaderDenormPreserveFloat16(in_struct->shaderDenormPreserveFloat16),
+      shaderDenormPreserveFloat32(in_struct->shaderDenormPreserveFloat32),
+      shaderDenormPreserveFloat64(in_struct->shaderDenormPreserveFloat64),
+      shaderDenormFlushToZeroFloat16(in_struct->shaderDenormFlushToZeroFloat16),
+      shaderDenormFlushToZeroFloat32(in_struct->shaderDenormFlushToZeroFloat32),
+      shaderDenormFlushToZeroFloat64(in_struct->shaderDenormFlushToZeroFloat64),
+      shaderRoundingModeRTEFloat16(in_struct->shaderRoundingModeRTEFloat16),
+      shaderRoundingModeRTEFloat32(in_struct->shaderRoundingModeRTEFloat32),
+      shaderRoundingModeRTEFloat64(in_struct->shaderRoundingModeRTEFloat64),
+      shaderRoundingModeRTZFloat16(in_struct->shaderRoundingModeRTZFloat16),
+      shaderRoundingModeRTZFloat32(in_struct->shaderRoundingModeRTZFloat32),
+      shaderRoundingModeRTZFloat64(in_struct->shaderRoundingModeRTZFloat64) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceFloatControlsProperties::safe_VkPhysicalDeviceFloatControlsProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES),
+      pNext(nullptr),
+      denormBehaviorIndependence(),
+      roundingModeIndependence(),
+      shaderSignedZeroInfNanPreserveFloat16(),
+      shaderSignedZeroInfNanPreserveFloat32(),
+      shaderSignedZeroInfNanPreserveFloat64(),
+      shaderDenormPreserveFloat16(),
+      shaderDenormPreserveFloat32(),
+      shaderDenormPreserveFloat64(),
+      shaderDenormFlushToZeroFloat16(),
+      shaderDenormFlushToZeroFloat32(),
+      shaderDenormFlushToZeroFloat64(),
+      shaderRoundingModeRTEFloat16(),
+      shaderRoundingModeRTEFloat32(),
+      shaderRoundingModeRTEFloat64(),
+      shaderRoundingModeRTZFloat16(),
+      shaderRoundingModeRTZFloat32(),
+      shaderRoundingModeRTZFloat64() {}
+
+safe_VkPhysicalDeviceFloatControlsProperties::safe_VkPhysicalDeviceFloatControlsProperties(
+    const safe_VkPhysicalDeviceFloatControlsProperties& copy_src) {
+    sType = copy_src.sType;
+    denormBehaviorIndependence = copy_src.denormBehaviorIndependence;
+    roundingModeIndependence = copy_src.roundingModeIndependence;
+    shaderSignedZeroInfNanPreserveFloat16 = copy_src.shaderSignedZeroInfNanPreserveFloat16;
+    shaderSignedZeroInfNanPreserveFloat32 = copy_src.shaderSignedZeroInfNanPreserveFloat32;
+    shaderSignedZeroInfNanPreserveFloat64 = copy_src.shaderSignedZeroInfNanPreserveFloat64;
+    shaderDenormPreserveFloat16 = copy_src.shaderDenormPreserveFloat16;
+    shaderDenormPreserveFloat32 = copy_src.shaderDenormPreserveFloat32;
+    shaderDenormPreserveFloat64 = copy_src.shaderDenormPreserveFloat64;
+    shaderDenormFlushToZeroFloat16 = copy_src.shaderDenormFlushToZeroFloat16;
+    shaderDenormFlushToZeroFloat32 = copy_src.shaderDenormFlushToZeroFloat32;
+    shaderDenormFlushToZeroFloat64 = copy_src.shaderDenormFlushToZeroFloat64;
+    shaderRoundingModeRTEFloat16 = copy_src.shaderRoundingModeRTEFloat16;
+    shaderRoundingModeRTEFloat32 = copy_src.shaderRoundingModeRTEFloat32;
+    shaderRoundingModeRTEFloat64 = copy_src.shaderRoundingModeRTEFloat64;
+    shaderRoundingModeRTZFloat16 = copy_src.shaderRoundingModeRTZFloat16;
+    shaderRoundingModeRTZFloat32 = copy_src.shaderRoundingModeRTZFloat32;
+    shaderRoundingModeRTZFloat64 = copy_src.shaderRoundingModeRTZFloat64;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceFloatControlsProperties& safe_VkPhysicalDeviceFloatControlsProperties::operator=(
+    const safe_VkPhysicalDeviceFloatControlsProperties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    denormBehaviorIndependence = copy_src.denormBehaviorIndependence;
+    roundingModeIndependence = copy_src.roundingModeIndependence;
+    shaderSignedZeroInfNanPreserveFloat16 = copy_src.shaderSignedZeroInfNanPreserveFloat16;
+    shaderSignedZeroInfNanPreserveFloat32 = copy_src.shaderSignedZeroInfNanPreserveFloat32;
+    shaderSignedZeroInfNanPreserveFloat64 = copy_src.shaderSignedZeroInfNanPreserveFloat64;
+    shaderDenormPreserveFloat16 = copy_src.shaderDenormPreserveFloat16;
+    shaderDenormPreserveFloat32 = copy_src.shaderDenormPreserveFloat32;
+    shaderDenormPreserveFloat64 = copy_src.shaderDenormPreserveFloat64;
+    shaderDenormFlushToZeroFloat16 = copy_src.shaderDenormFlushToZeroFloat16;
+    shaderDenormFlushToZeroFloat32 = copy_src.shaderDenormFlushToZeroFloat32;
+    shaderDenormFlushToZeroFloat64 = copy_src.shaderDenormFlushToZeroFloat64;
+    shaderRoundingModeRTEFloat16 = copy_src.shaderRoundingModeRTEFloat16;
+    shaderRoundingModeRTEFloat32 = copy_src.shaderRoundingModeRTEFloat32;
+    shaderRoundingModeRTEFloat64 = copy_src.shaderRoundingModeRTEFloat64;
+    shaderRoundingModeRTZFloat16 = copy_src.shaderRoundingModeRTZFloat16;
+    shaderRoundingModeRTZFloat32 = copy_src.shaderRoundingModeRTZFloat32;
+    shaderRoundingModeRTZFloat64 = copy_src.shaderRoundingModeRTZFloat64;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceFloatControlsProperties::~safe_VkPhysicalDeviceFloatControlsProperties() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceFloatControlsProperties::initialize(const VkPhysicalDeviceFloatControlsProperties* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    denormBehaviorIndependence = in_struct->denormBehaviorIndependence;
+    roundingModeIndependence = in_struct->roundingModeIndependence;
+    shaderSignedZeroInfNanPreserveFloat16 = in_struct->shaderSignedZeroInfNanPreserveFloat16;
+    shaderSignedZeroInfNanPreserveFloat32 = in_struct->shaderSignedZeroInfNanPreserveFloat32;
+    shaderSignedZeroInfNanPreserveFloat64 = in_struct->shaderSignedZeroInfNanPreserveFloat64;
+    shaderDenormPreserveFloat16 = in_struct->shaderDenormPreserveFloat16;
+    shaderDenormPreserveFloat32 = in_struct->shaderDenormPreserveFloat32;
+    shaderDenormPreserveFloat64 = in_struct->shaderDenormPreserveFloat64;
+    shaderDenormFlushToZeroFloat16 = in_struct->shaderDenormFlushToZeroFloat16;
+    shaderDenormFlushToZeroFloat32 = in_struct->shaderDenormFlushToZeroFloat32;
+    shaderDenormFlushToZeroFloat64 = in_struct->shaderDenormFlushToZeroFloat64;
+    shaderRoundingModeRTEFloat16 = in_struct->shaderRoundingModeRTEFloat16;
+    shaderRoundingModeRTEFloat32 = in_struct->shaderRoundingModeRTEFloat32;
+    shaderRoundingModeRTEFloat64 = in_struct->shaderRoundingModeRTEFloat64;
+    shaderRoundingModeRTZFloat16 = in_struct->shaderRoundingModeRTZFloat16;
+    shaderRoundingModeRTZFloat32 = in_struct->shaderRoundingModeRTZFloat32;
+    shaderRoundingModeRTZFloat64 = in_struct->shaderRoundingModeRTZFloat64;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceFloatControlsProperties::initialize(const safe_VkPhysicalDeviceFloatControlsProperties* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    denormBehaviorIndependence = copy_src->denormBehaviorIndependence;
+    roundingModeIndependence = copy_src->roundingModeIndependence;
+    shaderSignedZeroInfNanPreserveFloat16 = copy_src->shaderSignedZeroInfNanPreserveFloat16;
+    shaderSignedZeroInfNanPreserveFloat32 = copy_src->shaderSignedZeroInfNanPreserveFloat32;
+    shaderSignedZeroInfNanPreserveFloat64 = copy_src->shaderSignedZeroInfNanPreserveFloat64;
+    shaderDenormPreserveFloat16 = copy_src->shaderDenormPreserveFloat16;
+    shaderDenormPreserveFloat32 = copy_src->shaderDenormPreserveFloat32;
+    shaderDenormPreserveFloat64 = copy_src->shaderDenormPreserveFloat64;
+    shaderDenormFlushToZeroFloat16 = copy_src->shaderDenormFlushToZeroFloat16;
+    shaderDenormFlushToZeroFloat32 = copy_src->shaderDenormFlushToZeroFloat32;
+    shaderDenormFlushToZeroFloat64 = copy_src->shaderDenormFlushToZeroFloat64;
+    shaderRoundingModeRTEFloat16 = copy_src->shaderRoundingModeRTEFloat16;
+    shaderRoundingModeRTEFloat32 = copy_src->shaderRoundingModeRTEFloat32;
+    shaderRoundingModeRTEFloat64 = copy_src->shaderRoundingModeRTEFloat64;
+    shaderRoundingModeRTZFloat16 = copy_src->shaderRoundingModeRTZFloat16;
+    shaderRoundingModeRTZFloat32 = copy_src->shaderRoundingModeRTZFloat32;
+    shaderRoundingModeRTZFloat64 = copy_src->shaderRoundingModeRTZFloat64;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDescriptorSetLayoutBindingFlagsCreateInfo::safe_VkDescriptorSetLayoutBindingFlagsCreateInfo(
+    const VkDescriptorSetLayoutBindingFlagsCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), bindingCount(in_struct->bindingCount), pBindingFlags(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pBindingFlags) {
+        pBindingFlags = new VkDescriptorBindingFlags[in_struct->bindingCount];
+        memcpy((void*)pBindingFlags, (void*)in_struct->pBindingFlags, sizeof(VkDescriptorBindingFlags) * in_struct->bindingCount);
+    }
+}
+
+safe_VkDescriptorSetLayoutBindingFlagsCreateInfo::safe_VkDescriptorSetLayoutBindingFlagsCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO),
+      pNext(nullptr),
+      bindingCount(),
+      pBindingFlags(nullptr) {}
+
+safe_VkDescriptorSetLayoutBindingFlagsCreateInfo::safe_VkDescriptorSetLayoutBindingFlagsCreateInfo(
+    const safe_VkDescriptorSetLayoutBindingFlagsCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    bindingCount = copy_src.bindingCount;
+    pBindingFlags = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pBindingFlags) {
+        pBindingFlags = new VkDescriptorBindingFlags[copy_src.bindingCount];
+        memcpy((void*)pBindingFlags, (void*)copy_src.pBindingFlags, sizeof(VkDescriptorBindingFlags) * copy_src.bindingCount);
+    }
+}
+
+safe_VkDescriptorSetLayoutBindingFlagsCreateInfo& safe_VkDescriptorSetLayoutBindingFlagsCreateInfo::operator=(
+    const safe_VkDescriptorSetLayoutBindingFlagsCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pBindingFlags) delete[] pBindingFlags;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    bindingCount = copy_src.bindingCount;
+    pBindingFlags = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pBindingFlags) {
+        pBindingFlags = new VkDescriptorBindingFlags[copy_src.bindingCount];
+        memcpy((void*)pBindingFlags, (void*)copy_src.pBindingFlags, sizeof(VkDescriptorBindingFlags) * copy_src.bindingCount);
+    }
+
+    return *this;
+}
+
+safe_VkDescriptorSetLayoutBindingFlagsCreateInfo::~safe_VkDescriptorSetLayoutBindingFlagsCreateInfo() {
+    if (pBindingFlags) delete[] pBindingFlags;
+    FreePnextChain(pNext);
+}
+
+void safe_VkDescriptorSetLayoutBindingFlagsCreateInfo::initialize(const VkDescriptorSetLayoutBindingFlagsCreateInfo* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pBindingFlags) delete[] pBindingFlags;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    bindingCount = in_struct->bindingCount;
+    pBindingFlags = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pBindingFlags) {
+        pBindingFlags = new VkDescriptorBindingFlags[in_struct->bindingCount];
+        memcpy((void*)pBindingFlags, (void*)in_struct->pBindingFlags, sizeof(VkDescriptorBindingFlags) * in_struct->bindingCount);
+    }
+}
+
+void safe_VkDescriptorSetLayoutBindingFlagsCreateInfo::initialize(const safe_VkDescriptorSetLayoutBindingFlagsCreateInfo* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    bindingCount = copy_src->bindingCount;
+    pBindingFlags = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pBindingFlags) {
+        pBindingFlags = new VkDescriptorBindingFlags[copy_src->bindingCount];
+        memcpy((void*)pBindingFlags, (void*)copy_src->pBindingFlags, sizeof(VkDescriptorBindingFlags) * copy_src->bindingCount);
+    }
+}
+
+safe_VkPhysicalDeviceDescriptorIndexingFeatures::safe_VkPhysicalDeviceDescriptorIndexingFeatures(
+    const VkPhysicalDeviceDescriptorIndexingFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      shaderInputAttachmentArrayDynamicIndexing(in_struct->shaderInputAttachmentArrayDynamicIndexing),
+      shaderUniformTexelBufferArrayDynamicIndexing(in_struct->shaderUniformTexelBufferArrayDynamicIndexing),
+      shaderStorageTexelBufferArrayDynamicIndexing(in_struct->shaderStorageTexelBufferArrayDynamicIndexing),
+      shaderUniformBufferArrayNonUniformIndexing(in_struct->shaderUniformBufferArrayNonUniformIndexing),
+      shaderSampledImageArrayNonUniformIndexing(in_struct->shaderSampledImageArrayNonUniformIndexing),
+      shaderStorageBufferArrayNonUniformIndexing(in_struct->shaderStorageBufferArrayNonUniformIndexing),
+      shaderStorageImageArrayNonUniformIndexing(in_struct->shaderStorageImageArrayNonUniformIndexing),
+      shaderInputAttachmentArrayNonUniformIndexing(in_struct->shaderInputAttachmentArrayNonUniformIndexing),
+      shaderUniformTexelBufferArrayNonUniformIndexing(in_struct->shaderUniformTexelBufferArrayNonUniformIndexing),
+      shaderStorageTexelBufferArrayNonUniformIndexing(in_struct->shaderStorageTexelBufferArrayNonUniformIndexing),
+      descriptorBindingUniformBufferUpdateAfterBind(in_struct->descriptorBindingUniformBufferUpdateAfterBind),
+      descriptorBindingSampledImageUpdateAfterBind(in_struct->descriptorBindingSampledImageUpdateAfterBind),
+      descriptorBindingStorageImageUpdateAfterBind(in_struct->descriptorBindingStorageImageUpdateAfterBind),
+      descriptorBindingStorageBufferUpdateAfterBind(in_struct->descriptorBindingStorageBufferUpdateAfterBind),
+      descriptorBindingUniformTexelBufferUpdateAfterBind(in_struct->descriptorBindingUniformTexelBufferUpdateAfterBind),
+      descriptorBindingStorageTexelBufferUpdateAfterBind(in_struct->descriptorBindingStorageTexelBufferUpdateAfterBind),
+      descriptorBindingUpdateUnusedWhilePending(in_struct->descriptorBindingUpdateUnusedWhilePending),
+      descriptorBindingPartiallyBound(in_struct->descriptorBindingPartiallyBound),
+      descriptorBindingVariableDescriptorCount(in_struct->descriptorBindingVariableDescriptorCount),
+      runtimeDescriptorArray(in_struct->runtimeDescriptorArray) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDescriptorIndexingFeatures::safe_VkPhysicalDeviceDescriptorIndexingFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES),
+      pNext(nullptr),
+      shaderInputAttachmentArrayDynamicIndexing(),
+      shaderUniformTexelBufferArrayDynamicIndexing(),
+      shaderStorageTexelBufferArrayDynamicIndexing(),
+      shaderUniformBufferArrayNonUniformIndexing(),
+      shaderSampledImageArrayNonUniformIndexing(),
+      shaderStorageBufferArrayNonUniformIndexing(),
+      shaderStorageImageArrayNonUniformIndexing(),
+      shaderInputAttachmentArrayNonUniformIndexing(),
+      shaderUniformTexelBufferArrayNonUniformIndexing(),
+      shaderStorageTexelBufferArrayNonUniformIndexing(),
+      descriptorBindingUniformBufferUpdateAfterBind(),
+      descriptorBindingSampledImageUpdateAfterBind(),
+      descriptorBindingStorageImageUpdateAfterBind(),
+      descriptorBindingStorageBufferUpdateAfterBind(),
+      descriptorBindingUniformTexelBufferUpdateAfterBind(),
+      descriptorBindingStorageTexelBufferUpdateAfterBind(),
+      descriptorBindingUpdateUnusedWhilePending(),
+      descriptorBindingPartiallyBound(),
+      descriptorBindingVariableDescriptorCount(),
+      runtimeDescriptorArray() {}
+
+safe_VkPhysicalDeviceDescriptorIndexingFeatures::safe_VkPhysicalDeviceDescriptorIndexingFeatures(
+    const safe_VkPhysicalDeviceDescriptorIndexingFeatures& copy_src) {
+    sType = copy_src.sType;
+    shaderInputAttachmentArrayDynamicIndexing = copy_src.shaderInputAttachmentArrayDynamicIndexing;
+    shaderUniformTexelBufferArrayDynamicIndexing = copy_src.shaderUniformTexelBufferArrayDynamicIndexing;
+    shaderStorageTexelBufferArrayDynamicIndexing = copy_src.shaderStorageTexelBufferArrayDynamicIndexing;
+    shaderUniformBufferArrayNonUniformIndexing = copy_src.shaderUniformBufferArrayNonUniformIndexing;
+    shaderSampledImageArrayNonUniformIndexing = copy_src.shaderSampledImageArrayNonUniformIndexing;
+    shaderStorageBufferArrayNonUniformIndexing = copy_src.shaderStorageBufferArrayNonUniformIndexing;
+    shaderStorageImageArrayNonUniformIndexing = copy_src.shaderStorageImageArrayNonUniformIndexing;
+    shaderInputAttachmentArrayNonUniformIndexing = copy_src.shaderInputAttachmentArrayNonUniformIndexing;
+    shaderUniformTexelBufferArrayNonUniformIndexing = copy_src.shaderUniformTexelBufferArrayNonUniformIndexing;
+    shaderStorageTexelBufferArrayNonUniformIndexing = copy_src.shaderStorageTexelBufferArrayNonUniformIndexing;
+    descriptorBindingUniformBufferUpdateAfterBind = copy_src.descriptorBindingUniformBufferUpdateAfterBind;
+    descriptorBindingSampledImageUpdateAfterBind = copy_src.descriptorBindingSampledImageUpdateAfterBind;
+    descriptorBindingStorageImageUpdateAfterBind = copy_src.descriptorBindingStorageImageUpdateAfterBind;
+    descriptorBindingStorageBufferUpdateAfterBind = copy_src.descriptorBindingStorageBufferUpdateAfterBind;
+    descriptorBindingUniformTexelBufferUpdateAfterBind = copy_src.descriptorBindingUniformTexelBufferUpdateAfterBind;
+    descriptorBindingStorageTexelBufferUpdateAfterBind = copy_src.descriptorBindingStorageTexelBufferUpdateAfterBind;
+    descriptorBindingUpdateUnusedWhilePending = copy_src.descriptorBindingUpdateUnusedWhilePending;
+    descriptorBindingPartiallyBound = copy_src.descriptorBindingPartiallyBound;
+    descriptorBindingVariableDescriptorCount = copy_src.descriptorBindingVariableDescriptorCount;
+    runtimeDescriptorArray = copy_src.runtimeDescriptorArray;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDescriptorIndexingFeatures& safe_VkPhysicalDeviceDescriptorIndexingFeatures::operator=(
+    const safe_VkPhysicalDeviceDescriptorIndexingFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderInputAttachmentArrayDynamicIndexing = copy_src.shaderInputAttachmentArrayDynamicIndexing;
+    shaderUniformTexelBufferArrayDynamicIndexing = copy_src.shaderUniformTexelBufferArrayDynamicIndexing;
+    shaderStorageTexelBufferArrayDynamicIndexing = copy_src.shaderStorageTexelBufferArrayDynamicIndexing;
+    shaderUniformBufferArrayNonUniformIndexing = copy_src.shaderUniformBufferArrayNonUniformIndexing;
+    shaderSampledImageArrayNonUniformIndexing = copy_src.shaderSampledImageArrayNonUniformIndexing;
+    shaderStorageBufferArrayNonUniformIndexing = copy_src.shaderStorageBufferArrayNonUniformIndexing;
+    shaderStorageImageArrayNonUniformIndexing = copy_src.shaderStorageImageArrayNonUniformIndexing;
+    shaderInputAttachmentArrayNonUniformIndexing = copy_src.shaderInputAttachmentArrayNonUniformIndexing;
+    shaderUniformTexelBufferArrayNonUniformIndexing = copy_src.shaderUniformTexelBufferArrayNonUniformIndexing;
+    shaderStorageTexelBufferArrayNonUniformIndexing = copy_src.shaderStorageTexelBufferArrayNonUniformIndexing;
+    descriptorBindingUniformBufferUpdateAfterBind = copy_src.descriptorBindingUniformBufferUpdateAfterBind;
+    descriptorBindingSampledImageUpdateAfterBind = copy_src.descriptorBindingSampledImageUpdateAfterBind;
+    descriptorBindingStorageImageUpdateAfterBind = copy_src.descriptorBindingStorageImageUpdateAfterBind;
+    descriptorBindingStorageBufferUpdateAfterBind = copy_src.descriptorBindingStorageBufferUpdateAfterBind;
+    descriptorBindingUniformTexelBufferUpdateAfterBind = copy_src.descriptorBindingUniformTexelBufferUpdateAfterBind;
+    descriptorBindingStorageTexelBufferUpdateAfterBind = copy_src.descriptorBindingStorageTexelBufferUpdateAfterBind;
+    descriptorBindingUpdateUnusedWhilePending = copy_src.descriptorBindingUpdateUnusedWhilePending;
+    descriptorBindingPartiallyBound = copy_src.descriptorBindingPartiallyBound;
+    descriptorBindingVariableDescriptorCount = copy_src.descriptorBindingVariableDescriptorCount;
+    runtimeDescriptorArray = copy_src.runtimeDescriptorArray;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDescriptorIndexingFeatures::~safe_VkPhysicalDeviceDescriptorIndexingFeatures() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceDescriptorIndexingFeatures::initialize(const VkPhysicalDeviceDescriptorIndexingFeatures* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderInputAttachmentArrayDynamicIndexing = in_struct->shaderInputAttachmentArrayDynamicIndexing;
+    shaderUniformTexelBufferArrayDynamicIndexing = in_struct->shaderUniformTexelBufferArrayDynamicIndexing;
+    shaderStorageTexelBufferArrayDynamicIndexing = in_struct->shaderStorageTexelBufferArrayDynamicIndexing;
+    shaderUniformBufferArrayNonUniformIndexing = in_struct->shaderUniformBufferArrayNonUniformIndexing;
+    shaderSampledImageArrayNonUniformIndexing = in_struct->shaderSampledImageArrayNonUniformIndexing;
+    shaderStorageBufferArrayNonUniformIndexing = in_struct->shaderStorageBufferArrayNonUniformIndexing;
+    shaderStorageImageArrayNonUniformIndexing = in_struct->shaderStorageImageArrayNonUniformIndexing;
+    shaderInputAttachmentArrayNonUniformIndexing = in_struct->shaderInputAttachmentArrayNonUniformIndexing;
+    shaderUniformTexelBufferArrayNonUniformIndexing = in_struct->shaderUniformTexelBufferArrayNonUniformIndexing;
+    shaderStorageTexelBufferArrayNonUniformIndexing = in_struct->shaderStorageTexelBufferArrayNonUniformIndexing;
+    descriptorBindingUniformBufferUpdateAfterBind = in_struct->descriptorBindingUniformBufferUpdateAfterBind;
+    descriptorBindingSampledImageUpdateAfterBind = in_struct->descriptorBindingSampledImageUpdateAfterBind;
+    descriptorBindingStorageImageUpdateAfterBind = in_struct->descriptorBindingStorageImageUpdateAfterBind;
+    descriptorBindingStorageBufferUpdateAfterBind = in_struct->descriptorBindingStorageBufferUpdateAfterBind;
+    descriptorBindingUniformTexelBufferUpdateAfterBind = in_struct->descriptorBindingUniformTexelBufferUpdateAfterBind;
+    descriptorBindingStorageTexelBufferUpdateAfterBind = in_struct->descriptorBindingStorageTexelBufferUpdateAfterBind;
+    descriptorBindingUpdateUnusedWhilePending = in_struct->descriptorBindingUpdateUnusedWhilePending;
+    descriptorBindingPartiallyBound = in_struct->descriptorBindingPartiallyBound;
+    descriptorBindingVariableDescriptorCount = in_struct->descriptorBindingVariableDescriptorCount;
+    runtimeDescriptorArray = in_struct->runtimeDescriptorArray;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDescriptorIndexingFeatures::initialize(const safe_VkPhysicalDeviceDescriptorIndexingFeatures* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderInputAttachmentArrayDynamicIndexing = copy_src->shaderInputAttachmentArrayDynamicIndexing;
+    shaderUniformTexelBufferArrayDynamicIndexing = copy_src->shaderUniformTexelBufferArrayDynamicIndexing;
+    shaderStorageTexelBufferArrayDynamicIndexing = copy_src->shaderStorageTexelBufferArrayDynamicIndexing;
+    shaderUniformBufferArrayNonUniformIndexing = copy_src->shaderUniformBufferArrayNonUniformIndexing;
+    shaderSampledImageArrayNonUniformIndexing = copy_src->shaderSampledImageArrayNonUniformIndexing;
+    shaderStorageBufferArrayNonUniformIndexing = copy_src->shaderStorageBufferArrayNonUniformIndexing;
+    shaderStorageImageArrayNonUniformIndexing = copy_src->shaderStorageImageArrayNonUniformIndexing;
+    shaderInputAttachmentArrayNonUniformIndexing = copy_src->shaderInputAttachmentArrayNonUniformIndexing;
+    shaderUniformTexelBufferArrayNonUniformIndexing = copy_src->shaderUniformTexelBufferArrayNonUniformIndexing;
+    shaderStorageTexelBufferArrayNonUniformIndexing = copy_src->shaderStorageTexelBufferArrayNonUniformIndexing;
+    descriptorBindingUniformBufferUpdateAfterBind = copy_src->descriptorBindingUniformBufferUpdateAfterBind;
+    descriptorBindingSampledImageUpdateAfterBind = copy_src->descriptorBindingSampledImageUpdateAfterBind;
+    descriptorBindingStorageImageUpdateAfterBind = copy_src->descriptorBindingStorageImageUpdateAfterBind;
+    descriptorBindingStorageBufferUpdateAfterBind = copy_src->descriptorBindingStorageBufferUpdateAfterBind;
+    descriptorBindingUniformTexelBufferUpdateAfterBind = copy_src->descriptorBindingUniformTexelBufferUpdateAfterBind;
+    descriptorBindingStorageTexelBufferUpdateAfterBind = copy_src->descriptorBindingStorageTexelBufferUpdateAfterBind;
+    descriptorBindingUpdateUnusedWhilePending = copy_src->descriptorBindingUpdateUnusedWhilePending;
+    descriptorBindingPartiallyBound = copy_src->descriptorBindingPartiallyBound;
+    descriptorBindingVariableDescriptorCount = copy_src->descriptorBindingVariableDescriptorCount;
+    runtimeDescriptorArray = copy_src->runtimeDescriptorArray;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceDescriptorIndexingProperties::safe_VkPhysicalDeviceDescriptorIndexingProperties(
+    const VkPhysicalDeviceDescriptorIndexingProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      maxUpdateAfterBindDescriptorsInAllPools(in_struct->maxUpdateAfterBindDescriptorsInAllPools),
+      shaderUniformBufferArrayNonUniformIndexingNative(in_struct->shaderUniformBufferArrayNonUniformIndexingNative),
+      shaderSampledImageArrayNonUniformIndexingNative(in_struct->shaderSampledImageArrayNonUniformIndexingNative),
+      shaderStorageBufferArrayNonUniformIndexingNative(in_struct->shaderStorageBufferArrayNonUniformIndexingNative),
+      shaderStorageImageArrayNonUniformIndexingNative(in_struct->shaderStorageImageArrayNonUniformIndexingNative),
+      shaderInputAttachmentArrayNonUniformIndexingNative(in_struct->shaderInputAttachmentArrayNonUniformIndexingNative),
+      robustBufferAccessUpdateAfterBind(in_struct->robustBufferAccessUpdateAfterBind),
+      quadDivergentImplicitLod(in_struct->quadDivergentImplicitLod),
+      maxPerStageDescriptorUpdateAfterBindSamplers(in_struct->maxPerStageDescriptorUpdateAfterBindSamplers),
+      maxPerStageDescriptorUpdateAfterBindUniformBuffers(in_struct->maxPerStageDescriptorUpdateAfterBindUniformBuffers),
+      maxPerStageDescriptorUpdateAfterBindStorageBuffers(in_struct->maxPerStageDescriptorUpdateAfterBindStorageBuffers),
+      maxPerStageDescriptorUpdateAfterBindSampledImages(in_struct->maxPerStageDescriptorUpdateAfterBindSampledImages),
+      maxPerStageDescriptorUpdateAfterBindStorageImages(in_struct->maxPerStageDescriptorUpdateAfterBindStorageImages),
+      maxPerStageDescriptorUpdateAfterBindInputAttachments(in_struct->maxPerStageDescriptorUpdateAfterBindInputAttachments),
+      maxPerStageUpdateAfterBindResources(in_struct->maxPerStageUpdateAfterBindResources),
+      maxDescriptorSetUpdateAfterBindSamplers(in_struct->maxDescriptorSetUpdateAfterBindSamplers),
+      maxDescriptorSetUpdateAfterBindUniformBuffers(in_struct->maxDescriptorSetUpdateAfterBindUniformBuffers),
+      maxDescriptorSetUpdateAfterBindUniformBuffersDynamic(in_struct->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic),
+      maxDescriptorSetUpdateAfterBindStorageBuffers(in_struct->maxDescriptorSetUpdateAfterBindStorageBuffers),
+      maxDescriptorSetUpdateAfterBindStorageBuffersDynamic(in_struct->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic),
+      maxDescriptorSetUpdateAfterBindSampledImages(in_struct->maxDescriptorSetUpdateAfterBindSampledImages),
+      maxDescriptorSetUpdateAfterBindStorageImages(in_struct->maxDescriptorSetUpdateAfterBindStorageImages),
+      maxDescriptorSetUpdateAfterBindInputAttachments(in_struct->maxDescriptorSetUpdateAfterBindInputAttachments) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDescriptorIndexingProperties::safe_VkPhysicalDeviceDescriptorIndexingProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES),
+      pNext(nullptr),
+      maxUpdateAfterBindDescriptorsInAllPools(),
+      shaderUniformBufferArrayNonUniformIndexingNative(),
+      shaderSampledImageArrayNonUniformIndexingNative(),
+      shaderStorageBufferArrayNonUniformIndexingNative(),
+      shaderStorageImageArrayNonUniformIndexingNative(),
+      shaderInputAttachmentArrayNonUniformIndexingNative(),
+      robustBufferAccessUpdateAfterBind(),
+      quadDivergentImplicitLod(),
+      maxPerStageDescriptorUpdateAfterBindSamplers(),
+      maxPerStageDescriptorUpdateAfterBindUniformBuffers(),
+      maxPerStageDescriptorUpdateAfterBindStorageBuffers(),
+      maxPerStageDescriptorUpdateAfterBindSampledImages(),
+      maxPerStageDescriptorUpdateAfterBindStorageImages(),
+      maxPerStageDescriptorUpdateAfterBindInputAttachments(),
+      maxPerStageUpdateAfterBindResources(),
+      maxDescriptorSetUpdateAfterBindSamplers(),
+      maxDescriptorSetUpdateAfterBindUniformBuffers(),
+      maxDescriptorSetUpdateAfterBindUniformBuffersDynamic(),
+      maxDescriptorSetUpdateAfterBindStorageBuffers(),
+      maxDescriptorSetUpdateAfterBindStorageBuffersDynamic(),
+      maxDescriptorSetUpdateAfterBindSampledImages(),
+      maxDescriptorSetUpdateAfterBindStorageImages(),
+      maxDescriptorSetUpdateAfterBindInputAttachments() {}
+
+safe_VkPhysicalDeviceDescriptorIndexingProperties::safe_VkPhysicalDeviceDescriptorIndexingProperties(
+    const safe_VkPhysicalDeviceDescriptorIndexingProperties& copy_src) {
+    sType = copy_src.sType;
+    maxUpdateAfterBindDescriptorsInAllPools = copy_src.maxUpdateAfterBindDescriptorsInAllPools;
+    shaderUniformBufferArrayNonUniformIndexingNative = copy_src.shaderUniformBufferArrayNonUniformIndexingNative;
+    shaderSampledImageArrayNonUniformIndexingNative = copy_src.shaderSampledImageArrayNonUniformIndexingNative;
+    shaderStorageBufferArrayNonUniformIndexingNative = copy_src.shaderStorageBufferArrayNonUniformIndexingNative;
+    shaderStorageImageArrayNonUniformIndexingNative = copy_src.shaderStorageImageArrayNonUniformIndexingNative;
+    shaderInputAttachmentArrayNonUniformIndexingNative = copy_src.shaderInputAttachmentArrayNonUniformIndexingNative;
+    robustBufferAccessUpdateAfterBind = copy_src.robustBufferAccessUpdateAfterBind;
+    quadDivergentImplicitLod = copy_src.quadDivergentImplicitLod;
+    maxPerStageDescriptorUpdateAfterBindSamplers = copy_src.maxPerStageDescriptorUpdateAfterBindSamplers;
+    maxPerStageDescriptorUpdateAfterBindUniformBuffers = copy_src.maxPerStageDescriptorUpdateAfterBindUniformBuffers;
+    maxPerStageDescriptorUpdateAfterBindStorageBuffers = copy_src.maxPerStageDescriptorUpdateAfterBindStorageBuffers;
+    maxPerStageDescriptorUpdateAfterBindSampledImages = copy_src.maxPerStageDescriptorUpdateAfterBindSampledImages;
+    maxPerStageDescriptorUpdateAfterBindStorageImages = copy_src.maxPerStageDescriptorUpdateAfterBindStorageImages;
+    maxPerStageDescriptorUpdateAfterBindInputAttachments = copy_src.maxPerStageDescriptorUpdateAfterBindInputAttachments;
+    maxPerStageUpdateAfterBindResources = copy_src.maxPerStageUpdateAfterBindResources;
+    maxDescriptorSetUpdateAfterBindSamplers = copy_src.maxDescriptorSetUpdateAfterBindSamplers;
+    maxDescriptorSetUpdateAfterBindUniformBuffers = copy_src.maxDescriptorSetUpdateAfterBindUniformBuffers;
+    maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = copy_src.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
+    maxDescriptorSetUpdateAfterBindStorageBuffers = copy_src.maxDescriptorSetUpdateAfterBindStorageBuffers;
+    maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = copy_src.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
+    maxDescriptorSetUpdateAfterBindSampledImages = copy_src.maxDescriptorSetUpdateAfterBindSampledImages;
+    maxDescriptorSetUpdateAfterBindStorageImages = copy_src.maxDescriptorSetUpdateAfterBindStorageImages;
+    maxDescriptorSetUpdateAfterBindInputAttachments = copy_src.maxDescriptorSetUpdateAfterBindInputAttachments;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDescriptorIndexingProperties& safe_VkPhysicalDeviceDescriptorIndexingProperties::operator=(
+    const safe_VkPhysicalDeviceDescriptorIndexingProperties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxUpdateAfterBindDescriptorsInAllPools = copy_src.maxUpdateAfterBindDescriptorsInAllPools;
+    shaderUniformBufferArrayNonUniformIndexingNative = copy_src.shaderUniformBufferArrayNonUniformIndexingNative;
+    shaderSampledImageArrayNonUniformIndexingNative = copy_src.shaderSampledImageArrayNonUniformIndexingNative;
+    shaderStorageBufferArrayNonUniformIndexingNative = copy_src.shaderStorageBufferArrayNonUniformIndexingNative;
+    shaderStorageImageArrayNonUniformIndexingNative = copy_src.shaderStorageImageArrayNonUniformIndexingNative;
+    shaderInputAttachmentArrayNonUniformIndexingNative = copy_src.shaderInputAttachmentArrayNonUniformIndexingNative;
+    robustBufferAccessUpdateAfterBind = copy_src.robustBufferAccessUpdateAfterBind;
+    quadDivergentImplicitLod = copy_src.quadDivergentImplicitLod;
+    maxPerStageDescriptorUpdateAfterBindSamplers = copy_src.maxPerStageDescriptorUpdateAfterBindSamplers;
+    maxPerStageDescriptorUpdateAfterBindUniformBuffers = copy_src.maxPerStageDescriptorUpdateAfterBindUniformBuffers;
+    maxPerStageDescriptorUpdateAfterBindStorageBuffers = copy_src.maxPerStageDescriptorUpdateAfterBindStorageBuffers;
+    maxPerStageDescriptorUpdateAfterBindSampledImages = copy_src.maxPerStageDescriptorUpdateAfterBindSampledImages;
+    maxPerStageDescriptorUpdateAfterBindStorageImages = copy_src.maxPerStageDescriptorUpdateAfterBindStorageImages;
+    maxPerStageDescriptorUpdateAfterBindInputAttachments = copy_src.maxPerStageDescriptorUpdateAfterBindInputAttachments;
+    maxPerStageUpdateAfterBindResources = copy_src.maxPerStageUpdateAfterBindResources;
+    maxDescriptorSetUpdateAfterBindSamplers = copy_src.maxDescriptorSetUpdateAfterBindSamplers;
+    maxDescriptorSetUpdateAfterBindUniformBuffers = copy_src.maxDescriptorSetUpdateAfterBindUniformBuffers;
+    maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = copy_src.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
+    maxDescriptorSetUpdateAfterBindStorageBuffers = copy_src.maxDescriptorSetUpdateAfterBindStorageBuffers;
+    maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = copy_src.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
+    maxDescriptorSetUpdateAfterBindSampledImages = copy_src.maxDescriptorSetUpdateAfterBindSampledImages;
+    maxDescriptorSetUpdateAfterBindStorageImages = copy_src.maxDescriptorSetUpdateAfterBindStorageImages;
+    maxDescriptorSetUpdateAfterBindInputAttachments = copy_src.maxDescriptorSetUpdateAfterBindInputAttachments;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDescriptorIndexingProperties::~safe_VkPhysicalDeviceDescriptorIndexingProperties() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceDescriptorIndexingProperties::initialize(const VkPhysicalDeviceDescriptorIndexingProperties* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxUpdateAfterBindDescriptorsInAllPools = in_struct->maxUpdateAfterBindDescriptorsInAllPools;
+    shaderUniformBufferArrayNonUniformIndexingNative = in_struct->shaderUniformBufferArrayNonUniformIndexingNative;
+    shaderSampledImageArrayNonUniformIndexingNative = in_struct->shaderSampledImageArrayNonUniformIndexingNative;
+    shaderStorageBufferArrayNonUniformIndexingNative = in_struct->shaderStorageBufferArrayNonUniformIndexingNative;
+    shaderStorageImageArrayNonUniformIndexingNative = in_struct->shaderStorageImageArrayNonUniformIndexingNative;
+    shaderInputAttachmentArrayNonUniformIndexingNative = in_struct->shaderInputAttachmentArrayNonUniformIndexingNative;
+    robustBufferAccessUpdateAfterBind = in_struct->robustBufferAccessUpdateAfterBind;
+    quadDivergentImplicitLod = in_struct->quadDivergentImplicitLod;
+    maxPerStageDescriptorUpdateAfterBindSamplers = in_struct->maxPerStageDescriptorUpdateAfterBindSamplers;
+    maxPerStageDescriptorUpdateAfterBindUniformBuffers = in_struct->maxPerStageDescriptorUpdateAfterBindUniformBuffers;
+    maxPerStageDescriptorUpdateAfterBindStorageBuffers = in_struct->maxPerStageDescriptorUpdateAfterBindStorageBuffers;
+    maxPerStageDescriptorUpdateAfterBindSampledImages = in_struct->maxPerStageDescriptorUpdateAfterBindSampledImages;
+    maxPerStageDescriptorUpdateAfterBindStorageImages = in_struct->maxPerStageDescriptorUpdateAfterBindStorageImages;
+    maxPerStageDescriptorUpdateAfterBindInputAttachments = in_struct->maxPerStageDescriptorUpdateAfterBindInputAttachments;
+    maxPerStageUpdateAfterBindResources = in_struct->maxPerStageUpdateAfterBindResources;
+    maxDescriptorSetUpdateAfterBindSamplers = in_struct->maxDescriptorSetUpdateAfterBindSamplers;
+    maxDescriptorSetUpdateAfterBindUniformBuffers = in_struct->maxDescriptorSetUpdateAfterBindUniformBuffers;
+    maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = in_struct->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
+    maxDescriptorSetUpdateAfterBindStorageBuffers = in_struct->maxDescriptorSetUpdateAfterBindStorageBuffers;
+    maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = in_struct->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
+    maxDescriptorSetUpdateAfterBindSampledImages = in_struct->maxDescriptorSetUpdateAfterBindSampledImages;
+    maxDescriptorSetUpdateAfterBindStorageImages = in_struct->maxDescriptorSetUpdateAfterBindStorageImages;
+    maxDescriptorSetUpdateAfterBindInputAttachments = in_struct->maxDescriptorSetUpdateAfterBindInputAttachments;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDescriptorIndexingProperties::initialize(
+    const safe_VkPhysicalDeviceDescriptorIndexingProperties* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxUpdateAfterBindDescriptorsInAllPools = copy_src->maxUpdateAfterBindDescriptorsInAllPools;
+    shaderUniformBufferArrayNonUniformIndexingNative = copy_src->shaderUniformBufferArrayNonUniformIndexingNative;
+    shaderSampledImageArrayNonUniformIndexingNative = copy_src->shaderSampledImageArrayNonUniformIndexingNative;
+    shaderStorageBufferArrayNonUniformIndexingNative = copy_src->shaderStorageBufferArrayNonUniformIndexingNative;
+    shaderStorageImageArrayNonUniformIndexingNative = copy_src->shaderStorageImageArrayNonUniformIndexingNative;
+    shaderInputAttachmentArrayNonUniformIndexingNative = copy_src->shaderInputAttachmentArrayNonUniformIndexingNative;
+    robustBufferAccessUpdateAfterBind = copy_src->robustBufferAccessUpdateAfterBind;
+    quadDivergentImplicitLod = copy_src->quadDivergentImplicitLod;
+    maxPerStageDescriptorUpdateAfterBindSamplers = copy_src->maxPerStageDescriptorUpdateAfterBindSamplers;
+    maxPerStageDescriptorUpdateAfterBindUniformBuffers = copy_src->maxPerStageDescriptorUpdateAfterBindUniformBuffers;
+    maxPerStageDescriptorUpdateAfterBindStorageBuffers = copy_src->maxPerStageDescriptorUpdateAfterBindStorageBuffers;
+    maxPerStageDescriptorUpdateAfterBindSampledImages = copy_src->maxPerStageDescriptorUpdateAfterBindSampledImages;
+    maxPerStageDescriptorUpdateAfterBindStorageImages = copy_src->maxPerStageDescriptorUpdateAfterBindStorageImages;
+    maxPerStageDescriptorUpdateAfterBindInputAttachments = copy_src->maxPerStageDescriptorUpdateAfterBindInputAttachments;
+    maxPerStageUpdateAfterBindResources = copy_src->maxPerStageUpdateAfterBindResources;
+    maxDescriptorSetUpdateAfterBindSamplers = copy_src->maxDescriptorSetUpdateAfterBindSamplers;
+    maxDescriptorSetUpdateAfterBindUniformBuffers = copy_src->maxDescriptorSetUpdateAfterBindUniformBuffers;
+    maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = copy_src->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
+    maxDescriptorSetUpdateAfterBindStorageBuffers = copy_src->maxDescriptorSetUpdateAfterBindStorageBuffers;
+    maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = copy_src->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
+    maxDescriptorSetUpdateAfterBindSampledImages = copy_src->maxDescriptorSetUpdateAfterBindSampledImages;
+    maxDescriptorSetUpdateAfterBindStorageImages = copy_src->maxDescriptorSetUpdateAfterBindStorageImages;
+    maxDescriptorSetUpdateAfterBindInputAttachments = copy_src->maxDescriptorSetUpdateAfterBindInputAttachments;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDescriptorSetVariableDescriptorCountAllocateInfo::safe_VkDescriptorSetVariableDescriptorCountAllocateInfo(
+    const VkDescriptorSetVariableDescriptorCountAllocateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), descriptorSetCount(in_struct->descriptorSetCount), pDescriptorCounts(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pDescriptorCounts) {
+        pDescriptorCounts = new uint32_t[in_struct->descriptorSetCount];
+        memcpy((void*)pDescriptorCounts, (void*)in_struct->pDescriptorCounts, sizeof(uint32_t) * in_struct->descriptorSetCount);
+    }
+}
+
+safe_VkDescriptorSetVariableDescriptorCountAllocateInfo::safe_VkDescriptorSetVariableDescriptorCountAllocateInfo()
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO),
+      pNext(nullptr),
+      descriptorSetCount(),
+      pDescriptorCounts(nullptr) {}
+
+safe_VkDescriptorSetVariableDescriptorCountAllocateInfo::safe_VkDescriptorSetVariableDescriptorCountAllocateInfo(
+    const safe_VkDescriptorSetVariableDescriptorCountAllocateInfo& copy_src) {
+    sType = copy_src.sType;
+    descriptorSetCount = copy_src.descriptorSetCount;
+    pDescriptorCounts = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDescriptorCounts) {
+        pDescriptorCounts = new uint32_t[copy_src.descriptorSetCount];
+        memcpy((void*)pDescriptorCounts, (void*)copy_src.pDescriptorCounts, sizeof(uint32_t) * copy_src.descriptorSetCount);
+    }
+}
+
+safe_VkDescriptorSetVariableDescriptorCountAllocateInfo& safe_VkDescriptorSetVariableDescriptorCountAllocateInfo::operator=(
+    const safe_VkDescriptorSetVariableDescriptorCountAllocateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pDescriptorCounts) delete[] pDescriptorCounts;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    descriptorSetCount = copy_src.descriptorSetCount;
+    pDescriptorCounts = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDescriptorCounts) {
+        pDescriptorCounts = new uint32_t[copy_src.descriptorSetCount];
+        memcpy((void*)pDescriptorCounts, (void*)copy_src.pDescriptorCounts, sizeof(uint32_t) * copy_src.descriptorSetCount);
+    }
+
+    return *this;
+}
+
+safe_VkDescriptorSetVariableDescriptorCountAllocateInfo::~safe_VkDescriptorSetVariableDescriptorCountAllocateInfo() {
+    if (pDescriptorCounts) delete[] pDescriptorCounts;
+    FreePnextChain(pNext);
+}
+
+void safe_VkDescriptorSetVariableDescriptorCountAllocateInfo::initialize(
+    const VkDescriptorSetVariableDescriptorCountAllocateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pDescriptorCounts) delete[] pDescriptorCounts;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    descriptorSetCount = in_struct->descriptorSetCount;
+    pDescriptorCounts = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pDescriptorCounts) {
+        pDescriptorCounts = new uint32_t[in_struct->descriptorSetCount];
+        memcpy((void*)pDescriptorCounts, (void*)in_struct->pDescriptorCounts, sizeof(uint32_t) * in_struct->descriptorSetCount);
+    }
+}
+
+void safe_VkDescriptorSetVariableDescriptorCountAllocateInfo::initialize(
+    const safe_VkDescriptorSetVariableDescriptorCountAllocateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    descriptorSetCount = copy_src->descriptorSetCount;
+    pDescriptorCounts = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pDescriptorCounts) {
+        pDescriptorCounts = new uint32_t[copy_src->descriptorSetCount];
+        memcpy((void*)pDescriptorCounts, (void*)copy_src->pDescriptorCounts, sizeof(uint32_t) * copy_src->descriptorSetCount);
+    }
+}
+
+safe_VkDescriptorSetVariableDescriptorCountLayoutSupport::safe_VkDescriptorSetVariableDescriptorCountLayoutSupport(
+    const VkDescriptorSetVariableDescriptorCountLayoutSupport* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), maxVariableDescriptorCount(in_struct->maxVariableDescriptorCount) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDescriptorSetVariableDescriptorCountLayoutSupport::safe_VkDescriptorSetVariableDescriptorCountLayoutSupport()
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT),
+      pNext(nullptr),
+      maxVariableDescriptorCount() {}
+
+safe_VkDescriptorSetVariableDescriptorCountLayoutSupport::safe_VkDescriptorSetVariableDescriptorCountLayoutSupport(
+    const safe_VkDescriptorSetVariableDescriptorCountLayoutSupport& copy_src) {
+    sType = copy_src.sType;
+    maxVariableDescriptorCount = copy_src.maxVariableDescriptorCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDescriptorSetVariableDescriptorCountLayoutSupport& safe_VkDescriptorSetVariableDescriptorCountLayoutSupport::operator=(
+    const safe_VkDescriptorSetVariableDescriptorCountLayoutSupport& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxVariableDescriptorCount = copy_src.maxVariableDescriptorCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDescriptorSetVariableDescriptorCountLayoutSupport::~safe_VkDescriptorSetVariableDescriptorCountLayoutSupport() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkDescriptorSetVariableDescriptorCountLayoutSupport::initialize(
+    const VkDescriptorSetVariableDescriptorCountLayoutSupport* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxVariableDescriptorCount = in_struct->maxVariableDescriptorCount;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDescriptorSetVariableDescriptorCountLayoutSupport::initialize(
+    const safe_VkDescriptorSetVariableDescriptorCountLayoutSupport* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxVariableDescriptorCount = copy_src->maxVariableDescriptorCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSubpassDescriptionDepthStencilResolve::safe_VkSubpassDescriptionDepthStencilResolve(
+    const VkSubpassDescriptionDepthStencilResolve* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      depthResolveMode(in_struct->depthResolveMode),
+      stencilResolveMode(in_struct->stencilResolveMode),
+      pDepthStencilResolveAttachment(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pDepthStencilResolveAttachment)
+        pDepthStencilResolveAttachment = new safe_VkAttachmentReference2(in_struct->pDepthStencilResolveAttachment);
+}
+
+safe_VkSubpassDescriptionDepthStencilResolve::safe_VkSubpassDescriptionDepthStencilResolve()
+    : sType(VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE),
+      pNext(nullptr),
+      depthResolveMode(),
+      stencilResolveMode(),
+      pDepthStencilResolveAttachment(nullptr) {}
+
+safe_VkSubpassDescriptionDepthStencilResolve::safe_VkSubpassDescriptionDepthStencilResolve(
+    const safe_VkSubpassDescriptionDepthStencilResolve& copy_src) {
+    sType = copy_src.sType;
+    depthResolveMode = copy_src.depthResolveMode;
+    stencilResolveMode = copy_src.stencilResolveMode;
+    pDepthStencilResolveAttachment = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pDepthStencilResolveAttachment)
+        pDepthStencilResolveAttachment = new safe_VkAttachmentReference2(*copy_src.pDepthStencilResolveAttachment);
+}
+
+safe_VkSubpassDescriptionDepthStencilResolve& safe_VkSubpassDescriptionDepthStencilResolve::operator=(
+    const safe_VkSubpassDescriptionDepthStencilResolve& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pDepthStencilResolveAttachment) delete pDepthStencilResolveAttachment;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    depthResolveMode = copy_src.depthResolveMode;
+    stencilResolveMode = copy_src.stencilResolveMode;
+    pDepthStencilResolveAttachment = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pDepthStencilResolveAttachment)
+        pDepthStencilResolveAttachment = new safe_VkAttachmentReference2(*copy_src.pDepthStencilResolveAttachment);
+
+    return *this;
+}
+
+safe_VkSubpassDescriptionDepthStencilResolve::~safe_VkSubpassDescriptionDepthStencilResolve() {
+    if (pDepthStencilResolveAttachment) delete pDepthStencilResolveAttachment;
+    FreePnextChain(pNext);
+}
+
+void safe_VkSubpassDescriptionDepthStencilResolve::initialize(const VkSubpassDescriptionDepthStencilResolve* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pDepthStencilResolveAttachment) delete pDepthStencilResolveAttachment;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    depthResolveMode = in_struct->depthResolveMode;
+    stencilResolveMode = in_struct->stencilResolveMode;
+    pDepthStencilResolveAttachment = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (in_struct->pDepthStencilResolveAttachment)
+        pDepthStencilResolveAttachment = new safe_VkAttachmentReference2(in_struct->pDepthStencilResolveAttachment);
+}
+
+void safe_VkSubpassDescriptionDepthStencilResolve::initialize(const safe_VkSubpassDescriptionDepthStencilResolve* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    depthResolveMode = copy_src->depthResolveMode;
+    stencilResolveMode = copy_src->stencilResolveMode;
+    pDepthStencilResolveAttachment = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (copy_src->pDepthStencilResolveAttachment)
+        pDepthStencilResolveAttachment = new safe_VkAttachmentReference2(*copy_src->pDepthStencilResolveAttachment);
+}
+
+safe_VkPhysicalDeviceDepthStencilResolveProperties::safe_VkPhysicalDeviceDepthStencilResolveProperties(
+    const VkPhysicalDeviceDepthStencilResolveProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      supportedDepthResolveModes(in_struct->supportedDepthResolveModes),
+      supportedStencilResolveModes(in_struct->supportedStencilResolveModes),
+      independentResolveNone(in_struct->independentResolveNone),
+      independentResolve(in_struct->independentResolve) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDepthStencilResolveProperties::safe_VkPhysicalDeviceDepthStencilResolveProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES),
+      pNext(nullptr),
+      supportedDepthResolveModes(),
+      supportedStencilResolveModes(),
+      independentResolveNone(),
+      independentResolve() {}
+
+safe_VkPhysicalDeviceDepthStencilResolveProperties::safe_VkPhysicalDeviceDepthStencilResolveProperties(
+    const safe_VkPhysicalDeviceDepthStencilResolveProperties& copy_src) {
+    sType = copy_src.sType;
+    supportedDepthResolveModes = copy_src.supportedDepthResolveModes;
+    supportedStencilResolveModes = copy_src.supportedStencilResolveModes;
+    independentResolveNone = copy_src.independentResolveNone;
+    independentResolve = copy_src.independentResolve;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDepthStencilResolveProperties& safe_VkPhysicalDeviceDepthStencilResolveProperties::operator=(
+    const safe_VkPhysicalDeviceDepthStencilResolveProperties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    supportedDepthResolveModes = copy_src.supportedDepthResolveModes;
+    supportedStencilResolveModes = copy_src.supportedStencilResolveModes;
+    independentResolveNone = copy_src.independentResolveNone;
+    independentResolve = copy_src.independentResolve;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDepthStencilResolveProperties::~safe_VkPhysicalDeviceDepthStencilResolveProperties() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceDepthStencilResolveProperties::initialize(const VkPhysicalDeviceDepthStencilResolveProperties* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    supportedDepthResolveModes = in_struct->supportedDepthResolveModes;
+    supportedStencilResolveModes = in_struct->supportedStencilResolveModes;
+    independentResolveNone = in_struct->independentResolveNone;
+    independentResolve = in_struct->independentResolve;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDepthStencilResolveProperties::initialize(
+    const safe_VkPhysicalDeviceDepthStencilResolveProperties* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    supportedDepthResolveModes = copy_src->supportedDepthResolveModes;
+    supportedStencilResolveModes = copy_src->supportedStencilResolveModes;
+    independentResolveNone = copy_src->independentResolveNone;
+    independentResolve = copy_src->independentResolve;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceScalarBlockLayoutFeatures::safe_VkPhysicalDeviceScalarBlockLayoutFeatures(
+    const VkPhysicalDeviceScalarBlockLayoutFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), scalarBlockLayout(in_struct->scalarBlockLayout) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceScalarBlockLayoutFeatures::safe_VkPhysicalDeviceScalarBlockLayoutFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES), pNext(nullptr), scalarBlockLayout() {}
+
+safe_VkPhysicalDeviceScalarBlockLayoutFeatures::safe_VkPhysicalDeviceScalarBlockLayoutFeatures(
+    const safe_VkPhysicalDeviceScalarBlockLayoutFeatures& copy_src) {
+    sType = copy_src.sType;
+    scalarBlockLayout = copy_src.scalarBlockLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceScalarBlockLayoutFeatures& safe_VkPhysicalDeviceScalarBlockLayoutFeatures::operator=(
+    const safe_VkPhysicalDeviceScalarBlockLayoutFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    scalarBlockLayout = copy_src.scalarBlockLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceScalarBlockLayoutFeatures::~safe_VkPhysicalDeviceScalarBlockLayoutFeatures() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceScalarBlockLayoutFeatures::initialize(const VkPhysicalDeviceScalarBlockLayoutFeatures* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    scalarBlockLayout = in_struct->scalarBlockLayout;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceScalarBlockLayoutFeatures::initialize(const safe_VkPhysicalDeviceScalarBlockLayoutFeatures* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    scalarBlockLayout = copy_src->scalarBlockLayout;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkImageStencilUsageCreateInfo::safe_VkImageStencilUsageCreateInfo(const VkImageStencilUsageCreateInfo* in_struct,
+                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), stencilUsage(in_struct->stencilUsage) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImageStencilUsageCreateInfo::safe_VkImageStencilUsageCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO), pNext(nullptr), stencilUsage() {}
+
+safe_VkImageStencilUsageCreateInfo::safe_VkImageStencilUsageCreateInfo(const safe_VkImageStencilUsageCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    stencilUsage = copy_src.stencilUsage;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImageStencilUsageCreateInfo& safe_VkImageStencilUsageCreateInfo::operator=(
+    const safe_VkImageStencilUsageCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    stencilUsage = copy_src.stencilUsage;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImageStencilUsageCreateInfo::~safe_VkImageStencilUsageCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkImageStencilUsageCreateInfo::initialize(const VkImageStencilUsageCreateInfo* in_struct,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    stencilUsage = in_struct->stencilUsage;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImageStencilUsageCreateInfo::initialize(const safe_VkImageStencilUsageCreateInfo* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stencilUsage = copy_src->stencilUsage;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSamplerReductionModeCreateInfo::safe_VkSamplerReductionModeCreateInfo(const VkSamplerReductionModeCreateInfo* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType), reductionMode(in_struct->reductionMode) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSamplerReductionModeCreateInfo::safe_VkSamplerReductionModeCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO), pNext(nullptr), reductionMode() {}
+
+safe_VkSamplerReductionModeCreateInfo::safe_VkSamplerReductionModeCreateInfo(
+    const safe_VkSamplerReductionModeCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    reductionMode = copy_src.reductionMode;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSamplerReductionModeCreateInfo& safe_VkSamplerReductionModeCreateInfo::operator=(
+    const safe_VkSamplerReductionModeCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    reductionMode = copy_src.reductionMode;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSamplerReductionModeCreateInfo::~safe_VkSamplerReductionModeCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkSamplerReductionModeCreateInfo::initialize(const VkSamplerReductionModeCreateInfo* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    reductionMode = in_struct->reductionMode;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSamplerReductionModeCreateInfo::initialize(const safe_VkSamplerReductionModeCreateInfo* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    reductionMode = copy_src->reductionMode;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceSamplerFilterMinmaxProperties::safe_VkPhysicalDeviceSamplerFilterMinmaxProperties(
+    const VkPhysicalDeviceSamplerFilterMinmaxProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      filterMinmaxSingleComponentFormats(in_struct->filterMinmaxSingleComponentFormats),
+      filterMinmaxImageComponentMapping(in_struct->filterMinmaxImageComponentMapping) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceSamplerFilterMinmaxProperties::safe_VkPhysicalDeviceSamplerFilterMinmaxProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES),
+      pNext(nullptr),
+      filterMinmaxSingleComponentFormats(),
+      filterMinmaxImageComponentMapping() {}
+
+safe_VkPhysicalDeviceSamplerFilterMinmaxProperties::safe_VkPhysicalDeviceSamplerFilterMinmaxProperties(
+    const safe_VkPhysicalDeviceSamplerFilterMinmaxProperties& copy_src) {
+    sType = copy_src.sType;
+    filterMinmaxSingleComponentFormats = copy_src.filterMinmaxSingleComponentFormats;
+    filterMinmaxImageComponentMapping = copy_src.filterMinmaxImageComponentMapping;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceSamplerFilterMinmaxProperties& safe_VkPhysicalDeviceSamplerFilterMinmaxProperties::operator=(
+    const safe_VkPhysicalDeviceSamplerFilterMinmaxProperties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    filterMinmaxSingleComponentFormats = copy_src.filterMinmaxSingleComponentFormats;
+    filterMinmaxImageComponentMapping = copy_src.filterMinmaxImageComponentMapping;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceSamplerFilterMinmaxProperties::~safe_VkPhysicalDeviceSamplerFilterMinmaxProperties() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceSamplerFilterMinmaxProperties::initialize(const VkPhysicalDeviceSamplerFilterMinmaxProperties* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    filterMinmaxSingleComponentFormats = in_struct->filterMinmaxSingleComponentFormats;
+    filterMinmaxImageComponentMapping = in_struct->filterMinmaxImageComponentMapping;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceSamplerFilterMinmaxProperties::initialize(
+    const safe_VkPhysicalDeviceSamplerFilterMinmaxProperties* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    filterMinmaxSingleComponentFormats = copy_src->filterMinmaxSingleComponentFormats;
+    filterMinmaxImageComponentMapping = copy_src->filterMinmaxImageComponentMapping;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceVulkanMemoryModelFeatures::safe_VkPhysicalDeviceVulkanMemoryModelFeatures(
+    const VkPhysicalDeviceVulkanMemoryModelFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      vulkanMemoryModel(in_struct->vulkanMemoryModel),
+      vulkanMemoryModelDeviceScope(in_struct->vulkanMemoryModelDeviceScope),
+      vulkanMemoryModelAvailabilityVisibilityChains(in_struct->vulkanMemoryModelAvailabilityVisibilityChains) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceVulkanMemoryModelFeatures::safe_VkPhysicalDeviceVulkanMemoryModelFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES),
+      pNext(nullptr),
+      vulkanMemoryModel(),
+      vulkanMemoryModelDeviceScope(),
+      vulkanMemoryModelAvailabilityVisibilityChains() {}
+
+safe_VkPhysicalDeviceVulkanMemoryModelFeatures::safe_VkPhysicalDeviceVulkanMemoryModelFeatures(
+    const safe_VkPhysicalDeviceVulkanMemoryModelFeatures& copy_src) {
+    sType = copy_src.sType;
+    vulkanMemoryModel = copy_src.vulkanMemoryModel;
+    vulkanMemoryModelDeviceScope = copy_src.vulkanMemoryModelDeviceScope;
+    vulkanMemoryModelAvailabilityVisibilityChains = copy_src.vulkanMemoryModelAvailabilityVisibilityChains;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceVulkanMemoryModelFeatures& safe_VkPhysicalDeviceVulkanMemoryModelFeatures::operator=(
+    const safe_VkPhysicalDeviceVulkanMemoryModelFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    vulkanMemoryModel = copy_src.vulkanMemoryModel;
+    vulkanMemoryModelDeviceScope = copy_src.vulkanMemoryModelDeviceScope;
+    vulkanMemoryModelAvailabilityVisibilityChains = copy_src.vulkanMemoryModelAvailabilityVisibilityChains;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceVulkanMemoryModelFeatures::~safe_VkPhysicalDeviceVulkanMemoryModelFeatures() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceVulkanMemoryModelFeatures::initialize(const VkPhysicalDeviceVulkanMemoryModelFeatures* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    vulkanMemoryModel = in_struct->vulkanMemoryModel;
+    vulkanMemoryModelDeviceScope = in_struct->vulkanMemoryModelDeviceScope;
+    vulkanMemoryModelAvailabilityVisibilityChains = in_struct->vulkanMemoryModelAvailabilityVisibilityChains;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceVulkanMemoryModelFeatures::initialize(const safe_VkPhysicalDeviceVulkanMemoryModelFeatures* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    vulkanMemoryModel = copy_src->vulkanMemoryModel;
+    vulkanMemoryModelDeviceScope = copy_src->vulkanMemoryModelDeviceScope;
+    vulkanMemoryModelAvailabilityVisibilityChains = copy_src->vulkanMemoryModelAvailabilityVisibilityChains;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceImagelessFramebufferFeatures::safe_VkPhysicalDeviceImagelessFramebufferFeatures(
+    const VkPhysicalDeviceImagelessFramebufferFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), imagelessFramebuffer(in_struct->imagelessFramebuffer) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceImagelessFramebufferFeatures::safe_VkPhysicalDeviceImagelessFramebufferFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES), pNext(nullptr), imagelessFramebuffer() {}
+
+safe_VkPhysicalDeviceImagelessFramebufferFeatures::safe_VkPhysicalDeviceImagelessFramebufferFeatures(
+    const safe_VkPhysicalDeviceImagelessFramebufferFeatures& copy_src) {
+    sType = copy_src.sType;
+    imagelessFramebuffer = copy_src.imagelessFramebuffer;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceImagelessFramebufferFeatures& safe_VkPhysicalDeviceImagelessFramebufferFeatures::operator=(
+    const safe_VkPhysicalDeviceImagelessFramebufferFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    imagelessFramebuffer = copy_src.imagelessFramebuffer;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceImagelessFramebufferFeatures::~safe_VkPhysicalDeviceImagelessFramebufferFeatures() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceImagelessFramebufferFeatures::initialize(const VkPhysicalDeviceImagelessFramebufferFeatures* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    imagelessFramebuffer = in_struct->imagelessFramebuffer;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceImagelessFramebufferFeatures::initialize(
+    const safe_VkPhysicalDeviceImagelessFramebufferFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imagelessFramebuffer = copy_src->imagelessFramebuffer;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkFramebufferAttachmentImageInfo::safe_VkFramebufferAttachmentImageInfo(const VkFramebufferAttachmentImageInfo* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      usage(in_struct->usage),
+      width(in_struct->width),
+      height(in_struct->height),
+      layerCount(in_struct->layerCount),
+      viewFormatCount(in_struct->viewFormatCount),
+      pViewFormats(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pViewFormats) {
+        pViewFormats = new VkFormat[in_struct->viewFormatCount];
+        memcpy((void*)pViewFormats, (void*)in_struct->pViewFormats, sizeof(VkFormat) * in_struct->viewFormatCount);
+    }
+}
+
+safe_VkFramebufferAttachmentImageInfo::safe_VkFramebufferAttachmentImageInfo()
+    : sType(VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO),
+      pNext(nullptr),
+      flags(),
+      usage(),
+      width(),
+      height(),
+      layerCount(),
+      viewFormatCount(),
+      pViewFormats(nullptr) {}
+
+safe_VkFramebufferAttachmentImageInfo::safe_VkFramebufferAttachmentImageInfo(
+    const safe_VkFramebufferAttachmentImageInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    usage = copy_src.usage;
+    width = copy_src.width;
+    height = copy_src.height;
+    layerCount = copy_src.layerCount;
+    viewFormatCount = copy_src.viewFormatCount;
+    pViewFormats = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pViewFormats) {
+        pViewFormats = new VkFormat[copy_src.viewFormatCount];
+        memcpy((void*)pViewFormats, (void*)copy_src.pViewFormats, sizeof(VkFormat) * copy_src.viewFormatCount);
+    }
+}
+
+safe_VkFramebufferAttachmentImageInfo& safe_VkFramebufferAttachmentImageInfo::operator=(
+    const safe_VkFramebufferAttachmentImageInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pViewFormats) delete[] pViewFormats;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    usage = copy_src.usage;
+    width = copy_src.width;
+    height = copy_src.height;
+    layerCount = copy_src.layerCount;
+    viewFormatCount = copy_src.viewFormatCount;
+    pViewFormats = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pViewFormats) {
+        pViewFormats = new VkFormat[copy_src.viewFormatCount];
+        memcpy((void*)pViewFormats, (void*)copy_src.pViewFormats, sizeof(VkFormat) * copy_src.viewFormatCount);
+    }
+
+    return *this;
+}
+
+safe_VkFramebufferAttachmentImageInfo::~safe_VkFramebufferAttachmentImageInfo() {
+    if (pViewFormats) delete[] pViewFormats;
+    FreePnextChain(pNext);
+}
+
+void safe_VkFramebufferAttachmentImageInfo::initialize(const VkFramebufferAttachmentImageInfo* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pViewFormats) delete[] pViewFormats;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    usage = in_struct->usage;
+    width = in_struct->width;
+    height = in_struct->height;
+    layerCount = in_struct->layerCount;
+    viewFormatCount = in_struct->viewFormatCount;
+    pViewFormats = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pViewFormats) {
+        pViewFormats = new VkFormat[in_struct->viewFormatCount];
+        memcpy((void*)pViewFormats, (void*)in_struct->pViewFormats, sizeof(VkFormat) * in_struct->viewFormatCount);
+    }
+}
+
+void safe_VkFramebufferAttachmentImageInfo::initialize(const safe_VkFramebufferAttachmentImageInfo* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    usage = copy_src->usage;
+    width = copy_src->width;
+    height = copy_src->height;
+    layerCount = copy_src->layerCount;
+    viewFormatCount = copy_src->viewFormatCount;
+    pViewFormats = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pViewFormats) {
+        pViewFormats = new VkFormat[copy_src->viewFormatCount];
+        memcpy((void*)pViewFormats, (void*)copy_src->pViewFormats, sizeof(VkFormat) * copy_src->viewFormatCount);
+    }
+}
+
+safe_VkFramebufferAttachmentsCreateInfo::safe_VkFramebufferAttachmentsCreateInfo(
+    const VkFramebufferAttachmentsCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), attachmentImageInfoCount(in_struct->attachmentImageInfoCount), pAttachmentImageInfos(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (attachmentImageInfoCount && in_struct->pAttachmentImageInfos) {
+        pAttachmentImageInfos = new safe_VkFramebufferAttachmentImageInfo[attachmentImageInfoCount];
+        for (uint32_t i = 0; i < attachmentImageInfoCount; ++i) {
+            pAttachmentImageInfos[i].initialize(&in_struct->pAttachmentImageInfos[i]);
+        }
+    }
+}
+
+safe_VkFramebufferAttachmentsCreateInfo::safe_VkFramebufferAttachmentsCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO),
+      pNext(nullptr),
+      attachmentImageInfoCount(),
+      pAttachmentImageInfos(nullptr) {}
+
+safe_VkFramebufferAttachmentsCreateInfo::safe_VkFramebufferAttachmentsCreateInfo(
+    const safe_VkFramebufferAttachmentsCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    attachmentImageInfoCount = copy_src.attachmentImageInfoCount;
+    pAttachmentImageInfos = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (attachmentImageInfoCount && copy_src.pAttachmentImageInfos) {
+        pAttachmentImageInfos = new safe_VkFramebufferAttachmentImageInfo[attachmentImageInfoCount];
+        for (uint32_t i = 0; i < attachmentImageInfoCount; ++i) {
+            pAttachmentImageInfos[i].initialize(&copy_src.pAttachmentImageInfos[i]);
+        }
+    }
+}
+
+safe_VkFramebufferAttachmentsCreateInfo& safe_VkFramebufferAttachmentsCreateInfo::operator=(
+    const safe_VkFramebufferAttachmentsCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pAttachmentImageInfos) delete[] pAttachmentImageInfos;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    attachmentImageInfoCount = copy_src.attachmentImageInfoCount;
+    pAttachmentImageInfos = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (attachmentImageInfoCount && copy_src.pAttachmentImageInfos) {
+        pAttachmentImageInfos = new safe_VkFramebufferAttachmentImageInfo[attachmentImageInfoCount];
+        for (uint32_t i = 0; i < attachmentImageInfoCount; ++i) {
+            pAttachmentImageInfos[i].initialize(&copy_src.pAttachmentImageInfos[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkFramebufferAttachmentsCreateInfo::~safe_VkFramebufferAttachmentsCreateInfo() {
+    if (pAttachmentImageInfos) delete[] pAttachmentImageInfos;
+    FreePnextChain(pNext);
+}
+
+void safe_VkFramebufferAttachmentsCreateInfo::initialize(const VkFramebufferAttachmentsCreateInfo* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pAttachmentImageInfos) delete[] pAttachmentImageInfos;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    attachmentImageInfoCount = in_struct->attachmentImageInfoCount;
+    pAttachmentImageInfos = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (attachmentImageInfoCount && in_struct->pAttachmentImageInfos) {
+        pAttachmentImageInfos = new safe_VkFramebufferAttachmentImageInfo[attachmentImageInfoCount];
+        for (uint32_t i = 0; i < attachmentImageInfoCount; ++i) {
+            pAttachmentImageInfos[i].initialize(&in_struct->pAttachmentImageInfos[i]);
+        }
+    }
+}
+
+void safe_VkFramebufferAttachmentsCreateInfo::initialize(const safe_VkFramebufferAttachmentsCreateInfo* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    attachmentImageInfoCount = copy_src->attachmentImageInfoCount;
+    pAttachmentImageInfos = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (attachmentImageInfoCount && copy_src->pAttachmentImageInfos) {
+        pAttachmentImageInfos = new safe_VkFramebufferAttachmentImageInfo[attachmentImageInfoCount];
+        for (uint32_t i = 0; i < attachmentImageInfoCount; ++i) {
+            pAttachmentImageInfos[i].initialize(&copy_src->pAttachmentImageInfos[i]);
+        }
+    }
+}
+
+safe_VkRenderPassAttachmentBeginInfo::safe_VkRenderPassAttachmentBeginInfo(const VkRenderPassAttachmentBeginInfo* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), attachmentCount(in_struct->attachmentCount), pAttachments(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (attachmentCount && in_struct->pAttachments) {
+        pAttachments = new VkImageView[attachmentCount];
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
+            pAttachments[i] = in_struct->pAttachments[i];
+        }
+    }
+}
+
+safe_VkRenderPassAttachmentBeginInfo::safe_VkRenderPassAttachmentBeginInfo()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO), pNext(nullptr), attachmentCount(), pAttachments(nullptr) {}
+
+safe_VkRenderPassAttachmentBeginInfo::safe_VkRenderPassAttachmentBeginInfo(const safe_VkRenderPassAttachmentBeginInfo& copy_src) {
+    sType = copy_src.sType;
+    attachmentCount = copy_src.attachmentCount;
+    pAttachments = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (attachmentCount && copy_src.pAttachments) {
+        pAttachments = new VkImageView[attachmentCount];
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
+            pAttachments[i] = copy_src.pAttachments[i];
+        }
+    }
+}
+
+safe_VkRenderPassAttachmentBeginInfo& safe_VkRenderPassAttachmentBeginInfo::operator=(
+    const safe_VkRenderPassAttachmentBeginInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pAttachments) delete[] pAttachments;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    attachmentCount = copy_src.attachmentCount;
+    pAttachments = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (attachmentCount && copy_src.pAttachments) {
+        pAttachments = new VkImageView[attachmentCount];
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
+            pAttachments[i] = copy_src.pAttachments[i];
+        }
+    }
+
+    return *this;
+}
+
+safe_VkRenderPassAttachmentBeginInfo::~safe_VkRenderPassAttachmentBeginInfo() {
+    if (pAttachments) delete[] pAttachments;
+    FreePnextChain(pNext);
+}
+
+void safe_VkRenderPassAttachmentBeginInfo::initialize(const VkRenderPassAttachmentBeginInfo* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pAttachments) delete[] pAttachments;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    attachmentCount = in_struct->attachmentCount;
+    pAttachments = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (attachmentCount && in_struct->pAttachments) {
+        pAttachments = new VkImageView[attachmentCount];
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
+            pAttachments[i] = in_struct->pAttachments[i];
+        }
+    }
+}
+
+void safe_VkRenderPassAttachmentBeginInfo::initialize(const safe_VkRenderPassAttachmentBeginInfo* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    attachmentCount = copy_src->attachmentCount;
+    pAttachments = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (attachmentCount && copy_src->pAttachments) {
+        pAttachments = new VkImageView[attachmentCount];
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
+            pAttachments[i] = copy_src->pAttachments[i];
+        }
+    }
+}
+
+safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures::safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
+    const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), uniformBufferStandardLayout(in_struct->uniformBufferStandardLayout) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures::safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES),
+      pNext(nullptr),
+      uniformBufferStandardLayout() {}
+
+safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures::safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
+    const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures& copy_src) {
+    sType = copy_src.sType;
+    uniformBufferStandardLayout = copy_src.uniformBufferStandardLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures& safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures::operator=(
+    const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    uniformBufferStandardLayout = copy_src.uniformBufferStandardLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures::~safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures::initialize(
+    const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    uniformBufferStandardLayout = in_struct->uniformBufferStandardLayout;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures::initialize(
+    const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    uniformBufferStandardLayout = copy_src->uniformBufferStandardLayout;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures::safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
+    const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), shaderSubgroupExtendedTypes(in_struct->shaderSubgroupExtendedTypes) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures::safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES),
+      pNext(nullptr),
+      shaderSubgroupExtendedTypes() {}
+
+safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures::safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
+    const safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& copy_src) {
+    sType = copy_src.sType;
+    shaderSubgroupExtendedTypes = copy_src.shaderSubgroupExtendedTypes;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures::operator=(
+    const safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderSubgroupExtendedTypes = copy_src.shaderSubgroupExtendedTypes;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures::~safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures::initialize(
+    const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderSubgroupExtendedTypes = in_struct->shaderSubgroupExtendedTypes;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures::initialize(
+    const safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderSubgroupExtendedTypes = copy_src->shaderSubgroupExtendedTypes;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures::safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
+    const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), separateDepthStencilLayouts(in_struct->separateDepthStencilLayouts) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures::safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES),
+      pNext(nullptr),
+      separateDepthStencilLayouts() {}
+
+safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures::safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
+    const safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& copy_src) {
+    sType = copy_src.sType;
+    separateDepthStencilLayouts = copy_src.separateDepthStencilLayouts;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures::operator=(
+    const safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    separateDepthStencilLayouts = copy_src.separateDepthStencilLayouts;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures::~safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures::initialize(
+    const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    separateDepthStencilLayouts = in_struct->separateDepthStencilLayouts;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures::initialize(
+    const safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    separateDepthStencilLayouts = copy_src->separateDepthStencilLayouts;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkAttachmentReferenceStencilLayout::safe_VkAttachmentReferenceStencilLayout(
+    const VkAttachmentReferenceStencilLayout* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), stencilLayout(in_struct->stencilLayout) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkAttachmentReferenceStencilLayout::safe_VkAttachmentReferenceStencilLayout()
+    : sType(VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT), pNext(nullptr), stencilLayout() {}
+
+safe_VkAttachmentReferenceStencilLayout::safe_VkAttachmentReferenceStencilLayout(
+    const safe_VkAttachmentReferenceStencilLayout& copy_src) {
+    sType = copy_src.sType;
+    stencilLayout = copy_src.stencilLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkAttachmentReferenceStencilLayout& safe_VkAttachmentReferenceStencilLayout::operator=(
+    const safe_VkAttachmentReferenceStencilLayout& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    stencilLayout = copy_src.stencilLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkAttachmentReferenceStencilLayout::~safe_VkAttachmentReferenceStencilLayout() { FreePnextChain(pNext); }
+
+void safe_VkAttachmentReferenceStencilLayout::initialize(const VkAttachmentReferenceStencilLayout* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    stencilLayout = in_struct->stencilLayout;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkAttachmentReferenceStencilLayout::initialize(const safe_VkAttachmentReferenceStencilLayout* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stencilLayout = copy_src->stencilLayout;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkAttachmentDescriptionStencilLayout::safe_VkAttachmentDescriptionStencilLayout(
+    const VkAttachmentDescriptionStencilLayout* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      stencilInitialLayout(in_struct->stencilInitialLayout),
+      stencilFinalLayout(in_struct->stencilFinalLayout) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkAttachmentDescriptionStencilLayout::safe_VkAttachmentDescriptionStencilLayout()
+    : sType(VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT),
+      pNext(nullptr),
+      stencilInitialLayout(),
+      stencilFinalLayout() {}
+
+safe_VkAttachmentDescriptionStencilLayout::safe_VkAttachmentDescriptionStencilLayout(
+    const safe_VkAttachmentDescriptionStencilLayout& copy_src) {
+    sType = copy_src.sType;
+    stencilInitialLayout = copy_src.stencilInitialLayout;
+    stencilFinalLayout = copy_src.stencilFinalLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkAttachmentDescriptionStencilLayout& safe_VkAttachmentDescriptionStencilLayout::operator=(
+    const safe_VkAttachmentDescriptionStencilLayout& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    stencilInitialLayout = copy_src.stencilInitialLayout;
+    stencilFinalLayout = copy_src.stencilFinalLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkAttachmentDescriptionStencilLayout::~safe_VkAttachmentDescriptionStencilLayout() { FreePnextChain(pNext); }
+
+void safe_VkAttachmentDescriptionStencilLayout::initialize(const VkAttachmentDescriptionStencilLayout* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    stencilInitialLayout = in_struct->stencilInitialLayout;
+    stencilFinalLayout = in_struct->stencilFinalLayout;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkAttachmentDescriptionStencilLayout::initialize(const safe_VkAttachmentDescriptionStencilLayout* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stencilInitialLayout = copy_src->stencilInitialLayout;
+    stencilFinalLayout = copy_src->stencilFinalLayout;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceHostQueryResetFeatures::safe_VkPhysicalDeviceHostQueryResetFeatures(
+    const VkPhysicalDeviceHostQueryResetFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), hostQueryReset(in_struct->hostQueryReset) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceHostQueryResetFeatures::safe_VkPhysicalDeviceHostQueryResetFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES), pNext(nullptr), hostQueryReset() {}
+
+safe_VkPhysicalDeviceHostQueryResetFeatures::safe_VkPhysicalDeviceHostQueryResetFeatures(
+    const safe_VkPhysicalDeviceHostQueryResetFeatures& copy_src) {
+    sType = copy_src.sType;
+    hostQueryReset = copy_src.hostQueryReset;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceHostQueryResetFeatures& safe_VkPhysicalDeviceHostQueryResetFeatures::operator=(
+    const safe_VkPhysicalDeviceHostQueryResetFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    hostQueryReset = copy_src.hostQueryReset;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceHostQueryResetFeatures::~safe_VkPhysicalDeviceHostQueryResetFeatures() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceHostQueryResetFeatures::initialize(const VkPhysicalDeviceHostQueryResetFeatures* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    hostQueryReset = in_struct->hostQueryReset;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceHostQueryResetFeatures::initialize(const safe_VkPhysicalDeviceHostQueryResetFeatures* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    hostQueryReset = copy_src->hostQueryReset;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceTimelineSemaphoreFeatures::safe_VkPhysicalDeviceTimelineSemaphoreFeatures(
+    const VkPhysicalDeviceTimelineSemaphoreFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), timelineSemaphore(in_struct->timelineSemaphore) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceTimelineSemaphoreFeatures::safe_VkPhysicalDeviceTimelineSemaphoreFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES), pNext(nullptr), timelineSemaphore() {}
+
+safe_VkPhysicalDeviceTimelineSemaphoreFeatures::safe_VkPhysicalDeviceTimelineSemaphoreFeatures(
+    const safe_VkPhysicalDeviceTimelineSemaphoreFeatures& copy_src) {
+    sType = copy_src.sType;
+    timelineSemaphore = copy_src.timelineSemaphore;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceTimelineSemaphoreFeatures& safe_VkPhysicalDeviceTimelineSemaphoreFeatures::operator=(
+    const safe_VkPhysicalDeviceTimelineSemaphoreFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    timelineSemaphore = copy_src.timelineSemaphore;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceTimelineSemaphoreFeatures::~safe_VkPhysicalDeviceTimelineSemaphoreFeatures() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceTimelineSemaphoreFeatures::initialize(const VkPhysicalDeviceTimelineSemaphoreFeatures* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    timelineSemaphore = in_struct->timelineSemaphore;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceTimelineSemaphoreFeatures::initialize(const safe_VkPhysicalDeviceTimelineSemaphoreFeatures* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    timelineSemaphore = copy_src->timelineSemaphore;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceTimelineSemaphoreProperties::safe_VkPhysicalDeviceTimelineSemaphoreProperties(
+    const VkPhysicalDeviceTimelineSemaphoreProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), maxTimelineSemaphoreValueDifference(in_struct->maxTimelineSemaphoreValueDifference) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceTimelineSemaphoreProperties::safe_VkPhysicalDeviceTimelineSemaphoreProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES),
+      pNext(nullptr),
+      maxTimelineSemaphoreValueDifference() {}
+
+safe_VkPhysicalDeviceTimelineSemaphoreProperties::safe_VkPhysicalDeviceTimelineSemaphoreProperties(
+    const safe_VkPhysicalDeviceTimelineSemaphoreProperties& copy_src) {
+    sType = copy_src.sType;
+    maxTimelineSemaphoreValueDifference = copy_src.maxTimelineSemaphoreValueDifference;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceTimelineSemaphoreProperties& safe_VkPhysicalDeviceTimelineSemaphoreProperties::operator=(
+    const safe_VkPhysicalDeviceTimelineSemaphoreProperties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxTimelineSemaphoreValueDifference = copy_src.maxTimelineSemaphoreValueDifference;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceTimelineSemaphoreProperties::~safe_VkPhysicalDeviceTimelineSemaphoreProperties() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceTimelineSemaphoreProperties::initialize(const VkPhysicalDeviceTimelineSemaphoreProperties* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxTimelineSemaphoreValueDifference = in_struct->maxTimelineSemaphoreValueDifference;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceTimelineSemaphoreProperties::initialize(const safe_VkPhysicalDeviceTimelineSemaphoreProperties* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxTimelineSemaphoreValueDifference = copy_src->maxTimelineSemaphoreValueDifference;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSemaphoreTypeCreateInfo::safe_VkSemaphoreTypeCreateInfo(const VkSemaphoreTypeCreateInfo* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), semaphoreType(in_struct->semaphoreType), initialValue(in_struct->initialValue) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSemaphoreTypeCreateInfo::safe_VkSemaphoreTypeCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO), pNext(nullptr), semaphoreType(), initialValue() {}
+
+safe_VkSemaphoreTypeCreateInfo::safe_VkSemaphoreTypeCreateInfo(const safe_VkSemaphoreTypeCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    semaphoreType = copy_src.semaphoreType;
+    initialValue = copy_src.initialValue;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSemaphoreTypeCreateInfo& safe_VkSemaphoreTypeCreateInfo::operator=(const safe_VkSemaphoreTypeCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    semaphoreType = copy_src.semaphoreType;
+    initialValue = copy_src.initialValue;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSemaphoreTypeCreateInfo::~safe_VkSemaphoreTypeCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkSemaphoreTypeCreateInfo::initialize(const VkSemaphoreTypeCreateInfo* in_struct,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    semaphoreType = in_struct->semaphoreType;
+    initialValue = in_struct->initialValue;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSemaphoreTypeCreateInfo::initialize(const safe_VkSemaphoreTypeCreateInfo* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    semaphoreType = copy_src->semaphoreType;
+    initialValue = copy_src->initialValue;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkTimelineSemaphoreSubmitInfo::safe_VkTimelineSemaphoreSubmitInfo(const VkTimelineSemaphoreSubmitInfo* in_struct,
+                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      waitSemaphoreValueCount(in_struct->waitSemaphoreValueCount),
+      pWaitSemaphoreValues(nullptr),
+      signalSemaphoreValueCount(in_struct->signalSemaphoreValueCount),
+      pSignalSemaphoreValues(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pWaitSemaphoreValues) {
+        pWaitSemaphoreValues = new uint64_t[in_struct->waitSemaphoreValueCount];
+        memcpy((void*)pWaitSemaphoreValues, (void*)in_struct->pWaitSemaphoreValues,
+               sizeof(uint64_t) * in_struct->waitSemaphoreValueCount);
+    }
+
+    if (in_struct->pSignalSemaphoreValues) {
+        pSignalSemaphoreValues = new uint64_t[in_struct->signalSemaphoreValueCount];
+        memcpy((void*)pSignalSemaphoreValues, (void*)in_struct->pSignalSemaphoreValues,
+               sizeof(uint64_t) * in_struct->signalSemaphoreValueCount);
+    }
+}
+
+safe_VkTimelineSemaphoreSubmitInfo::safe_VkTimelineSemaphoreSubmitInfo()
+    : sType(VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO),
+      pNext(nullptr),
+      waitSemaphoreValueCount(),
+      pWaitSemaphoreValues(nullptr),
+      signalSemaphoreValueCount(),
+      pSignalSemaphoreValues(nullptr) {}
+
+safe_VkTimelineSemaphoreSubmitInfo::safe_VkTimelineSemaphoreSubmitInfo(const safe_VkTimelineSemaphoreSubmitInfo& copy_src) {
+    sType = copy_src.sType;
+    waitSemaphoreValueCount = copy_src.waitSemaphoreValueCount;
+    pWaitSemaphoreValues = nullptr;
+    signalSemaphoreValueCount = copy_src.signalSemaphoreValueCount;
+    pSignalSemaphoreValues = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pWaitSemaphoreValues) {
+        pWaitSemaphoreValues = new uint64_t[copy_src.waitSemaphoreValueCount];
+        memcpy((void*)pWaitSemaphoreValues, (void*)copy_src.pWaitSemaphoreValues,
+               sizeof(uint64_t) * copy_src.waitSemaphoreValueCount);
+    }
+
+    if (copy_src.pSignalSemaphoreValues) {
+        pSignalSemaphoreValues = new uint64_t[copy_src.signalSemaphoreValueCount];
+        memcpy((void*)pSignalSemaphoreValues, (void*)copy_src.pSignalSemaphoreValues,
+               sizeof(uint64_t) * copy_src.signalSemaphoreValueCount);
+    }
+}
+
+safe_VkTimelineSemaphoreSubmitInfo& safe_VkTimelineSemaphoreSubmitInfo::operator=(
+    const safe_VkTimelineSemaphoreSubmitInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pWaitSemaphoreValues) delete[] pWaitSemaphoreValues;
+    if (pSignalSemaphoreValues) delete[] pSignalSemaphoreValues;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    waitSemaphoreValueCount = copy_src.waitSemaphoreValueCount;
+    pWaitSemaphoreValues = nullptr;
+    signalSemaphoreValueCount = copy_src.signalSemaphoreValueCount;
+    pSignalSemaphoreValues = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pWaitSemaphoreValues) {
+        pWaitSemaphoreValues = new uint64_t[copy_src.waitSemaphoreValueCount];
+        memcpy((void*)pWaitSemaphoreValues, (void*)copy_src.pWaitSemaphoreValues,
+               sizeof(uint64_t) * copy_src.waitSemaphoreValueCount);
+    }
+
+    if (copy_src.pSignalSemaphoreValues) {
+        pSignalSemaphoreValues = new uint64_t[copy_src.signalSemaphoreValueCount];
+        memcpy((void*)pSignalSemaphoreValues, (void*)copy_src.pSignalSemaphoreValues,
+               sizeof(uint64_t) * copy_src.signalSemaphoreValueCount);
+    }
+
+    return *this;
+}
+
+safe_VkTimelineSemaphoreSubmitInfo::~safe_VkTimelineSemaphoreSubmitInfo() {
+    if (pWaitSemaphoreValues) delete[] pWaitSemaphoreValues;
+    if (pSignalSemaphoreValues) delete[] pSignalSemaphoreValues;
+    FreePnextChain(pNext);
+}
+
+void safe_VkTimelineSemaphoreSubmitInfo::initialize(const VkTimelineSemaphoreSubmitInfo* in_struct,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pWaitSemaphoreValues) delete[] pWaitSemaphoreValues;
+    if (pSignalSemaphoreValues) delete[] pSignalSemaphoreValues;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    waitSemaphoreValueCount = in_struct->waitSemaphoreValueCount;
+    pWaitSemaphoreValues = nullptr;
+    signalSemaphoreValueCount = in_struct->signalSemaphoreValueCount;
+    pSignalSemaphoreValues = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pWaitSemaphoreValues) {
+        pWaitSemaphoreValues = new uint64_t[in_struct->waitSemaphoreValueCount];
+        memcpy((void*)pWaitSemaphoreValues, (void*)in_struct->pWaitSemaphoreValues,
+               sizeof(uint64_t) * in_struct->waitSemaphoreValueCount);
+    }
+
+    if (in_struct->pSignalSemaphoreValues) {
+        pSignalSemaphoreValues = new uint64_t[in_struct->signalSemaphoreValueCount];
+        memcpy((void*)pSignalSemaphoreValues, (void*)in_struct->pSignalSemaphoreValues,
+               sizeof(uint64_t) * in_struct->signalSemaphoreValueCount);
+    }
+}
+
+void safe_VkTimelineSemaphoreSubmitInfo::initialize(const safe_VkTimelineSemaphoreSubmitInfo* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    waitSemaphoreValueCount = copy_src->waitSemaphoreValueCount;
+    pWaitSemaphoreValues = nullptr;
+    signalSemaphoreValueCount = copy_src->signalSemaphoreValueCount;
+    pSignalSemaphoreValues = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pWaitSemaphoreValues) {
+        pWaitSemaphoreValues = new uint64_t[copy_src->waitSemaphoreValueCount];
+        memcpy((void*)pWaitSemaphoreValues, (void*)copy_src->pWaitSemaphoreValues,
+               sizeof(uint64_t) * copy_src->waitSemaphoreValueCount);
+    }
+
+    if (copy_src->pSignalSemaphoreValues) {
+        pSignalSemaphoreValues = new uint64_t[copy_src->signalSemaphoreValueCount];
+        memcpy((void*)pSignalSemaphoreValues, (void*)copy_src->pSignalSemaphoreValues,
+               sizeof(uint64_t) * copy_src->signalSemaphoreValueCount);
+    }
+}
+
+safe_VkSemaphoreWaitInfo::safe_VkSemaphoreWaitInfo(const VkSemaphoreWaitInfo* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      semaphoreCount(in_struct->semaphoreCount),
+      pSemaphores(nullptr),
+      pValues(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (semaphoreCount && in_struct->pSemaphores) {
+        pSemaphores = new VkSemaphore[semaphoreCount];
+        for (uint32_t i = 0; i < semaphoreCount; ++i) {
+            pSemaphores[i] = in_struct->pSemaphores[i];
+        }
+    }
+
+    if (in_struct->pValues) {
+        pValues = new uint64_t[in_struct->semaphoreCount];
+        memcpy((void*)pValues, (void*)in_struct->pValues, sizeof(uint64_t) * in_struct->semaphoreCount);
+    }
+}
+
+safe_VkSemaphoreWaitInfo::safe_VkSemaphoreWaitInfo()
+    : sType(VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO),
+      pNext(nullptr),
+      flags(),
+      semaphoreCount(),
+      pSemaphores(nullptr),
+      pValues(nullptr) {}
+
+safe_VkSemaphoreWaitInfo::safe_VkSemaphoreWaitInfo(const safe_VkSemaphoreWaitInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    semaphoreCount = copy_src.semaphoreCount;
+    pSemaphores = nullptr;
+    pValues = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (semaphoreCount && copy_src.pSemaphores) {
+        pSemaphores = new VkSemaphore[semaphoreCount];
+        for (uint32_t i = 0; i < semaphoreCount; ++i) {
+            pSemaphores[i] = copy_src.pSemaphores[i];
+        }
+    }
+
+    if (copy_src.pValues) {
+        pValues = new uint64_t[copy_src.semaphoreCount];
+        memcpy((void*)pValues, (void*)copy_src.pValues, sizeof(uint64_t) * copy_src.semaphoreCount);
+    }
+}
+
+safe_VkSemaphoreWaitInfo& safe_VkSemaphoreWaitInfo::operator=(const safe_VkSemaphoreWaitInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pSemaphores) delete[] pSemaphores;
+    if (pValues) delete[] pValues;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    semaphoreCount = copy_src.semaphoreCount;
+    pSemaphores = nullptr;
+    pValues = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (semaphoreCount && copy_src.pSemaphores) {
+        pSemaphores = new VkSemaphore[semaphoreCount];
+        for (uint32_t i = 0; i < semaphoreCount; ++i) {
+            pSemaphores[i] = copy_src.pSemaphores[i];
+        }
+    }
+
+    if (copy_src.pValues) {
+        pValues = new uint64_t[copy_src.semaphoreCount];
+        memcpy((void*)pValues, (void*)copy_src.pValues, sizeof(uint64_t) * copy_src.semaphoreCount);
+    }
+
+    return *this;
+}
+
+safe_VkSemaphoreWaitInfo::~safe_VkSemaphoreWaitInfo() {
+    if (pSemaphores) delete[] pSemaphores;
+    if (pValues) delete[] pValues;
+    FreePnextChain(pNext);
+}
+
+void safe_VkSemaphoreWaitInfo::initialize(const VkSemaphoreWaitInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pSemaphores) delete[] pSemaphores;
+    if (pValues) delete[] pValues;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    semaphoreCount = in_struct->semaphoreCount;
+    pSemaphores = nullptr;
+    pValues = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (semaphoreCount && in_struct->pSemaphores) {
+        pSemaphores = new VkSemaphore[semaphoreCount];
+        for (uint32_t i = 0; i < semaphoreCount; ++i) {
+            pSemaphores[i] = in_struct->pSemaphores[i];
+        }
+    }
+
+    if (in_struct->pValues) {
+        pValues = new uint64_t[in_struct->semaphoreCount];
+        memcpy((void*)pValues, (void*)in_struct->pValues, sizeof(uint64_t) * in_struct->semaphoreCount);
+    }
+}
+
+void safe_VkSemaphoreWaitInfo::initialize(const safe_VkSemaphoreWaitInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    semaphoreCount = copy_src->semaphoreCount;
+    pSemaphores = nullptr;
+    pValues = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (semaphoreCount && copy_src->pSemaphores) {
+        pSemaphores = new VkSemaphore[semaphoreCount];
+        for (uint32_t i = 0; i < semaphoreCount; ++i) {
+            pSemaphores[i] = copy_src->pSemaphores[i];
+        }
+    }
+
+    if (copy_src->pValues) {
+        pValues = new uint64_t[copy_src->semaphoreCount];
+        memcpy((void*)pValues, (void*)copy_src->pValues, sizeof(uint64_t) * copy_src->semaphoreCount);
+    }
+}
+
+safe_VkSemaphoreSignalInfo::safe_VkSemaphoreSignalInfo(const VkSemaphoreSignalInfo* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), semaphore(in_struct->semaphore), value(in_struct->value) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSemaphoreSignalInfo::safe_VkSemaphoreSignalInfo()
+    : sType(VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO), pNext(nullptr), semaphore(), value() {}
+
+safe_VkSemaphoreSignalInfo::safe_VkSemaphoreSignalInfo(const safe_VkSemaphoreSignalInfo& copy_src) {
+    sType = copy_src.sType;
+    semaphore = copy_src.semaphore;
+    value = copy_src.value;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSemaphoreSignalInfo& safe_VkSemaphoreSignalInfo::operator=(const safe_VkSemaphoreSignalInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    semaphore = copy_src.semaphore;
+    value = copy_src.value;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSemaphoreSignalInfo::~safe_VkSemaphoreSignalInfo() { FreePnextChain(pNext); }
+
+void safe_VkSemaphoreSignalInfo::initialize(const VkSemaphoreSignalInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    semaphore = in_struct->semaphore;
+    value = in_struct->value;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSemaphoreSignalInfo::initialize(const safe_VkSemaphoreSignalInfo* copy_src,
+                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    semaphore = copy_src->semaphore;
+    value = copy_src->value;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceBufferDeviceAddressFeatures::safe_VkPhysicalDeviceBufferDeviceAddressFeatures(
+    const VkPhysicalDeviceBufferDeviceAddressFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      bufferDeviceAddress(in_struct->bufferDeviceAddress),
+      bufferDeviceAddressCaptureReplay(in_struct->bufferDeviceAddressCaptureReplay),
+      bufferDeviceAddressMultiDevice(in_struct->bufferDeviceAddressMultiDevice) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceBufferDeviceAddressFeatures::safe_VkPhysicalDeviceBufferDeviceAddressFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES),
+      pNext(nullptr),
+      bufferDeviceAddress(),
+      bufferDeviceAddressCaptureReplay(),
+      bufferDeviceAddressMultiDevice() {}
+
+safe_VkPhysicalDeviceBufferDeviceAddressFeatures::safe_VkPhysicalDeviceBufferDeviceAddressFeatures(
+    const safe_VkPhysicalDeviceBufferDeviceAddressFeatures& copy_src) {
+    sType = copy_src.sType;
+    bufferDeviceAddress = copy_src.bufferDeviceAddress;
+    bufferDeviceAddressCaptureReplay = copy_src.bufferDeviceAddressCaptureReplay;
+    bufferDeviceAddressMultiDevice = copy_src.bufferDeviceAddressMultiDevice;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceBufferDeviceAddressFeatures& safe_VkPhysicalDeviceBufferDeviceAddressFeatures::operator=(
+    const safe_VkPhysicalDeviceBufferDeviceAddressFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    bufferDeviceAddress = copy_src.bufferDeviceAddress;
+    bufferDeviceAddressCaptureReplay = copy_src.bufferDeviceAddressCaptureReplay;
+    bufferDeviceAddressMultiDevice = copy_src.bufferDeviceAddressMultiDevice;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceBufferDeviceAddressFeatures::~safe_VkPhysicalDeviceBufferDeviceAddressFeatures() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceBufferDeviceAddressFeatures::initialize(const VkPhysicalDeviceBufferDeviceAddressFeatures* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    bufferDeviceAddress = in_struct->bufferDeviceAddress;
+    bufferDeviceAddressCaptureReplay = in_struct->bufferDeviceAddressCaptureReplay;
+    bufferDeviceAddressMultiDevice = in_struct->bufferDeviceAddressMultiDevice;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceBufferDeviceAddressFeatures::initialize(const safe_VkPhysicalDeviceBufferDeviceAddressFeatures* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    bufferDeviceAddress = copy_src->bufferDeviceAddress;
+    bufferDeviceAddressCaptureReplay = copy_src->bufferDeviceAddressCaptureReplay;
+    bufferDeviceAddressMultiDevice = copy_src->bufferDeviceAddressMultiDevice;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkBufferDeviceAddressInfo::safe_VkBufferDeviceAddressInfo(const VkBufferDeviceAddressInfo* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), buffer(in_struct->buffer) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkBufferDeviceAddressInfo::safe_VkBufferDeviceAddressInfo()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO), pNext(nullptr), buffer() {}
+
+safe_VkBufferDeviceAddressInfo::safe_VkBufferDeviceAddressInfo(const safe_VkBufferDeviceAddressInfo& copy_src) {
+    sType = copy_src.sType;
+    buffer = copy_src.buffer;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBufferDeviceAddressInfo& safe_VkBufferDeviceAddressInfo::operator=(const safe_VkBufferDeviceAddressInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    buffer = copy_src.buffer;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkBufferDeviceAddressInfo::~safe_VkBufferDeviceAddressInfo() { FreePnextChain(pNext); }
+
+void safe_VkBufferDeviceAddressInfo::initialize(const VkBufferDeviceAddressInfo* in_struct,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    buffer = in_struct->buffer;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkBufferDeviceAddressInfo::initialize(const safe_VkBufferDeviceAddressInfo* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    buffer = copy_src->buffer;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkBufferOpaqueCaptureAddressCreateInfo::safe_VkBufferOpaqueCaptureAddressCreateInfo(
+    const VkBufferOpaqueCaptureAddressCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), opaqueCaptureAddress(in_struct->opaqueCaptureAddress) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkBufferOpaqueCaptureAddressCreateInfo::safe_VkBufferOpaqueCaptureAddressCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO), pNext(nullptr), opaqueCaptureAddress() {}
+
+safe_VkBufferOpaqueCaptureAddressCreateInfo::safe_VkBufferOpaqueCaptureAddressCreateInfo(
+    const safe_VkBufferOpaqueCaptureAddressCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    opaqueCaptureAddress = copy_src.opaqueCaptureAddress;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBufferOpaqueCaptureAddressCreateInfo& safe_VkBufferOpaqueCaptureAddressCreateInfo::operator=(
+    const safe_VkBufferOpaqueCaptureAddressCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    opaqueCaptureAddress = copy_src.opaqueCaptureAddress;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkBufferOpaqueCaptureAddressCreateInfo::~safe_VkBufferOpaqueCaptureAddressCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkBufferOpaqueCaptureAddressCreateInfo::initialize(const VkBufferOpaqueCaptureAddressCreateInfo* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    opaqueCaptureAddress = in_struct->opaqueCaptureAddress;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkBufferOpaqueCaptureAddressCreateInfo::initialize(const safe_VkBufferOpaqueCaptureAddressCreateInfo* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    opaqueCaptureAddress = copy_src->opaqueCaptureAddress;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkMemoryOpaqueCaptureAddressAllocateInfo::safe_VkMemoryOpaqueCaptureAddressAllocateInfo(
+    const VkMemoryOpaqueCaptureAddressAllocateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), opaqueCaptureAddress(in_struct->opaqueCaptureAddress) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMemoryOpaqueCaptureAddressAllocateInfo::safe_VkMemoryOpaqueCaptureAddressAllocateInfo()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO), pNext(nullptr), opaqueCaptureAddress() {}
+
+safe_VkMemoryOpaqueCaptureAddressAllocateInfo::safe_VkMemoryOpaqueCaptureAddressAllocateInfo(
+    const safe_VkMemoryOpaqueCaptureAddressAllocateInfo& copy_src) {
+    sType = copy_src.sType;
+    opaqueCaptureAddress = copy_src.opaqueCaptureAddress;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMemoryOpaqueCaptureAddressAllocateInfo& safe_VkMemoryOpaqueCaptureAddressAllocateInfo::operator=(
+    const safe_VkMemoryOpaqueCaptureAddressAllocateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    opaqueCaptureAddress = copy_src.opaqueCaptureAddress;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMemoryOpaqueCaptureAddressAllocateInfo::~safe_VkMemoryOpaqueCaptureAddressAllocateInfo() { FreePnextChain(pNext); }
+
+void safe_VkMemoryOpaqueCaptureAddressAllocateInfo::initialize(const VkMemoryOpaqueCaptureAddressAllocateInfo* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    opaqueCaptureAddress = in_struct->opaqueCaptureAddress;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMemoryOpaqueCaptureAddressAllocateInfo::initialize(const safe_VkMemoryOpaqueCaptureAddressAllocateInfo* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    opaqueCaptureAddress = copy_src->opaqueCaptureAddress;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDeviceMemoryOpaqueCaptureAddressInfo::safe_VkDeviceMemoryOpaqueCaptureAddressInfo(
+    const VkDeviceMemoryOpaqueCaptureAddressInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), memory(in_struct->memory) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDeviceMemoryOpaqueCaptureAddressInfo::safe_VkDeviceMemoryOpaqueCaptureAddressInfo()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO), pNext(nullptr), memory() {}
+
+safe_VkDeviceMemoryOpaqueCaptureAddressInfo::safe_VkDeviceMemoryOpaqueCaptureAddressInfo(
+    const safe_VkDeviceMemoryOpaqueCaptureAddressInfo& copy_src) {
+    sType = copy_src.sType;
+    memory = copy_src.memory;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDeviceMemoryOpaqueCaptureAddressInfo& safe_VkDeviceMemoryOpaqueCaptureAddressInfo::operator=(
+    const safe_VkDeviceMemoryOpaqueCaptureAddressInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    memory = copy_src.memory;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDeviceMemoryOpaqueCaptureAddressInfo::~safe_VkDeviceMemoryOpaqueCaptureAddressInfo() { FreePnextChain(pNext); }
+
+void safe_VkDeviceMemoryOpaqueCaptureAddressInfo::initialize(const VkDeviceMemoryOpaqueCaptureAddressInfo* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    memory = in_struct->memory;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDeviceMemoryOpaqueCaptureAddressInfo::initialize(const safe_VkDeviceMemoryOpaqueCaptureAddressInfo* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memory = copy_src->memory;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceVulkan13Features::safe_VkPhysicalDeviceVulkan13Features(const VkPhysicalDeviceVulkan13Features* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType),
+      robustImageAccess(in_struct->robustImageAccess),
+      inlineUniformBlock(in_struct->inlineUniformBlock),
+      descriptorBindingInlineUniformBlockUpdateAfterBind(in_struct->descriptorBindingInlineUniformBlockUpdateAfterBind),
+      pipelineCreationCacheControl(in_struct->pipelineCreationCacheControl),
+      privateData(in_struct->privateData),
+      shaderDemoteToHelperInvocation(in_struct->shaderDemoteToHelperInvocation),
+      shaderTerminateInvocation(in_struct->shaderTerminateInvocation),
+      subgroupSizeControl(in_struct->subgroupSizeControl),
+      computeFullSubgroups(in_struct->computeFullSubgroups),
+      synchronization2(in_struct->synchronization2),
+      textureCompressionASTC_HDR(in_struct->textureCompressionASTC_HDR),
+      shaderZeroInitializeWorkgroupMemory(in_struct->shaderZeroInitializeWorkgroupMemory),
+      dynamicRendering(in_struct->dynamicRendering),
+      shaderIntegerDotProduct(in_struct->shaderIntegerDotProduct),
+      maintenance4(in_struct->maintenance4) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceVulkan13Features::safe_VkPhysicalDeviceVulkan13Features()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES),
+      pNext(nullptr),
+      robustImageAccess(),
+      inlineUniformBlock(),
+      descriptorBindingInlineUniformBlockUpdateAfterBind(),
+      pipelineCreationCacheControl(),
+      privateData(),
+      shaderDemoteToHelperInvocation(),
+      shaderTerminateInvocation(),
+      subgroupSizeControl(),
+      computeFullSubgroups(),
+      synchronization2(),
+      textureCompressionASTC_HDR(),
+      shaderZeroInitializeWorkgroupMemory(),
+      dynamicRendering(),
+      shaderIntegerDotProduct(),
+      maintenance4() {}
+
+safe_VkPhysicalDeviceVulkan13Features::safe_VkPhysicalDeviceVulkan13Features(
+    const safe_VkPhysicalDeviceVulkan13Features& copy_src) {
+    sType = copy_src.sType;
+    robustImageAccess = copy_src.robustImageAccess;
+    inlineUniformBlock = copy_src.inlineUniformBlock;
+    descriptorBindingInlineUniformBlockUpdateAfterBind = copy_src.descriptorBindingInlineUniformBlockUpdateAfterBind;
+    pipelineCreationCacheControl = copy_src.pipelineCreationCacheControl;
+    privateData = copy_src.privateData;
+    shaderDemoteToHelperInvocation = copy_src.shaderDemoteToHelperInvocation;
+    shaderTerminateInvocation = copy_src.shaderTerminateInvocation;
+    subgroupSizeControl = copy_src.subgroupSizeControl;
+    computeFullSubgroups = copy_src.computeFullSubgroups;
+    synchronization2 = copy_src.synchronization2;
+    textureCompressionASTC_HDR = copy_src.textureCompressionASTC_HDR;
+    shaderZeroInitializeWorkgroupMemory = copy_src.shaderZeroInitializeWorkgroupMemory;
+    dynamicRendering = copy_src.dynamicRendering;
+    shaderIntegerDotProduct = copy_src.shaderIntegerDotProduct;
+    maintenance4 = copy_src.maintenance4;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceVulkan13Features& safe_VkPhysicalDeviceVulkan13Features::operator=(
+    const safe_VkPhysicalDeviceVulkan13Features& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    robustImageAccess = copy_src.robustImageAccess;
+    inlineUniformBlock = copy_src.inlineUniformBlock;
+    descriptorBindingInlineUniformBlockUpdateAfterBind = copy_src.descriptorBindingInlineUniformBlockUpdateAfterBind;
+    pipelineCreationCacheControl = copy_src.pipelineCreationCacheControl;
+    privateData = copy_src.privateData;
+    shaderDemoteToHelperInvocation = copy_src.shaderDemoteToHelperInvocation;
+    shaderTerminateInvocation = copy_src.shaderTerminateInvocation;
+    subgroupSizeControl = copy_src.subgroupSizeControl;
+    computeFullSubgroups = copy_src.computeFullSubgroups;
+    synchronization2 = copy_src.synchronization2;
+    textureCompressionASTC_HDR = copy_src.textureCompressionASTC_HDR;
+    shaderZeroInitializeWorkgroupMemory = copy_src.shaderZeroInitializeWorkgroupMemory;
+    dynamicRendering = copy_src.dynamicRendering;
+    shaderIntegerDotProduct = copy_src.shaderIntegerDotProduct;
+    maintenance4 = copy_src.maintenance4;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceVulkan13Features::~safe_VkPhysicalDeviceVulkan13Features() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceVulkan13Features::initialize(const VkPhysicalDeviceVulkan13Features* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    robustImageAccess = in_struct->robustImageAccess;
+    inlineUniformBlock = in_struct->inlineUniformBlock;
+    descriptorBindingInlineUniformBlockUpdateAfterBind = in_struct->descriptorBindingInlineUniformBlockUpdateAfterBind;
+    pipelineCreationCacheControl = in_struct->pipelineCreationCacheControl;
+    privateData = in_struct->privateData;
+    shaderDemoteToHelperInvocation = in_struct->shaderDemoteToHelperInvocation;
+    shaderTerminateInvocation = in_struct->shaderTerminateInvocation;
+    subgroupSizeControl = in_struct->subgroupSizeControl;
+    computeFullSubgroups = in_struct->computeFullSubgroups;
+    synchronization2 = in_struct->synchronization2;
+    textureCompressionASTC_HDR = in_struct->textureCompressionASTC_HDR;
+    shaderZeroInitializeWorkgroupMemory = in_struct->shaderZeroInitializeWorkgroupMemory;
+    dynamicRendering = in_struct->dynamicRendering;
+    shaderIntegerDotProduct = in_struct->shaderIntegerDotProduct;
+    maintenance4 = in_struct->maintenance4;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceVulkan13Features::initialize(const safe_VkPhysicalDeviceVulkan13Features* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    robustImageAccess = copy_src->robustImageAccess;
+    inlineUniformBlock = copy_src->inlineUniformBlock;
+    descriptorBindingInlineUniformBlockUpdateAfterBind = copy_src->descriptorBindingInlineUniformBlockUpdateAfterBind;
+    pipelineCreationCacheControl = copy_src->pipelineCreationCacheControl;
+    privateData = copy_src->privateData;
+    shaderDemoteToHelperInvocation = copy_src->shaderDemoteToHelperInvocation;
+    shaderTerminateInvocation = copy_src->shaderTerminateInvocation;
+    subgroupSizeControl = copy_src->subgroupSizeControl;
+    computeFullSubgroups = copy_src->computeFullSubgroups;
+    synchronization2 = copy_src->synchronization2;
+    textureCompressionASTC_HDR = copy_src->textureCompressionASTC_HDR;
+    shaderZeroInitializeWorkgroupMemory = copy_src->shaderZeroInitializeWorkgroupMemory;
+    dynamicRendering = copy_src->dynamicRendering;
+    shaderIntegerDotProduct = copy_src->shaderIntegerDotProduct;
+    maintenance4 = copy_src->maintenance4;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceVulkan13Properties::safe_VkPhysicalDeviceVulkan13Properties(
+    const VkPhysicalDeviceVulkan13Properties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      minSubgroupSize(in_struct->minSubgroupSize),
+      maxSubgroupSize(in_struct->maxSubgroupSize),
+      maxComputeWorkgroupSubgroups(in_struct->maxComputeWorkgroupSubgroups),
+      requiredSubgroupSizeStages(in_struct->requiredSubgroupSizeStages),
+      maxInlineUniformBlockSize(in_struct->maxInlineUniformBlockSize),
+      maxPerStageDescriptorInlineUniformBlocks(in_struct->maxPerStageDescriptorInlineUniformBlocks),
+      maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks(in_struct->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks),
+      maxDescriptorSetInlineUniformBlocks(in_struct->maxDescriptorSetInlineUniformBlocks),
+      maxDescriptorSetUpdateAfterBindInlineUniformBlocks(in_struct->maxDescriptorSetUpdateAfterBindInlineUniformBlocks),
+      maxInlineUniformTotalSize(in_struct->maxInlineUniformTotalSize),
+      integerDotProduct8BitUnsignedAccelerated(in_struct->integerDotProduct8BitUnsignedAccelerated),
+      integerDotProduct8BitSignedAccelerated(in_struct->integerDotProduct8BitSignedAccelerated),
+      integerDotProduct8BitMixedSignednessAccelerated(in_struct->integerDotProduct8BitMixedSignednessAccelerated),
+      integerDotProduct4x8BitPackedUnsignedAccelerated(in_struct->integerDotProduct4x8BitPackedUnsignedAccelerated),
+      integerDotProduct4x8BitPackedSignedAccelerated(in_struct->integerDotProduct4x8BitPackedSignedAccelerated),
+      integerDotProduct4x8BitPackedMixedSignednessAccelerated(in_struct->integerDotProduct4x8BitPackedMixedSignednessAccelerated),
+      integerDotProduct16BitUnsignedAccelerated(in_struct->integerDotProduct16BitUnsignedAccelerated),
+      integerDotProduct16BitSignedAccelerated(in_struct->integerDotProduct16BitSignedAccelerated),
+      integerDotProduct16BitMixedSignednessAccelerated(in_struct->integerDotProduct16BitMixedSignednessAccelerated),
+      integerDotProduct32BitUnsignedAccelerated(in_struct->integerDotProduct32BitUnsignedAccelerated),
+      integerDotProduct32BitSignedAccelerated(in_struct->integerDotProduct32BitSignedAccelerated),
+      integerDotProduct32BitMixedSignednessAccelerated(in_struct->integerDotProduct32BitMixedSignednessAccelerated),
+      integerDotProduct64BitUnsignedAccelerated(in_struct->integerDotProduct64BitUnsignedAccelerated),
+      integerDotProduct64BitSignedAccelerated(in_struct->integerDotProduct64BitSignedAccelerated),
+      integerDotProduct64BitMixedSignednessAccelerated(in_struct->integerDotProduct64BitMixedSignednessAccelerated),
+      integerDotProductAccumulatingSaturating8BitUnsignedAccelerated(
+          in_struct->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated),
+      integerDotProductAccumulatingSaturating8BitSignedAccelerated(
+          in_struct->integerDotProductAccumulatingSaturating8BitSignedAccelerated),
+      integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated(
+          in_struct->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated),
+      integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated(
+          in_struct->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated),
+      integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated(
+          in_struct->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated),
+      integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated(
+          in_struct->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated),
+      integerDotProductAccumulatingSaturating16BitUnsignedAccelerated(
+          in_struct->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated),
+      integerDotProductAccumulatingSaturating16BitSignedAccelerated(
+          in_struct->integerDotProductAccumulatingSaturating16BitSignedAccelerated),
+      integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated(
+          in_struct->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated),
+      integerDotProductAccumulatingSaturating32BitUnsignedAccelerated(
+          in_struct->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated),
+      integerDotProductAccumulatingSaturating32BitSignedAccelerated(
+          in_struct->integerDotProductAccumulatingSaturating32BitSignedAccelerated),
+      integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated(
+          in_struct->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated),
+      integerDotProductAccumulatingSaturating64BitUnsignedAccelerated(
+          in_struct->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated),
+      integerDotProductAccumulatingSaturating64BitSignedAccelerated(
+          in_struct->integerDotProductAccumulatingSaturating64BitSignedAccelerated),
+      integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated(
+          in_struct->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated),
+      storageTexelBufferOffsetAlignmentBytes(in_struct->storageTexelBufferOffsetAlignmentBytes),
+      storageTexelBufferOffsetSingleTexelAlignment(in_struct->storageTexelBufferOffsetSingleTexelAlignment),
+      uniformTexelBufferOffsetAlignmentBytes(in_struct->uniformTexelBufferOffsetAlignmentBytes),
+      uniformTexelBufferOffsetSingleTexelAlignment(in_struct->uniformTexelBufferOffsetSingleTexelAlignment),
+      maxBufferSize(in_struct->maxBufferSize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceVulkan13Properties::safe_VkPhysicalDeviceVulkan13Properties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES),
+      pNext(nullptr),
+      minSubgroupSize(),
+      maxSubgroupSize(),
+      maxComputeWorkgroupSubgroups(),
+      requiredSubgroupSizeStages(),
+      maxInlineUniformBlockSize(),
+      maxPerStageDescriptorInlineUniformBlocks(),
+      maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks(),
+      maxDescriptorSetInlineUniformBlocks(),
+      maxDescriptorSetUpdateAfterBindInlineUniformBlocks(),
+      maxInlineUniformTotalSize(),
+      integerDotProduct8BitUnsignedAccelerated(),
+      integerDotProduct8BitSignedAccelerated(),
+      integerDotProduct8BitMixedSignednessAccelerated(),
+      integerDotProduct4x8BitPackedUnsignedAccelerated(),
+      integerDotProduct4x8BitPackedSignedAccelerated(),
+      integerDotProduct4x8BitPackedMixedSignednessAccelerated(),
+      integerDotProduct16BitUnsignedAccelerated(),
+      integerDotProduct16BitSignedAccelerated(),
+      integerDotProduct16BitMixedSignednessAccelerated(),
+      integerDotProduct32BitUnsignedAccelerated(),
+      integerDotProduct32BitSignedAccelerated(),
+      integerDotProduct32BitMixedSignednessAccelerated(),
+      integerDotProduct64BitUnsignedAccelerated(),
+      integerDotProduct64BitSignedAccelerated(),
+      integerDotProduct64BitMixedSignednessAccelerated(),
+      integerDotProductAccumulatingSaturating8BitUnsignedAccelerated(),
+      integerDotProductAccumulatingSaturating8BitSignedAccelerated(),
+      integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated(),
+      integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated(),
+      integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated(),
+      integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated(),
+      integerDotProductAccumulatingSaturating16BitUnsignedAccelerated(),
+      integerDotProductAccumulatingSaturating16BitSignedAccelerated(),
+      integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated(),
+      integerDotProductAccumulatingSaturating32BitUnsignedAccelerated(),
+      integerDotProductAccumulatingSaturating32BitSignedAccelerated(),
+      integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated(),
+      integerDotProductAccumulatingSaturating64BitUnsignedAccelerated(),
+      integerDotProductAccumulatingSaturating64BitSignedAccelerated(),
+      integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated(),
+      storageTexelBufferOffsetAlignmentBytes(),
+      storageTexelBufferOffsetSingleTexelAlignment(),
+      uniformTexelBufferOffsetAlignmentBytes(),
+      uniformTexelBufferOffsetSingleTexelAlignment(),
+      maxBufferSize() {}
+
+safe_VkPhysicalDeviceVulkan13Properties::safe_VkPhysicalDeviceVulkan13Properties(
+    const safe_VkPhysicalDeviceVulkan13Properties& copy_src) {
+    sType = copy_src.sType;
+    minSubgroupSize = copy_src.minSubgroupSize;
+    maxSubgroupSize = copy_src.maxSubgroupSize;
+    maxComputeWorkgroupSubgroups = copy_src.maxComputeWorkgroupSubgroups;
+    requiredSubgroupSizeStages = copy_src.requiredSubgroupSizeStages;
+    maxInlineUniformBlockSize = copy_src.maxInlineUniformBlockSize;
+    maxPerStageDescriptorInlineUniformBlocks = copy_src.maxPerStageDescriptorInlineUniformBlocks;
+    maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = copy_src.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
+    maxDescriptorSetInlineUniformBlocks = copy_src.maxDescriptorSetInlineUniformBlocks;
+    maxDescriptorSetUpdateAfterBindInlineUniformBlocks = copy_src.maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
+    maxInlineUniformTotalSize = copy_src.maxInlineUniformTotalSize;
+    integerDotProduct8BitUnsignedAccelerated = copy_src.integerDotProduct8BitUnsignedAccelerated;
+    integerDotProduct8BitSignedAccelerated = copy_src.integerDotProduct8BitSignedAccelerated;
+    integerDotProduct8BitMixedSignednessAccelerated = copy_src.integerDotProduct8BitMixedSignednessAccelerated;
+    integerDotProduct4x8BitPackedUnsignedAccelerated = copy_src.integerDotProduct4x8BitPackedUnsignedAccelerated;
+    integerDotProduct4x8BitPackedSignedAccelerated = copy_src.integerDotProduct4x8BitPackedSignedAccelerated;
+    integerDotProduct4x8BitPackedMixedSignednessAccelerated = copy_src.integerDotProduct4x8BitPackedMixedSignednessAccelerated;
+    integerDotProduct16BitUnsignedAccelerated = copy_src.integerDotProduct16BitUnsignedAccelerated;
+    integerDotProduct16BitSignedAccelerated = copy_src.integerDotProduct16BitSignedAccelerated;
+    integerDotProduct16BitMixedSignednessAccelerated = copy_src.integerDotProduct16BitMixedSignednessAccelerated;
+    integerDotProduct32BitUnsignedAccelerated = copy_src.integerDotProduct32BitUnsignedAccelerated;
+    integerDotProduct32BitSignedAccelerated = copy_src.integerDotProduct32BitSignedAccelerated;
+    integerDotProduct32BitMixedSignednessAccelerated = copy_src.integerDotProduct32BitMixedSignednessAccelerated;
+    integerDotProduct64BitUnsignedAccelerated = copy_src.integerDotProduct64BitUnsignedAccelerated;
+    integerDotProduct64BitSignedAccelerated = copy_src.integerDotProduct64BitSignedAccelerated;
+    integerDotProduct64BitMixedSignednessAccelerated = copy_src.integerDotProduct64BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating8BitUnsignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating8BitSignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating8BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
+    integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating16BitUnsignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating16BitSignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating16BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating32BitUnsignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating32BitSignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating32BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating64BitUnsignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating64BitSignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating64BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
+    storageTexelBufferOffsetAlignmentBytes = copy_src.storageTexelBufferOffsetAlignmentBytes;
+    storageTexelBufferOffsetSingleTexelAlignment = copy_src.storageTexelBufferOffsetSingleTexelAlignment;
+    uniformTexelBufferOffsetAlignmentBytes = copy_src.uniformTexelBufferOffsetAlignmentBytes;
+    uniformTexelBufferOffsetSingleTexelAlignment = copy_src.uniformTexelBufferOffsetSingleTexelAlignment;
+    maxBufferSize = copy_src.maxBufferSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceVulkan13Properties& safe_VkPhysicalDeviceVulkan13Properties::operator=(
+    const safe_VkPhysicalDeviceVulkan13Properties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    minSubgroupSize = copy_src.minSubgroupSize;
+    maxSubgroupSize = copy_src.maxSubgroupSize;
+    maxComputeWorkgroupSubgroups = copy_src.maxComputeWorkgroupSubgroups;
+    requiredSubgroupSizeStages = copy_src.requiredSubgroupSizeStages;
+    maxInlineUniformBlockSize = copy_src.maxInlineUniformBlockSize;
+    maxPerStageDescriptorInlineUniformBlocks = copy_src.maxPerStageDescriptorInlineUniformBlocks;
+    maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = copy_src.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
+    maxDescriptorSetInlineUniformBlocks = copy_src.maxDescriptorSetInlineUniformBlocks;
+    maxDescriptorSetUpdateAfterBindInlineUniformBlocks = copy_src.maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
+    maxInlineUniformTotalSize = copy_src.maxInlineUniformTotalSize;
+    integerDotProduct8BitUnsignedAccelerated = copy_src.integerDotProduct8BitUnsignedAccelerated;
+    integerDotProduct8BitSignedAccelerated = copy_src.integerDotProduct8BitSignedAccelerated;
+    integerDotProduct8BitMixedSignednessAccelerated = copy_src.integerDotProduct8BitMixedSignednessAccelerated;
+    integerDotProduct4x8BitPackedUnsignedAccelerated = copy_src.integerDotProduct4x8BitPackedUnsignedAccelerated;
+    integerDotProduct4x8BitPackedSignedAccelerated = copy_src.integerDotProduct4x8BitPackedSignedAccelerated;
+    integerDotProduct4x8BitPackedMixedSignednessAccelerated = copy_src.integerDotProduct4x8BitPackedMixedSignednessAccelerated;
+    integerDotProduct16BitUnsignedAccelerated = copy_src.integerDotProduct16BitUnsignedAccelerated;
+    integerDotProduct16BitSignedAccelerated = copy_src.integerDotProduct16BitSignedAccelerated;
+    integerDotProduct16BitMixedSignednessAccelerated = copy_src.integerDotProduct16BitMixedSignednessAccelerated;
+    integerDotProduct32BitUnsignedAccelerated = copy_src.integerDotProduct32BitUnsignedAccelerated;
+    integerDotProduct32BitSignedAccelerated = copy_src.integerDotProduct32BitSignedAccelerated;
+    integerDotProduct32BitMixedSignednessAccelerated = copy_src.integerDotProduct32BitMixedSignednessAccelerated;
+    integerDotProduct64BitUnsignedAccelerated = copy_src.integerDotProduct64BitUnsignedAccelerated;
+    integerDotProduct64BitSignedAccelerated = copy_src.integerDotProduct64BitSignedAccelerated;
+    integerDotProduct64BitMixedSignednessAccelerated = copy_src.integerDotProduct64BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating8BitUnsignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating8BitSignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating8BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
+    integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating16BitUnsignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating16BitSignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating16BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating32BitUnsignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating32BitSignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating32BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating64BitUnsignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating64BitSignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating64BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
+    storageTexelBufferOffsetAlignmentBytes = copy_src.storageTexelBufferOffsetAlignmentBytes;
+    storageTexelBufferOffsetSingleTexelAlignment = copy_src.storageTexelBufferOffsetSingleTexelAlignment;
+    uniformTexelBufferOffsetAlignmentBytes = copy_src.uniformTexelBufferOffsetAlignmentBytes;
+    uniformTexelBufferOffsetSingleTexelAlignment = copy_src.uniformTexelBufferOffsetSingleTexelAlignment;
+    maxBufferSize = copy_src.maxBufferSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceVulkan13Properties::~safe_VkPhysicalDeviceVulkan13Properties() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceVulkan13Properties::initialize(const VkPhysicalDeviceVulkan13Properties* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    minSubgroupSize = in_struct->minSubgroupSize;
+    maxSubgroupSize = in_struct->maxSubgroupSize;
+    maxComputeWorkgroupSubgroups = in_struct->maxComputeWorkgroupSubgroups;
+    requiredSubgroupSizeStages = in_struct->requiredSubgroupSizeStages;
+    maxInlineUniformBlockSize = in_struct->maxInlineUniformBlockSize;
+    maxPerStageDescriptorInlineUniformBlocks = in_struct->maxPerStageDescriptorInlineUniformBlocks;
+    maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = in_struct->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
+    maxDescriptorSetInlineUniformBlocks = in_struct->maxDescriptorSetInlineUniformBlocks;
+    maxDescriptorSetUpdateAfterBindInlineUniformBlocks = in_struct->maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
+    maxInlineUniformTotalSize = in_struct->maxInlineUniformTotalSize;
+    integerDotProduct8BitUnsignedAccelerated = in_struct->integerDotProduct8BitUnsignedAccelerated;
+    integerDotProduct8BitSignedAccelerated = in_struct->integerDotProduct8BitSignedAccelerated;
+    integerDotProduct8BitMixedSignednessAccelerated = in_struct->integerDotProduct8BitMixedSignednessAccelerated;
+    integerDotProduct4x8BitPackedUnsignedAccelerated = in_struct->integerDotProduct4x8BitPackedUnsignedAccelerated;
+    integerDotProduct4x8BitPackedSignedAccelerated = in_struct->integerDotProduct4x8BitPackedSignedAccelerated;
+    integerDotProduct4x8BitPackedMixedSignednessAccelerated = in_struct->integerDotProduct4x8BitPackedMixedSignednessAccelerated;
+    integerDotProduct16BitUnsignedAccelerated = in_struct->integerDotProduct16BitUnsignedAccelerated;
+    integerDotProduct16BitSignedAccelerated = in_struct->integerDotProduct16BitSignedAccelerated;
+    integerDotProduct16BitMixedSignednessAccelerated = in_struct->integerDotProduct16BitMixedSignednessAccelerated;
+    integerDotProduct32BitUnsignedAccelerated = in_struct->integerDotProduct32BitUnsignedAccelerated;
+    integerDotProduct32BitSignedAccelerated = in_struct->integerDotProduct32BitSignedAccelerated;
+    integerDotProduct32BitMixedSignednessAccelerated = in_struct->integerDotProduct32BitMixedSignednessAccelerated;
+    integerDotProduct64BitUnsignedAccelerated = in_struct->integerDotProduct64BitUnsignedAccelerated;
+    integerDotProduct64BitSignedAccelerated = in_struct->integerDotProduct64BitSignedAccelerated;
+    integerDotProduct64BitMixedSignednessAccelerated = in_struct->integerDotProduct64BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating8BitUnsignedAccelerated =
+        in_struct->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating8BitSignedAccelerated =
+        in_struct->integerDotProductAccumulatingSaturating8BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated =
+        in_struct->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated =
+        in_struct->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated =
+        in_struct->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
+    integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated =
+        in_struct->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating16BitUnsignedAccelerated =
+        in_struct->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating16BitSignedAccelerated =
+        in_struct->integerDotProductAccumulatingSaturating16BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated =
+        in_struct->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating32BitUnsignedAccelerated =
+        in_struct->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating32BitSignedAccelerated =
+        in_struct->integerDotProductAccumulatingSaturating32BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated =
+        in_struct->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating64BitUnsignedAccelerated =
+        in_struct->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating64BitSignedAccelerated =
+        in_struct->integerDotProductAccumulatingSaturating64BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated =
+        in_struct->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
+    storageTexelBufferOffsetAlignmentBytes = in_struct->storageTexelBufferOffsetAlignmentBytes;
+    storageTexelBufferOffsetSingleTexelAlignment = in_struct->storageTexelBufferOffsetSingleTexelAlignment;
+    uniformTexelBufferOffsetAlignmentBytes = in_struct->uniformTexelBufferOffsetAlignmentBytes;
+    uniformTexelBufferOffsetSingleTexelAlignment = in_struct->uniformTexelBufferOffsetSingleTexelAlignment;
+    maxBufferSize = in_struct->maxBufferSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceVulkan13Properties::initialize(const safe_VkPhysicalDeviceVulkan13Properties* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    minSubgroupSize = copy_src->minSubgroupSize;
+    maxSubgroupSize = copy_src->maxSubgroupSize;
+    maxComputeWorkgroupSubgroups = copy_src->maxComputeWorkgroupSubgroups;
+    requiredSubgroupSizeStages = copy_src->requiredSubgroupSizeStages;
+    maxInlineUniformBlockSize = copy_src->maxInlineUniformBlockSize;
+    maxPerStageDescriptorInlineUniformBlocks = copy_src->maxPerStageDescriptorInlineUniformBlocks;
+    maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = copy_src->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
+    maxDescriptorSetInlineUniformBlocks = copy_src->maxDescriptorSetInlineUniformBlocks;
+    maxDescriptorSetUpdateAfterBindInlineUniformBlocks = copy_src->maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
+    maxInlineUniformTotalSize = copy_src->maxInlineUniformTotalSize;
+    integerDotProduct8BitUnsignedAccelerated = copy_src->integerDotProduct8BitUnsignedAccelerated;
+    integerDotProduct8BitSignedAccelerated = copy_src->integerDotProduct8BitSignedAccelerated;
+    integerDotProduct8BitMixedSignednessAccelerated = copy_src->integerDotProduct8BitMixedSignednessAccelerated;
+    integerDotProduct4x8BitPackedUnsignedAccelerated = copy_src->integerDotProduct4x8BitPackedUnsignedAccelerated;
+    integerDotProduct4x8BitPackedSignedAccelerated = copy_src->integerDotProduct4x8BitPackedSignedAccelerated;
+    integerDotProduct4x8BitPackedMixedSignednessAccelerated = copy_src->integerDotProduct4x8BitPackedMixedSignednessAccelerated;
+    integerDotProduct16BitUnsignedAccelerated = copy_src->integerDotProduct16BitUnsignedAccelerated;
+    integerDotProduct16BitSignedAccelerated = copy_src->integerDotProduct16BitSignedAccelerated;
+    integerDotProduct16BitMixedSignednessAccelerated = copy_src->integerDotProduct16BitMixedSignednessAccelerated;
+    integerDotProduct32BitUnsignedAccelerated = copy_src->integerDotProduct32BitUnsignedAccelerated;
+    integerDotProduct32BitSignedAccelerated = copy_src->integerDotProduct32BitSignedAccelerated;
+    integerDotProduct32BitMixedSignednessAccelerated = copy_src->integerDotProduct32BitMixedSignednessAccelerated;
+    integerDotProduct64BitUnsignedAccelerated = copy_src->integerDotProduct64BitUnsignedAccelerated;
+    integerDotProduct64BitSignedAccelerated = copy_src->integerDotProduct64BitSignedAccelerated;
+    integerDotProduct64BitMixedSignednessAccelerated = copy_src->integerDotProduct64BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating8BitUnsignedAccelerated =
+        copy_src->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating8BitSignedAccelerated =
+        copy_src->integerDotProductAccumulatingSaturating8BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated =
+        copy_src->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated =
+        copy_src->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated =
+        copy_src->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
+    integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated =
+        copy_src->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating16BitUnsignedAccelerated =
+        copy_src->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating16BitSignedAccelerated =
+        copy_src->integerDotProductAccumulatingSaturating16BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated =
+        copy_src->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating32BitUnsignedAccelerated =
+        copy_src->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating32BitSignedAccelerated =
+        copy_src->integerDotProductAccumulatingSaturating32BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated =
+        copy_src->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating64BitUnsignedAccelerated =
+        copy_src->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating64BitSignedAccelerated =
+        copy_src->integerDotProductAccumulatingSaturating64BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated =
+        copy_src->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
+    storageTexelBufferOffsetAlignmentBytes = copy_src->storageTexelBufferOffsetAlignmentBytes;
+    storageTexelBufferOffsetSingleTexelAlignment = copy_src->storageTexelBufferOffsetSingleTexelAlignment;
+    uniformTexelBufferOffsetAlignmentBytes = copy_src->uniformTexelBufferOffsetAlignmentBytes;
+    uniformTexelBufferOffsetSingleTexelAlignment = copy_src->uniformTexelBufferOffsetSingleTexelAlignment;
+    maxBufferSize = copy_src->maxBufferSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineCreationFeedbackCreateInfo::safe_VkPipelineCreationFeedbackCreateInfo(
+    const VkPipelineCreationFeedbackCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      pPipelineCreationFeedback(nullptr),
+      pipelineStageCreationFeedbackCount(in_struct->pipelineStageCreationFeedbackCount),
+      pPipelineStageCreationFeedbacks(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pPipelineCreationFeedback) {
+        pPipelineCreationFeedback = new VkPipelineCreationFeedback(*in_struct->pPipelineCreationFeedback);
+    }
+
+    if (in_struct->pPipelineStageCreationFeedbacks) {
+        pPipelineStageCreationFeedbacks = new VkPipelineCreationFeedback[in_struct->pipelineStageCreationFeedbackCount];
+        memcpy((void*)pPipelineStageCreationFeedbacks, (void*)in_struct->pPipelineStageCreationFeedbacks,
+               sizeof(VkPipelineCreationFeedback) * in_struct->pipelineStageCreationFeedbackCount);
+    }
+}
+
+safe_VkPipelineCreationFeedbackCreateInfo::safe_VkPipelineCreationFeedbackCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO),
+      pNext(nullptr),
+      pPipelineCreationFeedback(nullptr),
+      pipelineStageCreationFeedbackCount(),
+      pPipelineStageCreationFeedbacks(nullptr) {}
+
+safe_VkPipelineCreationFeedbackCreateInfo::safe_VkPipelineCreationFeedbackCreateInfo(
+    const safe_VkPipelineCreationFeedbackCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    pPipelineCreationFeedback = nullptr;
+    pipelineStageCreationFeedbackCount = copy_src.pipelineStageCreationFeedbackCount;
+    pPipelineStageCreationFeedbacks = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pPipelineCreationFeedback) {
+        pPipelineCreationFeedback = new VkPipelineCreationFeedback(*copy_src.pPipelineCreationFeedback);
+    }
+
+    if (copy_src.pPipelineStageCreationFeedbacks) {
+        pPipelineStageCreationFeedbacks = new VkPipelineCreationFeedback[copy_src.pipelineStageCreationFeedbackCount];
+        memcpy((void*)pPipelineStageCreationFeedbacks, (void*)copy_src.pPipelineStageCreationFeedbacks,
+               sizeof(VkPipelineCreationFeedback) * copy_src.pipelineStageCreationFeedbackCount);
+    }
+}
+
+safe_VkPipelineCreationFeedbackCreateInfo& safe_VkPipelineCreationFeedbackCreateInfo::operator=(
+    const safe_VkPipelineCreationFeedbackCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pPipelineCreationFeedback) delete pPipelineCreationFeedback;
+    if (pPipelineStageCreationFeedbacks) delete[] pPipelineStageCreationFeedbacks;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pPipelineCreationFeedback = nullptr;
+    pipelineStageCreationFeedbackCount = copy_src.pipelineStageCreationFeedbackCount;
+    pPipelineStageCreationFeedbacks = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pPipelineCreationFeedback) {
+        pPipelineCreationFeedback = new VkPipelineCreationFeedback(*copy_src.pPipelineCreationFeedback);
+    }
+
+    if (copy_src.pPipelineStageCreationFeedbacks) {
+        pPipelineStageCreationFeedbacks = new VkPipelineCreationFeedback[copy_src.pipelineStageCreationFeedbackCount];
+        memcpy((void*)pPipelineStageCreationFeedbacks, (void*)copy_src.pPipelineStageCreationFeedbacks,
+               sizeof(VkPipelineCreationFeedback) * copy_src.pipelineStageCreationFeedbackCount);
+    }
+
+    return *this;
+}
+
+safe_VkPipelineCreationFeedbackCreateInfo::~safe_VkPipelineCreationFeedbackCreateInfo() {
+    if (pPipelineCreationFeedback) delete pPipelineCreationFeedback;
+    if (pPipelineStageCreationFeedbacks) delete[] pPipelineStageCreationFeedbacks;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineCreationFeedbackCreateInfo::initialize(const VkPipelineCreationFeedbackCreateInfo* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pPipelineCreationFeedback) delete pPipelineCreationFeedback;
+    if (pPipelineStageCreationFeedbacks) delete[] pPipelineStageCreationFeedbacks;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pPipelineCreationFeedback = nullptr;
+    pipelineStageCreationFeedbackCount = in_struct->pipelineStageCreationFeedbackCount;
+    pPipelineStageCreationFeedbacks = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pPipelineCreationFeedback) {
+        pPipelineCreationFeedback = new VkPipelineCreationFeedback(*in_struct->pPipelineCreationFeedback);
+    }
+
+    if (in_struct->pPipelineStageCreationFeedbacks) {
+        pPipelineStageCreationFeedbacks = new VkPipelineCreationFeedback[in_struct->pipelineStageCreationFeedbackCount];
+        memcpy((void*)pPipelineStageCreationFeedbacks, (void*)in_struct->pPipelineStageCreationFeedbacks,
+               sizeof(VkPipelineCreationFeedback) * in_struct->pipelineStageCreationFeedbackCount);
+    }
+}
+
+void safe_VkPipelineCreationFeedbackCreateInfo::initialize(const safe_VkPipelineCreationFeedbackCreateInfo* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pPipelineCreationFeedback = nullptr;
+    pipelineStageCreationFeedbackCount = copy_src->pipelineStageCreationFeedbackCount;
+    pPipelineStageCreationFeedbacks = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pPipelineCreationFeedback) {
+        pPipelineCreationFeedback = new VkPipelineCreationFeedback(*copy_src->pPipelineCreationFeedback);
+    }
+
+    if (copy_src->pPipelineStageCreationFeedbacks) {
+        pPipelineStageCreationFeedbacks = new VkPipelineCreationFeedback[copy_src->pipelineStageCreationFeedbackCount];
+        memcpy((void*)pPipelineStageCreationFeedbacks, (void*)copy_src->pPipelineStageCreationFeedbacks,
+               sizeof(VkPipelineCreationFeedback) * copy_src->pipelineStageCreationFeedbackCount);
+    }
+}
+
+safe_VkPhysicalDeviceShaderTerminateInvocationFeatures::safe_VkPhysicalDeviceShaderTerminateInvocationFeatures(
+    const VkPhysicalDeviceShaderTerminateInvocationFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), shaderTerminateInvocation(in_struct->shaderTerminateInvocation) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderTerminateInvocationFeatures::safe_VkPhysicalDeviceShaderTerminateInvocationFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES), pNext(nullptr), shaderTerminateInvocation() {}
+
+safe_VkPhysicalDeviceShaderTerminateInvocationFeatures::safe_VkPhysicalDeviceShaderTerminateInvocationFeatures(
+    const safe_VkPhysicalDeviceShaderTerminateInvocationFeatures& copy_src) {
+    sType = copy_src.sType;
+    shaderTerminateInvocation = copy_src.shaderTerminateInvocation;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderTerminateInvocationFeatures& safe_VkPhysicalDeviceShaderTerminateInvocationFeatures::operator=(
+    const safe_VkPhysicalDeviceShaderTerminateInvocationFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderTerminateInvocation = copy_src.shaderTerminateInvocation;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderTerminateInvocationFeatures::~safe_VkPhysicalDeviceShaderTerminateInvocationFeatures() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceShaderTerminateInvocationFeatures::initialize(
+    const VkPhysicalDeviceShaderTerminateInvocationFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderTerminateInvocation = in_struct->shaderTerminateInvocation;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderTerminateInvocationFeatures::initialize(
+    const safe_VkPhysicalDeviceShaderTerminateInvocationFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderTerminateInvocation = copy_src->shaderTerminateInvocation;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceToolProperties::safe_VkPhysicalDeviceToolProperties(const VkPhysicalDeviceToolProperties* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType), purposes(in_struct->purposes) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
+        name[i] = in_struct->name[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
+        version[i] = in_struct->version[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = in_struct->description[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
+        layer[i] = in_struct->layer[i];
+    }
+}
+
+safe_VkPhysicalDeviceToolProperties::safe_VkPhysicalDeviceToolProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES), pNext(nullptr), purposes() {}
+
+safe_VkPhysicalDeviceToolProperties::safe_VkPhysicalDeviceToolProperties(const safe_VkPhysicalDeviceToolProperties& copy_src) {
+    sType = copy_src.sType;
+    purposes = copy_src.purposes;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
+        name[i] = copy_src.name[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
+        version[i] = copy_src.version[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = copy_src.description[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
+        layer[i] = copy_src.layer[i];
+    }
+}
+
+safe_VkPhysicalDeviceToolProperties& safe_VkPhysicalDeviceToolProperties::operator=(
+    const safe_VkPhysicalDeviceToolProperties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    purposes = copy_src.purposes;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
+        name[i] = copy_src.name[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
+        version[i] = copy_src.version[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = copy_src.description[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
+        layer[i] = copy_src.layer[i];
+    }
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceToolProperties::~safe_VkPhysicalDeviceToolProperties() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceToolProperties::initialize(const VkPhysicalDeviceToolProperties* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    purposes = in_struct->purposes;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
+        name[i] = in_struct->name[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
+        version[i] = in_struct->version[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = in_struct->description[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
+        layer[i] = in_struct->layer[i];
+    }
+}
+
+void safe_VkPhysicalDeviceToolProperties::initialize(const safe_VkPhysicalDeviceToolProperties* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    purposes = copy_src->purposes;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
+        name[i] = copy_src->name[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
+        version[i] = copy_src->version[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = copy_src->description[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
+        layer[i] = copy_src->layer[i];
+    }
+}
+
+safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures::safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+    const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), shaderDemoteToHelperInvocation(in_struct->shaderDemoteToHelperInvocation) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures::safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES),
+      pNext(nullptr),
+      shaderDemoteToHelperInvocation() {}
+
+safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures::safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+    const safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures& copy_src) {
+    sType = copy_src.sType;
+    shaderDemoteToHelperInvocation = copy_src.shaderDemoteToHelperInvocation;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures& safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures::operator=(
+    const safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderDemoteToHelperInvocation = copy_src.shaderDemoteToHelperInvocation;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures::~safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures::initialize(
+    const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderDemoteToHelperInvocation = in_struct->shaderDemoteToHelperInvocation;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures::initialize(
+    const safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderDemoteToHelperInvocation = copy_src->shaderDemoteToHelperInvocation;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDevicePrivateDataFeatures::safe_VkPhysicalDevicePrivateDataFeatures(
+    const VkPhysicalDevicePrivateDataFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), privateData(in_struct->privateData) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePrivateDataFeatures::safe_VkPhysicalDevicePrivateDataFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES), pNext(nullptr), privateData() {}
+
+safe_VkPhysicalDevicePrivateDataFeatures::safe_VkPhysicalDevicePrivateDataFeatures(
+    const safe_VkPhysicalDevicePrivateDataFeatures& copy_src) {
+    sType = copy_src.sType;
+    privateData = copy_src.privateData;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePrivateDataFeatures& safe_VkPhysicalDevicePrivateDataFeatures::operator=(
+    const safe_VkPhysicalDevicePrivateDataFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    privateData = copy_src.privateData;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePrivateDataFeatures::~safe_VkPhysicalDevicePrivateDataFeatures() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDevicePrivateDataFeatures::initialize(const VkPhysicalDevicePrivateDataFeatures* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    privateData = in_struct->privateData;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePrivateDataFeatures::initialize(const safe_VkPhysicalDevicePrivateDataFeatures* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    privateData = copy_src->privateData;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDevicePrivateDataCreateInfo::safe_VkDevicePrivateDataCreateInfo(const VkDevicePrivateDataCreateInfo* in_struct,
+                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), privateDataSlotRequestCount(in_struct->privateDataSlotRequestCount) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDevicePrivateDataCreateInfo::safe_VkDevicePrivateDataCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO), pNext(nullptr), privateDataSlotRequestCount() {}
+
+safe_VkDevicePrivateDataCreateInfo::safe_VkDevicePrivateDataCreateInfo(const safe_VkDevicePrivateDataCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    privateDataSlotRequestCount = copy_src.privateDataSlotRequestCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDevicePrivateDataCreateInfo& safe_VkDevicePrivateDataCreateInfo::operator=(
+    const safe_VkDevicePrivateDataCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    privateDataSlotRequestCount = copy_src.privateDataSlotRequestCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDevicePrivateDataCreateInfo::~safe_VkDevicePrivateDataCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkDevicePrivateDataCreateInfo::initialize(const VkDevicePrivateDataCreateInfo* in_struct,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    privateDataSlotRequestCount = in_struct->privateDataSlotRequestCount;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDevicePrivateDataCreateInfo::initialize(const safe_VkDevicePrivateDataCreateInfo* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    privateDataSlotRequestCount = copy_src->privateDataSlotRequestCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPrivateDataSlotCreateInfo::safe_VkPrivateDataSlotCreateInfo(const VkPrivateDataSlotCreateInfo* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPrivateDataSlotCreateInfo::safe_VkPrivateDataSlotCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO), pNext(nullptr), flags() {}
+
+safe_VkPrivateDataSlotCreateInfo::safe_VkPrivateDataSlotCreateInfo(const safe_VkPrivateDataSlotCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPrivateDataSlotCreateInfo& safe_VkPrivateDataSlotCreateInfo::operator=(const safe_VkPrivateDataSlotCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPrivateDataSlotCreateInfo::~safe_VkPrivateDataSlotCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkPrivateDataSlotCreateInfo::initialize(const VkPrivateDataSlotCreateInfo* in_struct,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPrivateDataSlotCreateInfo::initialize(const safe_VkPrivateDataSlotCreateInfo* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDevicePipelineCreationCacheControlFeatures::safe_VkPhysicalDevicePipelineCreationCacheControlFeatures(
+    const VkPhysicalDevicePipelineCreationCacheControlFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), pipelineCreationCacheControl(in_struct->pipelineCreationCacheControl) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePipelineCreationCacheControlFeatures::safe_VkPhysicalDevicePipelineCreationCacheControlFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES),
+      pNext(nullptr),
+      pipelineCreationCacheControl() {}
+
+safe_VkPhysicalDevicePipelineCreationCacheControlFeatures::safe_VkPhysicalDevicePipelineCreationCacheControlFeatures(
+    const safe_VkPhysicalDevicePipelineCreationCacheControlFeatures& copy_src) {
+    sType = copy_src.sType;
+    pipelineCreationCacheControl = copy_src.pipelineCreationCacheControl;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePipelineCreationCacheControlFeatures& safe_VkPhysicalDevicePipelineCreationCacheControlFeatures::operator=(
+    const safe_VkPhysicalDevicePipelineCreationCacheControlFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pipelineCreationCacheControl = copy_src.pipelineCreationCacheControl;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePipelineCreationCacheControlFeatures::~safe_VkPhysicalDevicePipelineCreationCacheControlFeatures() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDevicePipelineCreationCacheControlFeatures::initialize(
+    const VkPhysicalDevicePipelineCreationCacheControlFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pipelineCreationCacheControl = in_struct->pipelineCreationCacheControl;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePipelineCreationCacheControlFeatures::initialize(
+    const safe_VkPhysicalDevicePipelineCreationCacheControlFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pipelineCreationCacheControl = copy_src->pipelineCreationCacheControl;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkMemoryBarrier2::safe_VkMemoryBarrier2(const VkMemoryBarrier2* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                             bool copy_pnext)
+    : sType(in_struct->sType),
+      srcStageMask(in_struct->srcStageMask),
+      srcAccessMask(in_struct->srcAccessMask),
+      dstStageMask(in_struct->dstStageMask),
+      dstAccessMask(in_struct->dstAccessMask) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMemoryBarrier2::safe_VkMemoryBarrier2()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_BARRIER_2), pNext(nullptr), srcStageMask(), srcAccessMask(), dstStageMask(), dstAccessMask() {}
+
+safe_VkMemoryBarrier2::safe_VkMemoryBarrier2(const safe_VkMemoryBarrier2& copy_src) {
+    sType = copy_src.sType;
+    srcStageMask = copy_src.srcStageMask;
+    srcAccessMask = copy_src.srcAccessMask;
+    dstStageMask = copy_src.dstStageMask;
+    dstAccessMask = copy_src.dstAccessMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMemoryBarrier2& safe_VkMemoryBarrier2::operator=(const safe_VkMemoryBarrier2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    srcStageMask = copy_src.srcStageMask;
+    srcAccessMask = copy_src.srcAccessMask;
+    dstStageMask = copy_src.dstStageMask;
+    dstAccessMask = copy_src.dstAccessMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMemoryBarrier2::~safe_VkMemoryBarrier2() { FreePnextChain(pNext); }
+
+void safe_VkMemoryBarrier2::initialize(const VkMemoryBarrier2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    srcStageMask = in_struct->srcStageMask;
+    srcAccessMask = in_struct->srcAccessMask;
+    dstStageMask = in_struct->dstStageMask;
+    dstAccessMask = in_struct->dstAccessMask;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMemoryBarrier2::initialize(const safe_VkMemoryBarrier2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    srcStageMask = copy_src->srcStageMask;
+    srcAccessMask = copy_src->srcAccessMask;
+    dstStageMask = copy_src->dstStageMask;
+    dstAccessMask = copy_src->dstAccessMask;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkBufferMemoryBarrier2::safe_VkBufferMemoryBarrier2(const VkBufferMemoryBarrier2* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      srcStageMask(in_struct->srcStageMask),
+      srcAccessMask(in_struct->srcAccessMask),
+      dstStageMask(in_struct->dstStageMask),
+      dstAccessMask(in_struct->dstAccessMask),
+      srcQueueFamilyIndex(in_struct->srcQueueFamilyIndex),
+      dstQueueFamilyIndex(in_struct->dstQueueFamilyIndex),
+      buffer(in_struct->buffer),
+      offset(in_struct->offset),
+      size(in_struct->size) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkBufferMemoryBarrier2::safe_VkBufferMemoryBarrier2()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2),
+      pNext(nullptr),
+      srcStageMask(),
+      srcAccessMask(),
+      dstStageMask(),
+      dstAccessMask(),
+      srcQueueFamilyIndex(),
+      dstQueueFamilyIndex(),
+      buffer(),
+      offset(),
+      size() {}
+
+safe_VkBufferMemoryBarrier2::safe_VkBufferMemoryBarrier2(const safe_VkBufferMemoryBarrier2& copy_src) {
+    sType = copy_src.sType;
+    srcStageMask = copy_src.srcStageMask;
+    srcAccessMask = copy_src.srcAccessMask;
+    dstStageMask = copy_src.dstStageMask;
+    dstAccessMask = copy_src.dstAccessMask;
+    srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex;
+    dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex;
+    buffer = copy_src.buffer;
+    offset = copy_src.offset;
+    size = copy_src.size;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBufferMemoryBarrier2& safe_VkBufferMemoryBarrier2::operator=(const safe_VkBufferMemoryBarrier2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    srcStageMask = copy_src.srcStageMask;
+    srcAccessMask = copy_src.srcAccessMask;
+    dstStageMask = copy_src.dstStageMask;
+    dstAccessMask = copy_src.dstAccessMask;
+    srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex;
+    dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex;
+    buffer = copy_src.buffer;
+    offset = copy_src.offset;
+    size = copy_src.size;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkBufferMemoryBarrier2::~safe_VkBufferMemoryBarrier2() { FreePnextChain(pNext); }
+
+void safe_VkBufferMemoryBarrier2::initialize(const VkBufferMemoryBarrier2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    srcStageMask = in_struct->srcStageMask;
+    srcAccessMask = in_struct->srcAccessMask;
+    dstStageMask = in_struct->dstStageMask;
+    dstAccessMask = in_struct->dstAccessMask;
+    srcQueueFamilyIndex = in_struct->srcQueueFamilyIndex;
+    dstQueueFamilyIndex = in_struct->dstQueueFamilyIndex;
+    buffer = in_struct->buffer;
+    offset = in_struct->offset;
+    size = in_struct->size;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkBufferMemoryBarrier2::initialize(const safe_VkBufferMemoryBarrier2* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    srcStageMask = copy_src->srcStageMask;
+    srcAccessMask = copy_src->srcAccessMask;
+    dstStageMask = copy_src->dstStageMask;
+    dstAccessMask = copy_src->dstAccessMask;
+    srcQueueFamilyIndex = copy_src->srcQueueFamilyIndex;
+    dstQueueFamilyIndex = copy_src->dstQueueFamilyIndex;
+    buffer = copy_src->buffer;
+    offset = copy_src->offset;
+    size = copy_src->size;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkImageMemoryBarrier2::safe_VkImageMemoryBarrier2(const VkImageMemoryBarrier2* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      srcStageMask(in_struct->srcStageMask),
+      srcAccessMask(in_struct->srcAccessMask),
+      dstStageMask(in_struct->dstStageMask),
+      dstAccessMask(in_struct->dstAccessMask),
+      oldLayout(in_struct->oldLayout),
+      newLayout(in_struct->newLayout),
+      srcQueueFamilyIndex(in_struct->srcQueueFamilyIndex),
+      dstQueueFamilyIndex(in_struct->dstQueueFamilyIndex),
+      image(in_struct->image),
+      subresourceRange(in_struct->subresourceRange) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImageMemoryBarrier2::safe_VkImageMemoryBarrier2()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2),
+      pNext(nullptr),
+      srcStageMask(),
+      srcAccessMask(),
+      dstStageMask(),
+      dstAccessMask(),
+      oldLayout(),
+      newLayout(),
+      srcQueueFamilyIndex(),
+      dstQueueFamilyIndex(),
+      image(),
+      subresourceRange() {}
+
+safe_VkImageMemoryBarrier2::safe_VkImageMemoryBarrier2(const safe_VkImageMemoryBarrier2& copy_src) {
+    sType = copy_src.sType;
+    srcStageMask = copy_src.srcStageMask;
+    srcAccessMask = copy_src.srcAccessMask;
+    dstStageMask = copy_src.dstStageMask;
+    dstAccessMask = copy_src.dstAccessMask;
+    oldLayout = copy_src.oldLayout;
+    newLayout = copy_src.newLayout;
+    srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex;
+    dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex;
+    image = copy_src.image;
+    subresourceRange = copy_src.subresourceRange;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImageMemoryBarrier2& safe_VkImageMemoryBarrier2::operator=(const safe_VkImageMemoryBarrier2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    srcStageMask = copy_src.srcStageMask;
+    srcAccessMask = copy_src.srcAccessMask;
+    dstStageMask = copy_src.dstStageMask;
+    dstAccessMask = copy_src.dstAccessMask;
+    oldLayout = copy_src.oldLayout;
+    newLayout = copy_src.newLayout;
+    srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex;
+    dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex;
+    image = copy_src.image;
+    subresourceRange = copy_src.subresourceRange;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImageMemoryBarrier2::~safe_VkImageMemoryBarrier2() { FreePnextChain(pNext); }
+
+void safe_VkImageMemoryBarrier2::initialize(const VkImageMemoryBarrier2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    srcStageMask = in_struct->srcStageMask;
+    srcAccessMask = in_struct->srcAccessMask;
+    dstStageMask = in_struct->dstStageMask;
+    dstAccessMask = in_struct->dstAccessMask;
+    oldLayout = in_struct->oldLayout;
+    newLayout = in_struct->newLayout;
+    srcQueueFamilyIndex = in_struct->srcQueueFamilyIndex;
+    dstQueueFamilyIndex = in_struct->dstQueueFamilyIndex;
+    image = in_struct->image;
+    subresourceRange = in_struct->subresourceRange;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImageMemoryBarrier2::initialize(const safe_VkImageMemoryBarrier2* copy_src,
+                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    srcStageMask = copy_src->srcStageMask;
+    srcAccessMask = copy_src->srcAccessMask;
+    dstStageMask = copy_src->dstStageMask;
+    dstAccessMask = copy_src->dstAccessMask;
+    oldLayout = copy_src->oldLayout;
+    newLayout = copy_src->newLayout;
+    srcQueueFamilyIndex = copy_src->srcQueueFamilyIndex;
+    dstQueueFamilyIndex = copy_src->dstQueueFamilyIndex;
+    image = copy_src->image;
+    subresourceRange = copy_src->subresourceRange;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDependencyInfo::safe_VkDependencyInfo(const VkDependencyInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                             bool copy_pnext)
+    : sType(in_struct->sType),
+      dependencyFlags(in_struct->dependencyFlags),
+      memoryBarrierCount(in_struct->memoryBarrierCount),
+      pMemoryBarriers(nullptr),
+      bufferMemoryBarrierCount(in_struct->bufferMemoryBarrierCount),
+      pBufferMemoryBarriers(nullptr),
+      imageMemoryBarrierCount(in_struct->imageMemoryBarrierCount),
+      pImageMemoryBarriers(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (memoryBarrierCount && in_struct->pMemoryBarriers) {
+        pMemoryBarriers = new safe_VkMemoryBarrier2[memoryBarrierCount];
+        for (uint32_t i = 0; i < memoryBarrierCount; ++i) {
+            pMemoryBarriers[i].initialize(&in_struct->pMemoryBarriers[i]);
+        }
+    }
+    if (bufferMemoryBarrierCount && in_struct->pBufferMemoryBarriers) {
+        pBufferMemoryBarriers = new safe_VkBufferMemoryBarrier2[bufferMemoryBarrierCount];
+        for (uint32_t i = 0; i < bufferMemoryBarrierCount; ++i) {
+            pBufferMemoryBarriers[i].initialize(&in_struct->pBufferMemoryBarriers[i]);
+        }
+    }
+    if (imageMemoryBarrierCount && in_struct->pImageMemoryBarriers) {
+        pImageMemoryBarriers = new safe_VkImageMemoryBarrier2[imageMemoryBarrierCount];
+        for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) {
+            pImageMemoryBarriers[i].initialize(&in_struct->pImageMemoryBarriers[i]);
+        }
+    }
+}
+
+safe_VkDependencyInfo::safe_VkDependencyInfo()
+    : sType(VK_STRUCTURE_TYPE_DEPENDENCY_INFO),
+      pNext(nullptr),
+      dependencyFlags(),
+      memoryBarrierCount(),
+      pMemoryBarriers(nullptr),
+      bufferMemoryBarrierCount(),
+      pBufferMemoryBarriers(nullptr),
+      imageMemoryBarrierCount(),
+      pImageMemoryBarriers(nullptr) {}
+
+safe_VkDependencyInfo::safe_VkDependencyInfo(const safe_VkDependencyInfo& copy_src) {
+    sType = copy_src.sType;
+    dependencyFlags = copy_src.dependencyFlags;
+    memoryBarrierCount = copy_src.memoryBarrierCount;
+    pMemoryBarriers = nullptr;
+    bufferMemoryBarrierCount = copy_src.bufferMemoryBarrierCount;
+    pBufferMemoryBarriers = nullptr;
+    imageMemoryBarrierCount = copy_src.imageMemoryBarrierCount;
+    pImageMemoryBarriers = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (memoryBarrierCount && copy_src.pMemoryBarriers) {
+        pMemoryBarriers = new safe_VkMemoryBarrier2[memoryBarrierCount];
+        for (uint32_t i = 0; i < memoryBarrierCount; ++i) {
+            pMemoryBarriers[i].initialize(&copy_src.pMemoryBarriers[i]);
+        }
+    }
+    if (bufferMemoryBarrierCount && copy_src.pBufferMemoryBarriers) {
+        pBufferMemoryBarriers = new safe_VkBufferMemoryBarrier2[bufferMemoryBarrierCount];
+        for (uint32_t i = 0; i < bufferMemoryBarrierCount; ++i) {
+            pBufferMemoryBarriers[i].initialize(&copy_src.pBufferMemoryBarriers[i]);
+        }
+    }
+    if (imageMemoryBarrierCount && copy_src.pImageMemoryBarriers) {
+        pImageMemoryBarriers = new safe_VkImageMemoryBarrier2[imageMemoryBarrierCount];
+        for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) {
+            pImageMemoryBarriers[i].initialize(&copy_src.pImageMemoryBarriers[i]);
+        }
+    }
+}
+
+safe_VkDependencyInfo& safe_VkDependencyInfo::operator=(const safe_VkDependencyInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pMemoryBarriers) delete[] pMemoryBarriers;
+    if (pBufferMemoryBarriers) delete[] pBufferMemoryBarriers;
+    if (pImageMemoryBarriers) delete[] pImageMemoryBarriers;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    dependencyFlags = copy_src.dependencyFlags;
+    memoryBarrierCount = copy_src.memoryBarrierCount;
+    pMemoryBarriers = nullptr;
+    bufferMemoryBarrierCount = copy_src.bufferMemoryBarrierCount;
+    pBufferMemoryBarriers = nullptr;
+    imageMemoryBarrierCount = copy_src.imageMemoryBarrierCount;
+    pImageMemoryBarriers = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (memoryBarrierCount && copy_src.pMemoryBarriers) {
+        pMemoryBarriers = new safe_VkMemoryBarrier2[memoryBarrierCount];
+        for (uint32_t i = 0; i < memoryBarrierCount; ++i) {
+            pMemoryBarriers[i].initialize(&copy_src.pMemoryBarriers[i]);
+        }
+    }
+    if (bufferMemoryBarrierCount && copy_src.pBufferMemoryBarriers) {
+        pBufferMemoryBarriers = new safe_VkBufferMemoryBarrier2[bufferMemoryBarrierCount];
+        for (uint32_t i = 0; i < bufferMemoryBarrierCount; ++i) {
+            pBufferMemoryBarriers[i].initialize(&copy_src.pBufferMemoryBarriers[i]);
+        }
+    }
+    if (imageMemoryBarrierCount && copy_src.pImageMemoryBarriers) {
+        pImageMemoryBarriers = new safe_VkImageMemoryBarrier2[imageMemoryBarrierCount];
+        for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) {
+            pImageMemoryBarriers[i].initialize(&copy_src.pImageMemoryBarriers[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkDependencyInfo::~safe_VkDependencyInfo() {
+    if (pMemoryBarriers) delete[] pMemoryBarriers;
+    if (pBufferMemoryBarriers) delete[] pBufferMemoryBarriers;
+    if (pImageMemoryBarriers) delete[] pImageMemoryBarriers;
+    FreePnextChain(pNext);
+}
+
+void safe_VkDependencyInfo::initialize(const VkDependencyInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pMemoryBarriers) delete[] pMemoryBarriers;
+    if (pBufferMemoryBarriers) delete[] pBufferMemoryBarriers;
+    if (pImageMemoryBarriers) delete[] pImageMemoryBarriers;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    dependencyFlags = in_struct->dependencyFlags;
+    memoryBarrierCount = in_struct->memoryBarrierCount;
+    pMemoryBarriers = nullptr;
+    bufferMemoryBarrierCount = in_struct->bufferMemoryBarrierCount;
+    pBufferMemoryBarriers = nullptr;
+    imageMemoryBarrierCount = in_struct->imageMemoryBarrierCount;
+    pImageMemoryBarriers = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (memoryBarrierCount && in_struct->pMemoryBarriers) {
+        pMemoryBarriers = new safe_VkMemoryBarrier2[memoryBarrierCount];
+        for (uint32_t i = 0; i < memoryBarrierCount; ++i) {
+            pMemoryBarriers[i].initialize(&in_struct->pMemoryBarriers[i]);
+        }
+    }
+    if (bufferMemoryBarrierCount && in_struct->pBufferMemoryBarriers) {
+        pBufferMemoryBarriers = new safe_VkBufferMemoryBarrier2[bufferMemoryBarrierCount];
+        for (uint32_t i = 0; i < bufferMemoryBarrierCount; ++i) {
+            pBufferMemoryBarriers[i].initialize(&in_struct->pBufferMemoryBarriers[i]);
+        }
+    }
+    if (imageMemoryBarrierCount && in_struct->pImageMemoryBarriers) {
+        pImageMemoryBarriers = new safe_VkImageMemoryBarrier2[imageMemoryBarrierCount];
+        for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) {
+            pImageMemoryBarriers[i].initialize(&in_struct->pImageMemoryBarriers[i]);
+        }
+    }
+}
+
+void safe_VkDependencyInfo::initialize(const safe_VkDependencyInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    dependencyFlags = copy_src->dependencyFlags;
+    memoryBarrierCount = copy_src->memoryBarrierCount;
+    pMemoryBarriers = nullptr;
+    bufferMemoryBarrierCount = copy_src->bufferMemoryBarrierCount;
+    pBufferMemoryBarriers = nullptr;
+    imageMemoryBarrierCount = copy_src->imageMemoryBarrierCount;
+    pImageMemoryBarriers = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (memoryBarrierCount && copy_src->pMemoryBarriers) {
+        pMemoryBarriers = new safe_VkMemoryBarrier2[memoryBarrierCount];
+        for (uint32_t i = 0; i < memoryBarrierCount; ++i) {
+            pMemoryBarriers[i].initialize(&copy_src->pMemoryBarriers[i]);
+        }
+    }
+    if (bufferMemoryBarrierCount && copy_src->pBufferMemoryBarriers) {
+        pBufferMemoryBarriers = new safe_VkBufferMemoryBarrier2[bufferMemoryBarrierCount];
+        for (uint32_t i = 0; i < bufferMemoryBarrierCount; ++i) {
+            pBufferMemoryBarriers[i].initialize(&copy_src->pBufferMemoryBarriers[i]);
+        }
+    }
+    if (imageMemoryBarrierCount && copy_src->pImageMemoryBarriers) {
+        pImageMemoryBarriers = new safe_VkImageMemoryBarrier2[imageMemoryBarrierCount];
+        for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) {
+            pImageMemoryBarriers[i].initialize(&copy_src->pImageMemoryBarriers[i]);
+        }
+    }
+}
+
+safe_VkSemaphoreSubmitInfo::safe_VkSemaphoreSubmitInfo(const VkSemaphoreSubmitInfo* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      semaphore(in_struct->semaphore),
+      value(in_struct->value),
+      stageMask(in_struct->stageMask),
+      deviceIndex(in_struct->deviceIndex) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSemaphoreSubmitInfo::safe_VkSemaphoreSubmitInfo()
+    : sType(VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO), pNext(nullptr), semaphore(), value(), stageMask(), deviceIndex() {}
+
+safe_VkSemaphoreSubmitInfo::safe_VkSemaphoreSubmitInfo(const safe_VkSemaphoreSubmitInfo& copy_src) {
+    sType = copy_src.sType;
+    semaphore = copy_src.semaphore;
+    value = copy_src.value;
+    stageMask = copy_src.stageMask;
+    deviceIndex = copy_src.deviceIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSemaphoreSubmitInfo& safe_VkSemaphoreSubmitInfo::operator=(const safe_VkSemaphoreSubmitInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    semaphore = copy_src.semaphore;
+    value = copy_src.value;
+    stageMask = copy_src.stageMask;
+    deviceIndex = copy_src.deviceIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSemaphoreSubmitInfo::~safe_VkSemaphoreSubmitInfo() { FreePnextChain(pNext); }
+
+void safe_VkSemaphoreSubmitInfo::initialize(const VkSemaphoreSubmitInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    semaphore = in_struct->semaphore;
+    value = in_struct->value;
+    stageMask = in_struct->stageMask;
+    deviceIndex = in_struct->deviceIndex;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSemaphoreSubmitInfo::initialize(const safe_VkSemaphoreSubmitInfo* copy_src,
+                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    semaphore = copy_src->semaphore;
+    value = copy_src->value;
+    stageMask = copy_src->stageMask;
+    deviceIndex = copy_src->deviceIndex;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkCommandBufferSubmitInfo::safe_VkCommandBufferSubmitInfo(const VkCommandBufferSubmitInfo* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), commandBuffer(in_struct->commandBuffer), deviceMask(in_struct->deviceMask) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkCommandBufferSubmitInfo::safe_VkCommandBufferSubmitInfo()
+    : sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO), pNext(nullptr), commandBuffer(), deviceMask() {}
+
+safe_VkCommandBufferSubmitInfo::safe_VkCommandBufferSubmitInfo(const safe_VkCommandBufferSubmitInfo& copy_src) {
+    sType = copy_src.sType;
+    commandBuffer = copy_src.commandBuffer;
+    deviceMask = copy_src.deviceMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkCommandBufferSubmitInfo& safe_VkCommandBufferSubmitInfo::operator=(const safe_VkCommandBufferSubmitInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    commandBuffer = copy_src.commandBuffer;
+    deviceMask = copy_src.deviceMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkCommandBufferSubmitInfo::~safe_VkCommandBufferSubmitInfo() { FreePnextChain(pNext); }
+
+void safe_VkCommandBufferSubmitInfo::initialize(const VkCommandBufferSubmitInfo* in_struct,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    commandBuffer = in_struct->commandBuffer;
+    deviceMask = in_struct->deviceMask;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkCommandBufferSubmitInfo::initialize(const safe_VkCommandBufferSubmitInfo* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    commandBuffer = copy_src->commandBuffer;
+    deviceMask = copy_src->deviceMask;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSubmitInfo2::safe_VkSubmitInfo2(const VkSubmitInfo2* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      waitSemaphoreInfoCount(in_struct->waitSemaphoreInfoCount),
+      pWaitSemaphoreInfos(nullptr),
+      commandBufferInfoCount(in_struct->commandBufferInfoCount),
+      pCommandBufferInfos(nullptr),
+      signalSemaphoreInfoCount(in_struct->signalSemaphoreInfoCount),
+      pSignalSemaphoreInfos(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (waitSemaphoreInfoCount && in_struct->pWaitSemaphoreInfos) {
+        pWaitSemaphoreInfos = new safe_VkSemaphoreSubmitInfo[waitSemaphoreInfoCount];
+        for (uint32_t i = 0; i < waitSemaphoreInfoCount; ++i) {
+            pWaitSemaphoreInfos[i].initialize(&in_struct->pWaitSemaphoreInfos[i]);
+        }
+    }
+    if (commandBufferInfoCount && in_struct->pCommandBufferInfos) {
+        pCommandBufferInfos = new safe_VkCommandBufferSubmitInfo[commandBufferInfoCount];
+        for (uint32_t i = 0; i < commandBufferInfoCount; ++i) {
+            pCommandBufferInfos[i].initialize(&in_struct->pCommandBufferInfos[i]);
+        }
+    }
+    if (signalSemaphoreInfoCount && in_struct->pSignalSemaphoreInfos) {
+        pSignalSemaphoreInfos = new safe_VkSemaphoreSubmitInfo[signalSemaphoreInfoCount];
+        for (uint32_t i = 0; i < signalSemaphoreInfoCount; ++i) {
+            pSignalSemaphoreInfos[i].initialize(&in_struct->pSignalSemaphoreInfos[i]);
+        }
+    }
+}
+
+safe_VkSubmitInfo2::safe_VkSubmitInfo2()
+    : sType(VK_STRUCTURE_TYPE_SUBMIT_INFO_2),
+      pNext(nullptr),
+      flags(),
+      waitSemaphoreInfoCount(),
+      pWaitSemaphoreInfos(nullptr),
+      commandBufferInfoCount(),
+      pCommandBufferInfos(nullptr),
+      signalSemaphoreInfoCount(),
+      pSignalSemaphoreInfos(nullptr) {}
+
+safe_VkSubmitInfo2::safe_VkSubmitInfo2(const safe_VkSubmitInfo2& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    waitSemaphoreInfoCount = copy_src.waitSemaphoreInfoCount;
+    pWaitSemaphoreInfos = nullptr;
+    commandBufferInfoCount = copy_src.commandBufferInfoCount;
+    pCommandBufferInfos = nullptr;
+    signalSemaphoreInfoCount = copy_src.signalSemaphoreInfoCount;
+    pSignalSemaphoreInfos = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (waitSemaphoreInfoCount && copy_src.pWaitSemaphoreInfos) {
+        pWaitSemaphoreInfos = new safe_VkSemaphoreSubmitInfo[waitSemaphoreInfoCount];
+        for (uint32_t i = 0; i < waitSemaphoreInfoCount; ++i) {
+            pWaitSemaphoreInfos[i].initialize(&copy_src.pWaitSemaphoreInfos[i]);
+        }
+    }
+    if (commandBufferInfoCount && copy_src.pCommandBufferInfos) {
+        pCommandBufferInfos = new safe_VkCommandBufferSubmitInfo[commandBufferInfoCount];
+        for (uint32_t i = 0; i < commandBufferInfoCount; ++i) {
+            pCommandBufferInfos[i].initialize(&copy_src.pCommandBufferInfos[i]);
+        }
+    }
+    if (signalSemaphoreInfoCount && copy_src.pSignalSemaphoreInfos) {
+        pSignalSemaphoreInfos = new safe_VkSemaphoreSubmitInfo[signalSemaphoreInfoCount];
+        for (uint32_t i = 0; i < signalSemaphoreInfoCount; ++i) {
+            pSignalSemaphoreInfos[i].initialize(&copy_src.pSignalSemaphoreInfos[i]);
+        }
+    }
+}
+
+safe_VkSubmitInfo2& safe_VkSubmitInfo2::operator=(const safe_VkSubmitInfo2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pWaitSemaphoreInfos) delete[] pWaitSemaphoreInfos;
+    if (pCommandBufferInfos) delete[] pCommandBufferInfos;
+    if (pSignalSemaphoreInfos) delete[] pSignalSemaphoreInfos;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    waitSemaphoreInfoCount = copy_src.waitSemaphoreInfoCount;
+    pWaitSemaphoreInfos = nullptr;
+    commandBufferInfoCount = copy_src.commandBufferInfoCount;
+    pCommandBufferInfos = nullptr;
+    signalSemaphoreInfoCount = copy_src.signalSemaphoreInfoCount;
+    pSignalSemaphoreInfos = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (waitSemaphoreInfoCount && copy_src.pWaitSemaphoreInfos) {
+        pWaitSemaphoreInfos = new safe_VkSemaphoreSubmitInfo[waitSemaphoreInfoCount];
+        for (uint32_t i = 0; i < waitSemaphoreInfoCount; ++i) {
+            pWaitSemaphoreInfos[i].initialize(&copy_src.pWaitSemaphoreInfos[i]);
+        }
+    }
+    if (commandBufferInfoCount && copy_src.pCommandBufferInfos) {
+        pCommandBufferInfos = new safe_VkCommandBufferSubmitInfo[commandBufferInfoCount];
+        for (uint32_t i = 0; i < commandBufferInfoCount; ++i) {
+            pCommandBufferInfos[i].initialize(&copy_src.pCommandBufferInfos[i]);
+        }
+    }
+    if (signalSemaphoreInfoCount && copy_src.pSignalSemaphoreInfos) {
+        pSignalSemaphoreInfos = new safe_VkSemaphoreSubmitInfo[signalSemaphoreInfoCount];
+        for (uint32_t i = 0; i < signalSemaphoreInfoCount; ++i) {
+            pSignalSemaphoreInfos[i].initialize(&copy_src.pSignalSemaphoreInfos[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkSubmitInfo2::~safe_VkSubmitInfo2() {
+    if (pWaitSemaphoreInfos) delete[] pWaitSemaphoreInfos;
+    if (pCommandBufferInfos) delete[] pCommandBufferInfos;
+    if (pSignalSemaphoreInfos) delete[] pSignalSemaphoreInfos;
+    FreePnextChain(pNext);
+}
+
+void safe_VkSubmitInfo2::initialize(const VkSubmitInfo2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pWaitSemaphoreInfos) delete[] pWaitSemaphoreInfos;
+    if (pCommandBufferInfos) delete[] pCommandBufferInfos;
+    if (pSignalSemaphoreInfos) delete[] pSignalSemaphoreInfos;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    waitSemaphoreInfoCount = in_struct->waitSemaphoreInfoCount;
+    pWaitSemaphoreInfos = nullptr;
+    commandBufferInfoCount = in_struct->commandBufferInfoCount;
+    pCommandBufferInfos = nullptr;
+    signalSemaphoreInfoCount = in_struct->signalSemaphoreInfoCount;
+    pSignalSemaphoreInfos = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (waitSemaphoreInfoCount && in_struct->pWaitSemaphoreInfos) {
+        pWaitSemaphoreInfos = new safe_VkSemaphoreSubmitInfo[waitSemaphoreInfoCount];
+        for (uint32_t i = 0; i < waitSemaphoreInfoCount; ++i) {
+            pWaitSemaphoreInfos[i].initialize(&in_struct->pWaitSemaphoreInfos[i]);
+        }
+    }
+    if (commandBufferInfoCount && in_struct->pCommandBufferInfos) {
+        pCommandBufferInfos = new safe_VkCommandBufferSubmitInfo[commandBufferInfoCount];
+        for (uint32_t i = 0; i < commandBufferInfoCount; ++i) {
+            pCommandBufferInfos[i].initialize(&in_struct->pCommandBufferInfos[i]);
+        }
+    }
+    if (signalSemaphoreInfoCount && in_struct->pSignalSemaphoreInfos) {
+        pSignalSemaphoreInfos = new safe_VkSemaphoreSubmitInfo[signalSemaphoreInfoCount];
+        for (uint32_t i = 0; i < signalSemaphoreInfoCount; ++i) {
+            pSignalSemaphoreInfos[i].initialize(&in_struct->pSignalSemaphoreInfos[i]);
+        }
+    }
+}
+
+void safe_VkSubmitInfo2::initialize(const safe_VkSubmitInfo2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    waitSemaphoreInfoCount = copy_src->waitSemaphoreInfoCount;
+    pWaitSemaphoreInfos = nullptr;
+    commandBufferInfoCount = copy_src->commandBufferInfoCount;
+    pCommandBufferInfos = nullptr;
+    signalSemaphoreInfoCount = copy_src->signalSemaphoreInfoCount;
+    pSignalSemaphoreInfos = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (waitSemaphoreInfoCount && copy_src->pWaitSemaphoreInfos) {
+        pWaitSemaphoreInfos = new safe_VkSemaphoreSubmitInfo[waitSemaphoreInfoCount];
+        for (uint32_t i = 0; i < waitSemaphoreInfoCount; ++i) {
+            pWaitSemaphoreInfos[i].initialize(&copy_src->pWaitSemaphoreInfos[i]);
+        }
+    }
+    if (commandBufferInfoCount && copy_src->pCommandBufferInfos) {
+        pCommandBufferInfos = new safe_VkCommandBufferSubmitInfo[commandBufferInfoCount];
+        for (uint32_t i = 0; i < commandBufferInfoCount; ++i) {
+            pCommandBufferInfos[i].initialize(&copy_src->pCommandBufferInfos[i]);
+        }
+    }
+    if (signalSemaphoreInfoCount && copy_src->pSignalSemaphoreInfos) {
+        pSignalSemaphoreInfos = new safe_VkSemaphoreSubmitInfo[signalSemaphoreInfoCount];
+        for (uint32_t i = 0; i < signalSemaphoreInfoCount; ++i) {
+            pSignalSemaphoreInfos[i].initialize(&copy_src->pSignalSemaphoreInfos[i]);
+        }
+    }
+}
+
+safe_VkPhysicalDeviceSynchronization2Features::safe_VkPhysicalDeviceSynchronization2Features(
+    const VkPhysicalDeviceSynchronization2Features* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), synchronization2(in_struct->synchronization2) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceSynchronization2Features::safe_VkPhysicalDeviceSynchronization2Features()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES), pNext(nullptr), synchronization2() {}
+
+safe_VkPhysicalDeviceSynchronization2Features::safe_VkPhysicalDeviceSynchronization2Features(
+    const safe_VkPhysicalDeviceSynchronization2Features& copy_src) {
+    sType = copy_src.sType;
+    synchronization2 = copy_src.synchronization2;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceSynchronization2Features& safe_VkPhysicalDeviceSynchronization2Features::operator=(
+    const safe_VkPhysicalDeviceSynchronization2Features& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    synchronization2 = copy_src.synchronization2;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceSynchronization2Features::~safe_VkPhysicalDeviceSynchronization2Features() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceSynchronization2Features::initialize(const VkPhysicalDeviceSynchronization2Features* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    synchronization2 = in_struct->synchronization2;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceSynchronization2Features::initialize(const safe_VkPhysicalDeviceSynchronization2Features* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    synchronization2 = copy_src->synchronization2;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures::safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+    const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), shaderZeroInitializeWorkgroupMemory(in_struct->shaderZeroInitializeWorkgroupMemory) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures::safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES),
+      pNext(nullptr),
+      shaderZeroInitializeWorkgroupMemory() {}
+
+safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures::safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+    const safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures& copy_src) {
+    sType = copy_src.sType;
+    shaderZeroInitializeWorkgroupMemory = copy_src.shaderZeroInitializeWorkgroupMemory;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures& safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures::operator=(
+    const safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderZeroInitializeWorkgroupMemory = copy_src.shaderZeroInitializeWorkgroupMemory;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures::~safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures::initialize(
+    const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderZeroInitializeWorkgroupMemory = in_struct->shaderZeroInitializeWorkgroupMemory;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures::initialize(
+    const safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderZeroInitializeWorkgroupMemory = copy_src->shaderZeroInitializeWorkgroupMemory;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceImageRobustnessFeatures::safe_VkPhysicalDeviceImageRobustnessFeatures(
+    const VkPhysicalDeviceImageRobustnessFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), robustImageAccess(in_struct->robustImageAccess) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceImageRobustnessFeatures::safe_VkPhysicalDeviceImageRobustnessFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES), pNext(nullptr), robustImageAccess() {}
+
+safe_VkPhysicalDeviceImageRobustnessFeatures::safe_VkPhysicalDeviceImageRobustnessFeatures(
+    const safe_VkPhysicalDeviceImageRobustnessFeatures& copy_src) {
+    sType = copy_src.sType;
+    robustImageAccess = copy_src.robustImageAccess;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceImageRobustnessFeatures& safe_VkPhysicalDeviceImageRobustnessFeatures::operator=(
+    const safe_VkPhysicalDeviceImageRobustnessFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    robustImageAccess = copy_src.robustImageAccess;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceImageRobustnessFeatures::~safe_VkPhysicalDeviceImageRobustnessFeatures() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceImageRobustnessFeatures::initialize(const VkPhysicalDeviceImageRobustnessFeatures* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    robustImageAccess = in_struct->robustImageAccess;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceImageRobustnessFeatures::initialize(const safe_VkPhysicalDeviceImageRobustnessFeatures* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    robustImageAccess = copy_src->robustImageAccess;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkBufferCopy2::safe_VkBufferCopy2(const VkBufferCopy2* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), srcOffset(in_struct->srcOffset), dstOffset(in_struct->dstOffset), size(in_struct->size) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkBufferCopy2::safe_VkBufferCopy2()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_COPY_2), pNext(nullptr), srcOffset(), dstOffset(), size() {}
+
+safe_VkBufferCopy2::safe_VkBufferCopy2(const safe_VkBufferCopy2& copy_src) {
+    sType = copy_src.sType;
+    srcOffset = copy_src.srcOffset;
+    dstOffset = copy_src.dstOffset;
+    size = copy_src.size;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBufferCopy2& safe_VkBufferCopy2::operator=(const safe_VkBufferCopy2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    srcOffset = copy_src.srcOffset;
+    dstOffset = copy_src.dstOffset;
+    size = copy_src.size;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkBufferCopy2::~safe_VkBufferCopy2() { FreePnextChain(pNext); }
+
+void safe_VkBufferCopy2::initialize(const VkBufferCopy2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    srcOffset = in_struct->srcOffset;
+    dstOffset = in_struct->dstOffset;
+    size = in_struct->size;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkBufferCopy2::initialize(const safe_VkBufferCopy2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    srcOffset = copy_src->srcOffset;
+    dstOffset = copy_src->dstOffset;
+    size = copy_src->size;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkCopyBufferInfo2::safe_VkCopyBufferInfo2(const VkCopyBufferInfo2* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                               bool copy_pnext)
+    : sType(in_struct->sType),
+      srcBuffer(in_struct->srcBuffer),
+      dstBuffer(in_struct->dstBuffer),
+      regionCount(in_struct->regionCount),
+      pRegions(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (regionCount && in_struct->pRegions) {
+        pRegions = new safe_VkBufferCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+safe_VkCopyBufferInfo2::safe_VkCopyBufferInfo2()
+    : sType(VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2), pNext(nullptr), srcBuffer(), dstBuffer(), regionCount(), pRegions(nullptr) {}
+
+safe_VkCopyBufferInfo2::safe_VkCopyBufferInfo2(const safe_VkCopyBufferInfo2& copy_src) {
+    sType = copy_src.sType;
+    srcBuffer = copy_src.srcBuffer;
+    dstBuffer = copy_src.dstBuffer;
+    regionCount = copy_src.regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (regionCount && copy_src.pRegions) {
+        pRegions = new safe_VkBufferCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+}
+
+safe_VkCopyBufferInfo2& safe_VkCopyBufferInfo2::operator=(const safe_VkCopyBufferInfo2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    srcBuffer = copy_src.srcBuffer;
+    dstBuffer = copy_src.dstBuffer;
+    regionCount = copy_src.regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (regionCount && copy_src.pRegions) {
+        pRegions = new safe_VkBufferCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkCopyBufferInfo2::~safe_VkCopyBufferInfo2() {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+}
+
+void safe_VkCopyBufferInfo2::initialize(const VkCopyBufferInfo2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    srcBuffer = in_struct->srcBuffer;
+    dstBuffer = in_struct->dstBuffer;
+    regionCount = in_struct->regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (regionCount && in_struct->pRegions) {
+        pRegions = new safe_VkBufferCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+void safe_VkCopyBufferInfo2::initialize(const safe_VkCopyBufferInfo2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    srcBuffer = copy_src->srcBuffer;
+    dstBuffer = copy_src->dstBuffer;
+    regionCount = copy_src->regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (regionCount && copy_src->pRegions) {
+        pRegions = new safe_VkBufferCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src->pRegions[i]);
+        }
+    }
+}
+
+safe_VkImageCopy2::safe_VkImageCopy2(const VkImageCopy2* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      srcSubresource(in_struct->srcSubresource),
+      srcOffset(in_struct->srcOffset),
+      dstSubresource(in_struct->dstSubresource),
+      dstOffset(in_struct->dstOffset),
+      extent(in_struct->extent) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImageCopy2::safe_VkImageCopy2()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_COPY_2),
+      pNext(nullptr),
+      srcSubresource(),
+      srcOffset(),
+      dstSubresource(),
+      dstOffset(),
+      extent() {}
+
+safe_VkImageCopy2::safe_VkImageCopy2(const safe_VkImageCopy2& copy_src) {
+    sType = copy_src.sType;
+    srcSubresource = copy_src.srcSubresource;
+    srcOffset = copy_src.srcOffset;
+    dstSubresource = copy_src.dstSubresource;
+    dstOffset = copy_src.dstOffset;
+    extent = copy_src.extent;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImageCopy2& safe_VkImageCopy2::operator=(const safe_VkImageCopy2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    srcSubresource = copy_src.srcSubresource;
+    srcOffset = copy_src.srcOffset;
+    dstSubresource = copy_src.dstSubresource;
+    dstOffset = copy_src.dstOffset;
+    extent = copy_src.extent;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImageCopy2::~safe_VkImageCopy2() { FreePnextChain(pNext); }
+
+void safe_VkImageCopy2::initialize(const VkImageCopy2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    srcSubresource = in_struct->srcSubresource;
+    srcOffset = in_struct->srcOffset;
+    dstSubresource = in_struct->dstSubresource;
+    dstOffset = in_struct->dstOffset;
+    extent = in_struct->extent;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImageCopy2::initialize(const safe_VkImageCopy2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    srcSubresource = copy_src->srcSubresource;
+    srcOffset = copy_src->srcOffset;
+    dstSubresource = copy_src->dstSubresource;
+    dstOffset = copy_src->dstOffset;
+    extent = copy_src->extent;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkCopyImageInfo2::safe_VkCopyImageInfo2(const VkCopyImageInfo2* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                             bool copy_pnext)
+    : sType(in_struct->sType),
+      srcImage(in_struct->srcImage),
+      srcImageLayout(in_struct->srcImageLayout),
+      dstImage(in_struct->dstImage),
+      dstImageLayout(in_struct->dstImageLayout),
+      regionCount(in_struct->regionCount),
+      pRegions(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (regionCount && in_struct->pRegions) {
+        pRegions = new safe_VkImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+safe_VkCopyImageInfo2::safe_VkCopyImageInfo2()
+    : sType(VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2),
+      pNext(nullptr),
+      srcImage(),
+      srcImageLayout(),
+      dstImage(),
+      dstImageLayout(),
+      regionCount(),
+      pRegions(nullptr) {}
+
+safe_VkCopyImageInfo2::safe_VkCopyImageInfo2(const safe_VkCopyImageInfo2& copy_src) {
+    sType = copy_src.sType;
+    srcImage = copy_src.srcImage;
+    srcImageLayout = copy_src.srcImageLayout;
+    dstImage = copy_src.dstImage;
+    dstImageLayout = copy_src.dstImageLayout;
+    regionCount = copy_src.regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (regionCount && copy_src.pRegions) {
+        pRegions = new safe_VkImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+}
+
+safe_VkCopyImageInfo2& safe_VkCopyImageInfo2::operator=(const safe_VkCopyImageInfo2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    srcImage = copy_src.srcImage;
+    srcImageLayout = copy_src.srcImageLayout;
+    dstImage = copy_src.dstImage;
+    dstImageLayout = copy_src.dstImageLayout;
+    regionCount = copy_src.regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (regionCount && copy_src.pRegions) {
+        pRegions = new safe_VkImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkCopyImageInfo2::~safe_VkCopyImageInfo2() {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+}
+
+void safe_VkCopyImageInfo2::initialize(const VkCopyImageInfo2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    srcImage = in_struct->srcImage;
+    srcImageLayout = in_struct->srcImageLayout;
+    dstImage = in_struct->dstImage;
+    dstImageLayout = in_struct->dstImageLayout;
+    regionCount = in_struct->regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (regionCount && in_struct->pRegions) {
+        pRegions = new safe_VkImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+void safe_VkCopyImageInfo2::initialize(const safe_VkCopyImageInfo2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    srcImage = copy_src->srcImage;
+    srcImageLayout = copy_src->srcImageLayout;
+    dstImage = copy_src->dstImage;
+    dstImageLayout = copy_src->dstImageLayout;
+    regionCount = copy_src->regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (regionCount && copy_src->pRegions) {
+        pRegions = new safe_VkImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src->pRegions[i]);
+        }
+    }
+}
+
+safe_VkBufferImageCopy2::safe_VkBufferImageCopy2(const VkBufferImageCopy2* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                                 bool copy_pnext)
+    : sType(in_struct->sType),
+      bufferOffset(in_struct->bufferOffset),
+      bufferRowLength(in_struct->bufferRowLength),
+      bufferImageHeight(in_struct->bufferImageHeight),
+      imageSubresource(in_struct->imageSubresource),
+      imageOffset(in_struct->imageOffset),
+      imageExtent(in_struct->imageExtent) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkBufferImageCopy2::safe_VkBufferImageCopy2()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2),
+      pNext(nullptr),
+      bufferOffset(),
+      bufferRowLength(),
+      bufferImageHeight(),
+      imageSubresource(),
+      imageOffset(),
+      imageExtent() {}
+
+safe_VkBufferImageCopy2::safe_VkBufferImageCopy2(const safe_VkBufferImageCopy2& copy_src) {
+    sType = copy_src.sType;
+    bufferOffset = copy_src.bufferOffset;
+    bufferRowLength = copy_src.bufferRowLength;
+    bufferImageHeight = copy_src.bufferImageHeight;
+    imageSubresource = copy_src.imageSubresource;
+    imageOffset = copy_src.imageOffset;
+    imageExtent = copy_src.imageExtent;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBufferImageCopy2& safe_VkBufferImageCopy2::operator=(const safe_VkBufferImageCopy2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    bufferOffset = copy_src.bufferOffset;
+    bufferRowLength = copy_src.bufferRowLength;
+    bufferImageHeight = copy_src.bufferImageHeight;
+    imageSubresource = copy_src.imageSubresource;
+    imageOffset = copy_src.imageOffset;
+    imageExtent = copy_src.imageExtent;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkBufferImageCopy2::~safe_VkBufferImageCopy2() { FreePnextChain(pNext); }
+
+void safe_VkBufferImageCopy2::initialize(const VkBufferImageCopy2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    bufferOffset = in_struct->bufferOffset;
+    bufferRowLength = in_struct->bufferRowLength;
+    bufferImageHeight = in_struct->bufferImageHeight;
+    imageSubresource = in_struct->imageSubresource;
+    imageOffset = in_struct->imageOffset;
+    imageExtent = in_struct->imageExtent;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkBufferImageCopy2::initialize(const safe_VkBufferImageCopy2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    bufferOffset = copy_src->bufferOffset;
+    bufferRowLength = copy_src->bufferRowLength;
+    bufferImageHeight = copy_src->bufferImageHeight;
+    imageSubresource = copy_src->imageSubresource;
+    imageOffset = copy_src->imageOffset;
+    imageExtent = copy_src->imageExtent;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkCopyBufferToImageInfo2::safe_VkCopyBufferToImageInfo2(const VkCopyBufferToImageInfo2* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      srcBuffer(in_struct->srcBuffer),
+      dstImage(in_struct->dstImage),
+      dstImageLayout(in_struct->dstImageLayout),
+      regionCount(in_struct->regionCount),
+      pRegions(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (regionCount && in_struct->pRegions) {
+        pRegions = new safe_VkBufferImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+safe_VkCopyBufferToImageInfo2::safe_VkCopyBufferToImageInfo2()
+    : sType(VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2),
+      pNext(nullptr),
+      srcBuffer(),
+      dstImage(),
+      dstImageLayout(),
+      regionCount(),
+      pRegions(nullptr) {}
+
+safe_VkCopyBufferToImageInfo2::safe_VkCopyBufferToImageInfo2(const safe_VkCopyBufferToImageInfo2& copy_src) {
+    sType = copy_src.sType;
+    srcBuffer = copy_src.srcBuffer;
+    dstImage = copy_src.dstImage;
+    dstImageLayout = copy_src.dstImageLayout;
+    regionCount = copy_src.regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (regionCount && copy_src.pRegions) {
+        pRegions = new safe_VkBufferImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+}
+
+safe_VkCopyBufferToImageInfo2& safe_VkCopyBufferToImageInfo2::operator=(const safe_VkCopyBufferToImageInfo2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    srcBuffer = copy_src.srcBuffer;
+    dstImage = copy_src.dstImage;
+    dstImageLayout = copy_src.dstImageLayout;
+    regionCount = copy_src.regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (regionCount && copy_src.pRegions) {
+        pRegions = new safe_VkBufferImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkCopyBufferToImageInfo2::~safe_VkCopyBufferToImageInfo2() {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+}
+
+void safe_VkCopyBufferToImageInfo2::initialize(const VkCopyBufferToImageInfo2* in_struct,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    srcBuffer = in_struct->srcBuffer;
+    dstImage = in_struct->dstImage;
+    dstImageLayout = in_struct->dstImageLayout;
+    regionCount = in_struct->regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (regionCount && in_struct->pRegions) {
+        pRegions = new safe_VkBufferImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+void safe_VkCopyBufferToImageInfo2::initialize(const safe_VkCopyBufferToImageInfo2* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    srcBuffer = copy_src->srcBuffer;
+    dstImage = copy_src->dstImage;
+    dstImageLayout = copy_src->dstImageLayout;
+    regionCount = copy_src->regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (regionCount && copy_src->pRegions) {
+        pRegions = new safe_VkBufferImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src->pRegions[i]);
+        }
+    }
+}
+
+safe_VkCopyImageToBufferInfo2::safe_VkCopyImageToBufferInfo2(const VkCopyImageToBufferInfo2* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      srcImage(in_struct->srcImage),
+      srcImageLayout(in_struct->srcImageLayout),
+      dstBuffer(in_struct->dstBuffer),
+      regionCount(in_struct->regionCount),
+      pRegions(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (regionCount && in_struct->pRegions) {
+        pRegions = new safe_VkBufferImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+safe_VkCopyImageToBufferInfo2::safe_VkCopyImageToBufferInfo2()
+    : sType(VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2),
+      pNext(nullptr),
+      srcImage(),
+      srcImageLayout(),
+      dstBuffer(),
+      regionCount(),
+      pRegions(nullptr) {}
+
+safe_VkCopyImageToBufferInfo2::safe_VkCopyImageToBufferInfo2(const safe_VkCopyImageToBufferInfo2& copy_src) {
+    sType = copy_src.sType;
+    srcImage = copy_src.srcImage;
+    srcImageLayout = copy_src.srcImageLayout;
+    dstBuffer = copy_src.dstBuffer;
+    regionCount = copy_src.regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (regionCount && copy_src.pRegions) {
+        pRegions = new safe_VkBufferImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+}
+
+safe_VkCopyImageToBufferInfo2& safe_VkCopyImageToBufferInfo2::operator=(const safe_VkCopyImageToBufferInfo2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    srcImage = copy_src.srcImage;
+    srcImageLayout = copy_src.srcImageLayout;
+    dstBuffer = copy_src.dstBuffer;
+    regionCount = copy_src.regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (regionCount && copy_src.pRegions) {
+        pRegions = new safe_VkBufferImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkCopyImageToBufferInfo2::~safe_VkCopyImageToBufferInfo2() {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+}
+
+void safe_VkCopyImageToBufferInfo2::initialize(const VkCopyImageToBufferInfo2* in_struct,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    srcImage = in_struct->srcImage;
+    srcImageLayout = in_struct->srcImageLayout;
+    dstBuffer = in_struct->dstBuffer;
+    regionCount = in_struct->regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (regionCount && in_struct->pRegions) {
+        pRegions = new safe_VkBufferImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+void safe_VkCopyImageToBufferInfo2::initialize(const safe_VkCopyImageToBufferInfo2* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    srcImage = copy_src->srcImage;
+    srcImageLayout = copy_src->srcImageLayout;
+    dstBuffer = copy_src->dstBuffer;
+    regionCount = copy_src->regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (regionCount && copy_src->pRegions) {
+        pRegions = new safe_VkBufferImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src->pRegions[i]);
+        }
+    }
+}
+
+safe_VkImageBlit2::safe_VkImageBlit2(const VkImageBlit2* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), srcSubresource(in_struct->srcSubresource), dstSubresource(in_struct->dstSubresource) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    for (uint32_t i = 0; i < 2; ++i) {
+        srcOffsets[i] = in_struct->srcOffsets[i];
+    }
+
+    for (uint32_t i = 0; i < 2; ++i) {
+        dstOffsets[i] = in_struct->dstOffsets[i];
+    }
+}
+
+safe_VkImageBlit2::safe_VkImageBlit2()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_BLIT_2), pNext(nullptr), srcSubresource(), dstSubresource() {}
+
+safe_VkImageBlit2::safe_VkImageBlit2(const safe_VkImageBlit2& copy_src) {
+    sType = copy_src.sType;
+    srcSubresource = copy_src.srcSubresource;
+    dstSubresource = copy_src.dstSubresource;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < 2; ++i) {
+        srcOffsets[i] = copy_src.srcOffsets[i];
+    }
+
+    for (uint32_t i = 0; i < 2; ++i) {
+        dstOffsets[i] = copy_src.dstOffsets[i];
+    }
+}
+
+safe_VkImageBlit2& safe_VkImageBlit2::operator=(const safe_VkImageBlit2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    srcSubresource = copy_src.srcSubresource;
+    dstSubresource = copy_src.dstSubresource;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < 2; ++i) {
+        srcOffsets[i] = copy_src.srcOffsets[i];
+    }
+
+    for (uint32_t i = 0; i < 2; ++i) {
+        dstOffsets[i] = copy_src.dstOffsets[i];
+    }
+
+    return *this;
+}
+
+safe_VkImageBlit2::~safe_VkImageBlit2() { FreePnextChain(pNext); }
+
+void safe_VkImageBlit2::initialize(const VkImageBlit2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    srcSubresource = in_struct->srcSubresource;
+    dstSubresource = in_struct->dstSubresource;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    for (uint32_t i = 0; i < 2; ++i) {
+        srcOffsets[i] = in_struct->srcOffsets[i];
+    }
+
+    for (uint32_t i = 0; i < 2; ++i) {
+        dstOffsets[i] = in_struct->dstOffsets[i];
+    }
+}
+
+void safe_VkImageBlit2::initialize(const safe_VkImageBlit2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    srcSubresource = copy_src->srcSubresource;
+    dstSubresource = copy_src->dstSubresource;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    for (uint32_t i = 0; i < 2; ++i) {
+        srcOffsets[i] = copy_src->srcOffsets[i];
+    }
+
+    for (uint32_t i = 0; i < 2; ++i) {
+        dstOffsets[i] = copy_src->dstOffsets[i];
+    }
+}
+
+safe_VkBlitImageInfo2::safe_VkBlitImageInfo2(const VkBlitImageInfo2* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                             bool copy_pnext)
+    : sType(in_struct->sType),
+      srcImage(in_struct->srcImage),
+      srcImageLayout(in_struct->srcImageLayout),
+      dstImage(in_struct->dstImage),
+      dstImageLayout(in_struct->dstImageLayout),
+      regionCount(in_struct->regionCount),
+      pRegions(nullptr),
+      filter(in_struct->filter) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (regionCount && in_struct->pRegions) {
+        pRegions = new safe_VkImageBlit2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+safe_VkBlitImageInfo2::safe_VkBlitImageInfo2()
+    : sType(VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2),
+      pNext(nullptr),
+      srcImage(),
+      srcImageLayout(),
+      dstImage(),
+      dstImageLayout(),
+      regionCount(),
+      pRegions(nullptr),
+      filter() {}
+
+safe_VkBlitImageInfo2::safe_VkBlitImageInfo2(const safe_VkBlitImageInfo2& copy_src) {
+    sType = copy_src.sType;
+    srcImage = copy_src.srcImage;
+    srcImageLayout = copy_src.srcImageLayout;
+    dstImage = copy_src.dstImage;
+    dstImageLayout = copy_src.dstImageLayout;
+    regionCount = copy_src.regionCount;
+    pRegions = nullptr;
+    filter = copy_src.filter;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (regionCount && copy_src.pRegions) {
+        pRegions = new safe_VkImageBlit2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+}
+
+safe_VkBlitImageInfo2& safe_VkBlitImageInfo2::operator=(const safe_VkBlitImageInfo2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    srcImage = copy_src.srcImage;
+    srcImageLayout = copy_src.srcImageLayout;
+    dstImage = copy_src.dstImage;
+    dstImageLayout = copy_src.dstImageLayout;
+    regionCount = copy_src.regionCount;
+    pRegions = nullptr;
+    filter = copy_src.filter;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (regionCount && copy_src.pRegions) {
+        pRegions = new safe_VkImageBlit2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkBlitImageInfo2::~safe_VkBlitImageInfo2() {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+}
+
+void safe_VkBlitImageInfo2::initialize(const VkBlitImageInfo2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    srcImage = in_struct->srcImage;
+    srcImageLayout = in_struct->srcImageLayout;
+    dstImage = in_struct->dstImage;
+    dstImageLayout = in_struct->dstImageLayout;
+    regionCount = in_struct->regionCount;
+    pRegions = nullptr;
+    filter = in_struct->filter;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (regionCount && in_struct->pRegions) {
+        pRegions = new safe_VkImageBlit2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+void safe_VkBlitImageInfo2::initialize(const safe_VkBlitImageInfo2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    srcImage = copy_src->srcImage;
+    srcImageLayout = copy_src->srcImageLayout;
+    dstImage = copy_src->dstImage;
+    dstImageLayout = copy_src->dstImageLayout;
+    regionCount = copy_src->regionCount;
+    pRegions = nullptr;
+    filter = copy_src->filter;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (regionCount && copy_src->pRegions) {
+        pRegions = new safe_VkImageBlit2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src->pRegions[i]);
+        }
+    }
+}
+
+safe_VkImageResolve2::safe_VkImageResolve2(const VkImageResolve2* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                           bool copy_pnext)
+    : sType(in_struct->sType),
+      srcSubresource(in_struct->srcSubresource),
+      srcOffset(in_struct->srcOffset),
+      dstSubresource(in_struct->dstSubresource),
+      dstOffset(in_struct->dstOffset),
+      extent(in_struct->extent) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImageResolve2::safe_VkImageResolve2()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2),
+      pNext(nullptr),
+      srcSubresource(),
+      srcOffset(),
+      dstSubresource(),
+      dstOffset(),
+      extent() {}
+
+safe_VkImageResolve2::safe_VkImageResolve2(const safe_VkImageResolve2& copy_src) {
+    sType = copy_src.sType;
+    srcSubresource = copy_src.srcSubresource;
+    srcOffset = copy_src.srcOffset;
+    dstSubresource = copy_src.dstSubresource;
+    dstOffset = copy_src.dstOffset;
+    extent = copy_src.extent;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImageResolve2& safe_VkImageResolve2::operator=(const safe_VkImageResolve2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    srcSubresource = copy_src.srcSubresource;
+    srcOffset = copy_src.srcOffset;
+    dstSubresource = copy_src.dstSubresource;
+    dstOffset = copy_src.dstOffset;
+    extent = copy_src.extent;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImageResolve2::~safe_VkImageResolve2() { FreePnextChain(pNext); }
+
+void safe_VkImageResolve2::initialize(const VkImageResolve2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    srcSubresource = in_struct->srcSubresource;
+    srcOffset = in_struct->srcOffset;
+    dstSubresource = in_struct->dstSubresource;
+    dstOffset = in_struct->dstOffset;
+    extent = in_struct->extent;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImageResolve2::initialize(const safe_VkImageResolve2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    srcSubresource = copy_src->srcSubresource;
+    srcOffset = copy_src->srcOffset;
+    dstSubresource = copy_src->dstSubresource;
+    dstOffset = copy_src->dstOffset;
+    extent = copy_src->extent;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkResolveImageInfo2::safe_VkResolveImageInfo2(const VkResolveImageInfo2* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      srcImage(in_struct->srcImage),
+      srcImageLayout(in_struct->srcImageLayout),
+      dstImage(in_struct->dstImage),
+      dstImageLayout(in_struct->dstImageLayout),
+      regionCount(in_struct->regionCount),
+      pRegions(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (regionCount && in_struct->pRegions) {
+        pRegions = new safe_VkImageResolve2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+safe_VkResolveImageInfo2::safe_VkResolveImageInfo2()
+    : sType(VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2),
+      pNext(nullptr),
+      srcImage(),
+      srcImageLayout(),
+      dstImage(),
+      dstImageLayout(),
+      regionCount(),
+      pRegions(nullptr) {}
+
+safe_VkResolveImageInfo2::safe_VkResolveImageInfo2(const safe_VkResolveImageInfo2& copy_src) {
+    sType = copy_src.sType;
+    srcImage = copy_src.srcImage;
+    srcImageLayout = copy_src.srcImageLayout;
+    dstImage = copy_src.dstImage;
+    dstImageLayout = copy_src.dstImageLayout;
+    regionCount = copy_src.regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (regionCount && copy_src.pRegions) {
+        pRegions = new safe_VkImageResolve2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+}
+
+safe_VkResolveImageInfo2& safe_VkResolveImageInfo2::operator=(const safe_VkResolveImageInfo2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    srcImage = copy_src.srcImage;
+    srcImageLayout = copy_src.srcImageLayout;
+    dstImage = copy_src.dstImage;
+    dstImageLayout = copy_src.dstImageLayout;
+    regionCount = copy_src.regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (regionCount && copy_src.pRegions) {
+        pRegions = new safe_VkImageResolve2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkResolveImageInfo2::~safe_VkResolveImageInfo2() {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+}
+
+void safe_VkResolveImageInfo2::initialize(const VkResolveImageInfo2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    srcImage = in_struct->srcImage;
+    srcImageLayout = in_struct->srcImageLayout;
+    dstImage = in_struct->dstImage;
+    dstImageLayout = in_struct->dstImageLayout;
+    regionCount = in_struct->regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (regionCount && in_struct->pRegions) {
+        pRegions = new safe_VkImageResolve2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+void safe_VkResolveImageInfo2::initialize(const safe_VkResolveImageInfo2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    srcImage = copy_src->srcImage;
+    srcImageLayout = copy_src->srcImageLayout;
+    dstImage = copy_src->dstImage;
+    dstImageLayout = copy_src->dstImageLayout;
+    regionCount = copy_src->regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (regionCount && copy_src->pRegions) {
+        pRegions = new safe_VkImageResolve2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src->pRegions[i]);
+        }
+    }
+}
+
+safe_VkPhysicalDeviceSubgroupSizeControlFeatures::safe_VkPhysicalDeviceSubgroupSizeControlFeatures(
+    const VkPhysicalDeviceSubgroupSizeControlFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      subgroupSizeControl(in_struct->subgroupSizeControl),
+      computeFullSubgroups(in_struct->computeFullSubgroups) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceSubgroupSizeControlFeatures::safe_VkPhysicalDeviceSubgroupSizeControlFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES),
+      pNext(nullptr),
+      subgroupSizeControl(),
+      computeFullSubgroups() {}
+
+safe_VkPhysicalDeviceSubgroupSizeControlFeatures::safe_VkPhysicalDeviceSubgroupSizeControlFeatures(
+    const safe_VkPhysicalDeviceSubgroupSizeControlFeatures& copy_src) {
+    sType = copy_src.sType;
+    subgroupSizeControl = copy_src.subgroupSizeControl;
+    computeFullSubgroups = copy_src.computeFullSubgroups;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceSubgroupSizeControlFeatures& safe_VkPhysicalDeviceSubgroupSizeControlFeatures::operator=(
+    const safe_VkPhysicalDeviceSubgroupSizeControlFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    subgroupSizeControl = copy_src.subgroupSizeControl;
+    computeFullSubgroups = copy_src.computeFullSubgroups;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceSubgroupSizeControlFeatures::~safe_VkPhysicalDeviceSubgroupSizeControlFeatures() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceSubgroupSizeControlFeatures::initialize(const VkPhysicalDeviceSubgroupSizeControlFeatures* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    subgroupSizeControl = in_struct->subgroupSizeControl;
+    computeFullSubgroups = in_struct->computeFullSubgroups;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceSubgroupSizeControlFeatures::initialize(const safe_VkPhysicalDeviceSubgroupSizeControlFeatures* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    subgroupSizeControl = copy_src->subgroupSizeControl;
+    computeFullSubgroups = copy_src->computeFullSubgroups;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceSubgroupSizeControlProperties::safe_VkPhysicalDeviceSubgroupSizeControlProperties(
+    const VkPhysicalDeviceSubgroupSizeControlProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      minSubgroupSize(in_struct->minSubgroupSize),
+      maxSubgroupSize(in_struct->maxSubgroupSize),
+      maxComputeWorkgroupSubgroups(in_struct->maxComputeWorkgroupSubgroups),
+      requiredSubgroupSizeStages(in_struct->requiredSubgroupSizeStages) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceSubgroupSizeControlProperties::safe_VkPhysicalDeviceSubgroupSizeControlProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES),
+      pNext(nullptr),
+      minSubgroupSize(),
+      maxSubgroupSize(),
+      maxComputeWorkgroupSubgroups(),
+      requiredSubgroupSizeStages() {}
+
+safe_VkPhysicalDeviceSubgroupSizeControlProperties::safe_VkPhysicalDeviceSubgroupSizeControlProperties(
+    const safe_VkPhysicalDeviceSubgroupSizeControlProperties& copy_src) {
+    sType = copy_src.sType;
+    minSubgroupSize = copy_src.minSubgroupSize;
+    maxSubgroupSize = copy_src.maxSubgroupSize;
+    maxComputeWorkgroupSubgroups = copy_src.maxComputeWorkgroupSubgroups;
+    requiredSubgroupSizeStages = copy_src.requiredSubgroupSizeStages;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceSubgroupSizeControlProperties& safe_VkPhysicalDeviceSubgroupSizeControlProperties::operator=(
+    const safe_VkPhysicalDeviceSubgroupSizeControlProperties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    minSubgroupSize = copy_src.minSubgroupSize;
+    maxSubgroupSize = copy_src.maxSubgroupSize;
+    maxComputeWorkgroupSubgroups = copy_src.maxComputeWorkgroupSubgroups;
+    requiredSubgroupSizeStages = copy_src.requiredSubgroupSizeStages;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceSubgroupSizeControlProperties::~safe_VkPhysicalDeviceSubgroupSizeControlProperties() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceSubgroupSizeControlProperties::initialize(const VkPhysicalDeviceSubgroupSizeControlProperties* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    minSubgroupSize = in_struct->minSubgroupSize;
+    maxSubgroupSize = in_struct->maxSubgroupSize;
+    maxComputeWorkgroupSubgroups = in_struct->maxComputeWorkgroupSubgroups;
+    requiredSubgroupSizeStages = in_struct->requiredSubgroupSizeStages;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceSubgroupSizeControlProperties::initialize(
+    const safe_VkPhysicalDeviceSubgroupSizeControlProperties* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    minSubgroupSize = copy_src->minSubgroupSize;
+    maxSubgroupSize = copy_src->maxSubgroupSize;
+    maxComputeWorkgroupSubgroups = copy_src->maxComputeWorkgroupSubgroups;
+    requiredSubgroupSizeStages = copy_src->requiredSubgroupSizeStages;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo::safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
+    const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), requiredSubgroupSize(in_struct->requiredSubgroupSize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo::safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO), pNext(nullptr), requiredSubgroupSize() {}
+
+safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo::safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
+    const safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    requiredSubgroupSize = copy_src.requiredSubgroupSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo& safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo::operator=(
+    const safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    requiredSubgroupSize = copy_src.requiredSubgroupSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo::~safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo::initialize(
+    const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    requiredSubgroupSize = in_struct->requiredSubgroupSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo::initialize(
+    const safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    requiredSubgroupSize = copy_src->requiredSubgroupSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceInlineUniformBlockFeatures::safe_VkPhysicalDeviceInlineUniformBlockFeatures(
+    const VkPhysicalDeviceInlineUniformBlockFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      inlineUniformBlock(in_struct->inlineUniformBlock),
+      descriptorBindingInlineUniformBlockUpdateAfterBind(in_struct->descriptorBindingInlineUniformBlockUpdateAfterBind) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceInlineUniformBlockFeatures::safe_VkPhysicalDeviceInlineUniformBlockFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES),
+      pNext(nullptr),
+      inlineUniformBlock(),
+      descriptorBindingInlineUniformBlockUpdateAfterBind() {}
+
+safe_VkPhysicalDeviceInlineUniformBlockFeatures::safe_VkPhysicalDeviceInlineUniformBlockFeatures(
+    const safe_VkPhysicalDeviceInlineUniformBlockFeatures& copy_src) {
+    sType = copy_src.sType;
+    inlineUniformBlock = copy_src.inlineUniformBlock;
+    descriptorBindingInlineUniformBlockUpdateAfterBind = copy_src.descriptorBindingInlineUniformBlockUpdateAfterBind;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceInlineUniformBlockFeatures& safe_VkPhysicalDeviceInlineUniformBlockFeatures::operator=(
+    const safe_VkPhysicalDeviceInlineUniformBlockFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    inlineUniformBlock = copy_src.inlineUniformBlock;
+    descriptorBindingInlineUniformBlockUpdateAfterBind = copy_src.descriptorBindingInlineUniformBlockUpdateAfterBind;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceInlineUniformBlockFeatures::~safe_VkPhysicalDeviceInlineUniformBlockFeatures() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceInlineUniformBlockFeatures::initialize(const VkPhysicalDeviceInlineUniformBlockFeatures* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    inlineUniformBlock = in_struct->inlineUniformBlock;
+    descriptorBindingInlineUniformBlockUpdateAfterBind = in_struct->descriptorBindingInlineUniformBlockUpdateAfterBind;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceInlineUniformBlockFeatures::initialize(const safe_VkPhysicalDeviceInlineUniformBlockFeatures* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    inlineUniformBlock = copy_src->inlineUniformBlock;
+    descriptorBindingInlineUniformBlockUpdateAfterBind = copy_src->descriptorBindingInlineUniformBlockUpdateAfterBind;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceInlineUniformBlockProperties::safe_VkPhysicalDeviceInlineUniformBlockProperties(
+    const VkPhysicalDeviceInlineUniformBlockProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      maxInlineUniformBlockSize(in_struct->maxInlineUniformBlockSize),
+      maxPerStageDescriptorInlineUniformBlocks(in_struct->maxPerStageDescriptorInlineUniformBlocks),
+      maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks(in_struct->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks),
+      maxDescriptorSetInlineUniformBlocks(in_struct->maxDescriptorSetInlineUniformBlocks),
+      maxDescriptorSetUpdateAfterBindInlineUniformBlocks(in_struct->maxDescriptorSetUpdateAfterBindInlineUniformBlocks) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceInlineUniformBlockProperties::safe_VkPhysicalDeviceInlineUniformBlockProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES),
+      pNext(nullptr),
+      maxInlineUniformBlockSize(),
+      maxPerStageDescriptorInlineUniformBlocks(),
+      maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks(),
+      maxDescriptorSetInlineUniformBlocks(),
+      maxDescriptorSetUpdateAfterBindInlineUniformBlocks() {}
+
+safe_VkPhysicalDeviceInlineUniformBlockProperties::safe_VkPhysicalDeviceInlineUniformBlockProperties(
+    const safe_VkPhysicalDeviceInlineUniformBlockProperties& copy_src) {
+    sType = copy_src.sType;
+    maxInlineUniformBlockSize = copy_src.maxInlineUniformBlockSize;
+    maxPerStageDescriptorInlineUniformBlocks = copy_src.maxPerStageDescriptorInlineUniformBlocks;
+    maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = copy_src.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
+    maxDescriptorSetInlineUniformBlocks = copy_src.maxDescriptorSetInlineUniformBlocks;
+    maxDescriptorSetUpdateAfterBindInlineUniformBlocks = copy_src.maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceInlineUniformBlockProperties& safe_VkPhysicalDeviceInlineUniformBlockProperties::operator=(
+    const safe_VkPhysicalDeviceInlineUniformBlockProperties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxInlineUniformBlockSize = copy_src.maxInlineUniformBlockSize;
+    maxPerStageDescriptorInlineUniformBlocks = copy_src.maxPerStageDescriptorInlineUniformBlocks;
+    maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = copy_src.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
+    maxDescriptorSetInlineUniformBlocks = copy_src.maxDescriptorSetInlineUniformBlocks;
+    maxDescriptorSetUpdateAfterBindInlineUniformBlocks = copy_src.maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceInlineUniformBlockProperties::~safe_VkPhysicalDeviceInlineUniformBlockProperties() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceInlineUniformBlockProperties::initialize(const VkPhysicalDeviceInlineUniformBlockProperties* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxInlineUniformBlockSize = in_struct->maxInlineUniformBlockSize;
+    maxPerStageDescriptorInlineUniformBlocks = in_struct->maxPerStageDescriptorInlineUniformBlocks;
+    maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = in_struct->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
+    maxDescriptorSetInlineUniformBlocks = in_struct->maxDescriptorSetInlineUniformBlocks;
+    maxDescriptorSetUpdateAfterBindInlineUniformBlocks = in_struct->maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceInlineUniformBlockProperties::initialize(
+    const safe_VkPhysicalDeviceInlineUniformBlockProperties* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxInlineUniformBlockSize = copy_src->maxInlineUniformBlockSize;
+    maxPerStageDescriptorInlineUniformBlocks = copy_src->maxPerStageDescriptorInlineUniformBlocks;
+    maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = copy_src->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
+    maxDescriptorSetInlineUniformBlocks = copy_src->maxDescriptorSetInlineUniformBlocks;
+    maxDescriptorSetUpdateAfterBindInlineUniformBlocks = copy_src->maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkWriteDescriptorSetInlineUniformBlock::safe_VkWriteDescriptorSetInlineUniformBlock(
+    const VkWriteDescriptorSetInlineUniformBlock* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), dataSize(in_struct->dataSize), pData(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pData != nullptr) {
+        auto temp = new std::byte[in_struct->dataSize];
+        std::memcpy(temp, in_struct->pData, in_struct->dataSize);
+        pData = temp;
+    }
+}
+
+safe_VkWriteDescriptorSetInlineUniformBlock::safe_VkWriteDescriptorSetInlineUniformBlock()
+    : sType(VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK), pNext(nullptr), dataSize(), pData(nullptr) {}
+
+safe_VkWriteDescriptorSetInlineUniformBlock::safe_VkWriteDescriptorSetInlineUniformBlock(
+    const safe_VkWriteDescriptorSetInlineUniformBlock& copy_src) {
+    sType = copy_src.sType;
+    dataSize = copy_src.dataSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pData != nullptr) {
+        auto temp = new std::byte[copy_src.dataSize];
+        std::memcpy(temp, copy_src.pData, copy_src.dataSize);
+        pData = temp;
+    }
+}
+
+safe_VkWriteDescriptorSetInlineUniformBlock& safe_VkWriteDescriptorSetInlineUniformBlock::operator=(
+    const safe_VkWriteDescriptorSetInlineUniformBlock& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pData != nullptr) {
+        auto temp = reinterpret_cast<const std::byte*>(pData);
+        delete[] temp;
+    }
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    dataSize = copy_src.dataSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pData != nullptr) {
+        auto temp = new std::byte[copy_src.dataSize];
+        std::memcpy(temp, copy_src.pData, copy_src.dataSize);
+        pData = temp;
+    }
+
+    return *this;
+}
+
+safe_VkWriteDescriptorSetInlineUniformBlock::~safe_VkWriteDescriptorSetInlineUniformBlock() {
+    if (pData != nullptr) {
+        auto temp = reinterpret_cast<const std::byte*>(pData);
+        delete[] temp;
+    }
+    FreePnextChain(pNext);
+}
+
+void safe_VkWriteDescriptorSetInlineUniformBlock::initialize(const VkWriteDescriptorSetInlineUniformBlock* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pData != nullptr) {
+        auto temp = reinterpret_cast<const std::byte*>(pData);
+        delete[] temp;
+    }
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    dataSize = in_struct->dataSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pData != nullptr) {
+        auto temp = new std::byte[in_struct->dataSize];
+        std::memcpy(temp, in_struct->pData, in_struct->dataSize);
+        pData = temp;
+    }
+}
+
+void safe_VkWriteDescriptorSetInlineUniformBlock::initialize(const safe_VkWriteDescriptorSetInlineUniformBlock* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    dataSize = copy_src->dataSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pData != nullptr) {
+        auto temp = new std::byte[copy_src->dataSize];
+        std::memcpy(temp, copy_src->pData, copy_src->dataSize);
+        pData = temp;
+    }
+}
+
+safe_VkDescriptorPoolInlineUniformBlockCreateInfo::safe_VkDescriptorPoolInlineUniformBlockCreateInfo(
+    const VkDescriptorPoolInlineUniformBlockCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), maxInlineUniformBlockBindings(in_struct->maxInlineUniformBlockBindings) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDescriptorPoolInlineUniformBlockCreateInfo::safe_VkDescriptorPoolInlineUniformBlockCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO), pNext(nullptr), maxInlineUniformBlockBindings() {}
+
+safe_VkDescriptorPoolInlineUniformBlockCreateInfo::safe_VkDescriptorPoolInlineUniformBlockCreateInfo(
+    const safe_VkDescriptorPoolInlineUniformBlockCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    maxInlineUniformBlockBindings = copy_src.maxInlineUniformBlockBindings;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDescriptorPoolInlineUniformBlockCreateInfo& safe_VkDescriptorPoolInlineUniformBlockCreateInfo::operator=(
+    const safe_VkDescriptorPoolInlineUniformBlockCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxInlineUniformBlockBindings = copy_src.maxInlineUniformBlockBindings;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDescriptorPoolInlineUniformBlockCreateInfo::~safe_VkDescriptorPoolInlineUniformBlockCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkDescriptorPoolInlineUniformBlockCreateInfo::initialize(const VkDescriptorPoolInlineUniformBlockCreateInfo* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxInlineUniformBlockBindings = in_struct->maxInlineUniformBlockBindings;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDescriptorPoolInlineUniformBlockCreateInfo::initialize(
+    const safe_VkDescriptorPoolInlineUniformBlockCreateInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxInlineUniformBlockBindings = copy_src->maxInlineUniformBlockBindings;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures::safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
+    const VkPhysicalDeviceTextureCompressionASTCHDRFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), textureCompressionASTC_HDR(in_struct->textureCompressionASTC_HDR) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures::safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES),
+      pNext(nullptr),
+      textureCompressionASTC_HDR() {}
+
+safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures::safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
+    const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures& copy_src) {
+    sType = copy_src.sType;
+    textureCompressionASTC_HDR = copy_src.textureCompressionASTC_HDR;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures& safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures::operator=(
+    const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    textureCompressionASTC_HDR = copy_src.textureCompressionASTC_HDR;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures::~safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures::initialize(
+    const VkPhysicalDeviceTextureCompressionASTCHDRFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    textureCompressionASTC_HDR = in_struct->textureCompressionASTC_HDR;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures::initialize(
+    const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    textureCompressionASTC_HDR = copy_src->textureCompressionASTC_HDR;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkRenderingAttachmentInfo::safe_VkRenderingAttachmentInfo(const VkRenderingAttachmentInfo* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      imageView(in_struct->imageView),
+      imageLayout(in_struct->imageLayout),
+      resolveMode(in_struct->resolveMode),
+      resolveImageView(in_struct->resolveImageView),
+      resolveImageLayout(in_struct->resolveImageLayout),
+      loadOp(in_struct->loadOp),
+      storeOp(in_struct->storeOp),
+      clearValue(in_struct->clearValue) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkRenderingAttachmentInfo::safe_VkRenderingAttachmentInfo()
+    : sType(VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO),
+      pNext(nullptr),
+      imageView(),
+      imageLayout(),
+      resolveMode(),
+      resolveImageView(),
+      resolveImageLayout(),
+      loadOp(),
+      storeOp(),
+      clearValue() {}
+
+safe_VkRenderingAttachmentInfo::safe_VkRenderingAttachmentInfo(const safe_VkRenderingAttachmentInfo& copy_src) {
+    sType = copy_src.sType;
+    imageView = copy_src.imageView;
+    imageLayout = copy_src.imageLayout;
+    resolveMode = copy_src.resolveMode;
+    resolveImageView = copy_src.resolveImageView;
+    resolveImageLayout = copy_src.resolveImageLayout;
+    loadOp = copy_src.loadOp;
+    storeOp = copy_src.storeOp;
+    clearValue = copy_src.clearValue;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkRenderingAttachmentInfo& safe_VkRenderingAttachmentInfo::operator=(const safe_VkRenderingAttachmentInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    imageView = copy_src.imageView;
+    imageLayout = copy_src.imageLayout;
+    resolveMode = copy_src.resolveMode;
+    resolveImageView = copy_src.resolveImageView;
+    resolveImageLayout = copy_src.resolveImageLayout;
+    loadOp = copy_src.loadOp;
+    storeOp = copy_src.storeOp;
+    clearValue = copy_src.clearValue;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkRenderingAttachmentInfo::~safe_VkRenderingAttachmentInfo() { FreePnextChain(pNext); }
+
+void safe_VkRenderingAttachmentInfo::initialize(const VkRenderingAttachmentInfo* in_struct,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    imageView = in_struct->imageView;
+    imageLayout = in_struct->imageLayout;
+    resolveMode = in_struct->resolveMode;
+    resolveImageView = in_struct->resolveImageView;
+    resolveImageLayout = in_struct->resolveImageLayout;
+    loadOp = in_struct->loadOp;
+    storeOp = in_struct->storeOp;
+    clearValue = in_struct->clearValue;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkRenderingAttachmentInfo::initialize(const safe_VkRenderingAttachmentInfo* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imageView = copy_src->imageView;
+    imageLayout = copy_src->imageLayout;
+    resolveMode = copy_src->resolveMode;
+    resolveImageView = copy_src->resolveImageView;
+    resolveImageLayout = copy_src->resolveImageLayout;
+    loadOp = copy_src->loadOp;
+    storeOp = copy_src->storeOp;
+    clearValue = copy_src->clearValue;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkRenderingInfo::safe_VkRenderingInfo(const VkRenderingInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                           bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      renderArea(in_struct->renderArea),
+      layerCount(in_struct->layerCount),
+      viewMask(in_struct->viewMask),
+      colorAttachmentCount(in_struct->colorAttachmentCount),
+      pColorAttachments(nullptr),
+      pDepthAttachment(nullptr),
+      pStencilAttachment(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (colorAttachmentCount && in_struct->pColorAttachments) {
+        pColorAttachments = new safe_VkRenderingAttachmentInfo[colorAttachmentCount];
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
+            pColorAttachments[i].initialize(&in_struct->pColorAttachments[i]);
+        }
+    }
+    if (in_struct->pDepthAttachment) pDepthAttachment = new safe_VkRenderingAttachmentInfo(in_struct->pDepthAttachment);
+    if (in_struct->pStencilAttachment) pStencilAttachment = new safe_VkRenderingAttachmentInfo(in_struct->pStencilAttachment);
+}
+
+safe_VkRenderingInfo::safe_VkRenderingInfo()
+    : sType(VK_STRUCTURE_TYPE_RENDERING_INFO),
+      pNext(nullptr),
+      flags(),
+      renderArea(),
+      layerCount(),
+      viewMask(),
+      colorAttachmentCount(),
+      pColorAttachments(nullptr),
+      pDepthAttachment(nullptr),
+      pStencilAttachment(nullptr) {}
+
+safe_VkRenderingInfo::safe_VkRenderingInfo(const safe_VkRenderingInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    renderArea = copy_src.renderArea;
+    layerCount = copy_src.layerCount;
+    viewMask = copy_src.viewMask;
+    colorAttachmentCount = copy_src.colorAttachmentCount;
+    pColorAttachments = nullptr;
+    pDepthAttachment = nullptr;
+    pStencilAttachment = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (colorAttachmentCount && copy_src.pColorAttachments) {
+        pColorAttachments = new safe_VkRenderingAttachmentInfo[colorAttachmentCount];
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
+            pColorAttachments[i].initialize(&copy_src.pColorAttachments[i]);
+        }
+    }
+    if (copy_src.pDepthAttachment) pDepthAttachment = new safe_VkRenderingAttachmentInfo(*copy_src.pDepthAttachment);
+    if (copy_src.pStencilAttachment) pStencilAttachment = new safe_VkRenderingAttachmentInfo(*copy_src.pStencilAttachment);
+}
+
+safe_VkRenderingInfo& safe_VkRenderingInfo::operator=(const safe_VkRenderingInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pColorAttachments) delete[] pColorAttachments;
+    if (pDepthAttachment) delete pDepthAttachment;
+    if (pStencilAttachment) delete pStencilAttachment;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    renderArea = copy_src.renderArea;
+    layerCount = copy_src.layerCount;
+    viewMask = copy_src.viewMask;
+    colorAttachmentCount = copy_src.colorAttachmentCount;
+    pColorAttachments = nullptr;
+    pDepthAttachment = nullptr;
+    pStencilAttachment = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (colorAttachmentCount && copy_src.pColorAttachments) {
+        pColorAttachments = new safe_VkRenderingAttachmentInfo[colorAttachmentCount];
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
+            pColorAttachments[i].initialize(&copy_src.pColorAttachments[i]);
+        }
+    }
+    if (copy_src.pDepthAttachment) pDepthAttachment = new safe_VkRenderingAttachmentInfo(*copy_src.pDepthAttachment);
+    if (copy_src.pStencilAttachment) pStencilAttachment = new safe_VkRenderingAttachmentInfo(*copy_src.pStencilAttachment);
+
+    return *this;
+}
+
+safe_VkRenderingInfo::~safe_VkRenderingInfo() {
+    if (pColorAttachments) delete[] pColorAttachments;
+    if (pDepthAttachment) delete pDepthAttachment;
+    if (pStencilAttachment) delete pStencilAttachment;
+    FreePnextChain(pNext);
+}
+
+void safe_VkRenderingInfo::initialize(const VkRenderingInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pColorAttachments) delete[] pColorAttachments;
+    if (pDepthAttachment) delete pDepthAttachment;
+    if (pStencilAttachment) delete pStencilAttachment;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    renderArea = in_struct->renderArea;
+    layerCount = in_struct->layerCount;
+    viewMask = in_struct->viewMask;
+    colorAttachmentCount = in_struct->colorAttachmentCount;
+    pColorAttachments = nullptr;
+    pDepthAttachment = nullptr;
+    pStencilAttachment = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (colorAttachmentCount && in_struct->pColorAttachments) {
+        pColorAttachments = new safe_VkRenderingAttachmentInfo[colorAttachmentCount];
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
+            pColorAttachments[i].initialize(&in_struct->pColorAttachments[i]);
+        }
+    }
+    if (in_struct->pDepthAttachment) pDepthAttachment = new safe_VkRenderingAttachmentInfo(in_struct->pDepthAttachment);
+    if (in_struct->pStencilAttachment) pStencilAttachment = new safe_VkRenderingAttachmentInfo(in_struct->pStencilAttachment);
+}
+
+void safe_VkRenderingInfo::initialize(const safe_VkRenderingInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    renderArea = copy_src->renderArea;
+    layerCount = copy_src->layerCount;
+    viewMask = copy_src->viewMask;
+    colorAttachmentCount = copy_src->colorAttachmentCount;
+    pColorAttachments = nullptr;
+    pDepthAttachment = nullptr;
+    pStencilAttachment = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (colorAttachmentCount && copy_src->pColorAttachments) {
+        pColorAttachments = new safe_VkRenderingAttachmentInfo[colorAttachmentCount];
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
+            pColorAttachments[i].initialize(&copy_src->pColorAttachments[i]);
+        }
+    }
+    if (copy_src->pDepthAttachment) pDepthAttachment = new safe_VkRenderingAttachmentInfo(*copy_src->pDepthAttachment);
+    if (copy_src->pStencilAttachment) pStencilAttachment = new safe_VkRenderingAttachmentInfo(*copy_src->pStencilAttachment);
+}
+
+safe_VkPipelineRenderingCreateInfo::safe_VkPipelineRenderingCreateInfo(const VkPipelineRenderingCreateInfo* in_struct,
+                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      viewMask(in_struct->viewMask),
+      colorAttachmentCount(in_struct->colorAttachmentCount),
+      pColorAttachmentFormats(nullptr),
+      depthAttachmentFormat(in_struct->depthAttachmentFormat),
+      stencilAttachmentFormat(in_struct->stencilAttachmentFormat) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    bool custom_init = copy_state && copy_state->init;
+    if (custom_init) {
+        custom_init =
+            copy_state->init(reinterpret_cast<VkBaseOutStructure*>(this), reinterpret_cast<const VkBaseOutStructure*>(in_struct));
+    }
+    if (!custom_init) {
+        // The custom iniitalization was not used, so do the regular initialization
+        if (in_struct->pColorAttachmentFormats) {
+            pColorAttachmentFormats = new VkFormat[in_struct->colorAttachmentCount];
+            memcpy((void*)pColorAttachmentFormats, (void*)in_struct->pColorAttachmentFormats,
+                   sizeof(VkFormat) * in_struct->colorAttachmentCount);
+        }
+    }
+}
+
+safe_VkPipelineRenderingCreateInfo::safe_VkPipelineRenderingCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO),
+      pNext(nullptr),
+      viewMask(),
+      colorAttachmentCount(),
+      pColorAttachmentFormats(nullptr),
+      depthAttachmentFormat(),
+      stencilAttachmentFormat() {}
+
+safe_VkPipelineRenderingCreateInfo::safe_VkPipelineRenderingCreateInfo(const safe_VkPipelineRenderingCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    viewMask = copy_src.viewMask;
+    colorAttachmentCount = copy_src.colorAttachmentCount;
+    pColorAttachmentFormats = nullptr;
+    depthAttachmentFormat = copy_src.depthAttachmentFormat;
+    stencilAttachmentFormat = copy_src.stencilAttachmentFormat;
+
+    if (copy_src.pColorAttachmentFormats) {
+        pColorAttachmentFormats = new VkFormat[copy_src.colorAttachmentCount];
+        memcpy((void*)pColorAttachmentFormats, (void*)copy_src.pColorAttachmentFormats,
+               sizeof(VkFormat) * copy_src.colorAttachmentCount);
+    }
+}
+
+safe_VkPipelineRenderingCreateInfo& safe_VkPipelineRenderingCreateInfo::operator=(
+    const safe_VkPipelineRenderingCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pColorAttachmentFormats) delete[] pColorAttachmentFormats;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    viewMask = copy_src.viewMask;
+    colorAttachmentCount = copy_src.colorAttachmentCount;
+    pColorAttachmentFormats = nullptr;
+    depthAttachmentFormat = copy_src.depthAttachmentFormat;
+    stencilAttachmentFormat = copy_src.stencilAttachmentFormat;
+
+    if (copy_src.pColorAttachmentFormats) {
+        pColorAttachmentFormats = new VkFormat[copy_src.colorAttachmentCount];
+        memcpy((void*)pColorAttachmentFormats, (void*)copy_src.pColorAttachmentFormats,
+               sizeof(VkFormat) * copy_src.colorAttachmentCount);
+    }
+
+    return *this;
+}
+
+safe_VkPipelineRenderingCreateInfo::~safe_VkPipelineRenderingCreateInfo() {
+    if (pColorAttachmentFormats) delete[] pColorAttachmentFormats;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineRenderingCreateInfo::initialize(const VkPipelineRenderingCreateInfo* in_struct,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pColorAttachmentFormats) delete[] pColorAttachmentFormats;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    viewMask = in_struct->viewMask;
+    colorAttachmentCount = in_struct->colorAttachmentCount;
+    pColorAttachmentFormats = nullptr;
+    depthAttachmentFormat = in_struct->depthAttachmentFormat;
+    stencilAttachmentFormat = in_struct->stencilAttachmentFormat;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    bool custom_init = copy_state && copy_state->init;
+    if (custom_init) {
+        custom_init =
+            copy_state->init(reinterpret_cast<VkBaseOutStructure*>(this), reinterpret_cast<const VkBaseOutStructure*>(in_struct));
+    }
+    if (!custom_init) {
+        // The custom iniitalization was not used, so do the regular initialization
+        if (in_struct->pColorAttachmentFormats) {
+            pColorAttachmentFormats = new VkFormat[in_struct->colorAttachmentCount];
+            memcpy((void*)pColorAttachmentFormats, (void*)in_struct->pColorAttachmentFormats,
+                   sizeof(VkFormat) * in_struct->colorAttachmentCount);
+        }
+    }
+}
+
+void safe_VkPipelineRenderingCreateInfo::initialize(const safe_VkPipelineRenderingCreateInfo* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    viewMask = copy_src->viewMask;
+    colorAttachmentCount = copy_src->colorAttachmentCount;
+    pColorAttachmentFormats = nullptr;
+    depthAttachmentFormat = copy_src->depthAttachmentFormat;
+    stencilAttachmentFormat = copy_src->stencilAttachmentFormat;
+
+    if (copy_src->pColorAttachmentFormats) {
+        pColorAttachmentFormats = new VkFormat[copy_src->colorAttachmentCount];
+        memcpy((void*)pColorAttachmentFormats, (void*)copy_src->pColorAttachmentFormats,
+               sizeof(VkFormat) * copy_src->colorAttachmentCount);
+    }
+}
+
+safe_VkPhysicalDeviceDynamicRenderingFeatures::safe_VkPhysicalDeviceDynamicRenderingFeatures(
+    const VkPhysicalDeviceDynamicRenderingFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), dynamicRendering(in_struct->dynamicRendering) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDynamicRenderingFeatures::safe_VkPhysicalDeviceDynamicRenderingFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES), pNext(nullptr), dynamicRendering() {}
+
+safe_VkPhysicalDeviceDynamicRenderingFeatures::safe_VkPhysicalDeviceDynamicRenderingFeatures(
+    const safe_VkPhysicalDeviceDynamicRenderingFeatures& copy_src) {
+    sType = copy_src.sType;
+    dynamicRendering = copy_src.dynamicRendering;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDynamicRenderingFeatures& safe_VkPhysicalDeviceDynamicRenderingFeatures::operator=(
+    const safe_VkPhysicalDeviceDynamicRenderingFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    dynamicRendering = copy_src.dynamicRendering;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDynamicRenderingFeatures::~safe_VkPhysicalDeviceDynamicRenderingFeatures() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceDynamicRenderingFeatures::initialize(const VkPhysicalDeviceDynamicRenderingFeatures* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    dynamicRendering = in_struct->dynamicRendering;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDynamicRenderingFeatures::initialize(const safe_VkPhysicalDeviceDynamicRenderingFeatures* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    dynamicRendering = copy_src->dynamicRendering;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkCommandBufferInheritanceRenderingInfo::safe_VkCommandBufferInheritanceRenderingInfo(
+    const VkCommandBufferInheritanceRenderingInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      viewMask(in_struct->viewMask),
+      colorAttachmentCount(in_struct->colorAttachmentCount),
+      pColorAttachmentFormats(nullptr),
+      depthAttachmentFormat(in_struct->depthAttachmentFormat),
+      stencilAttachmentFormat(in_struct->stencilAttachmentFormat),
+      rasterizationSamples(in_struct->rasterizationSamples) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pColorAttachmentFormats) {
+        pColorAttachmentFormats = new VkFormat[in_struct->colorAttachmentCount];
+        memcpy((void*)pColorAttachmentFormats, (void*)in_struct->pColorAttachmentFormats,
+               sizeof(VkFormat) * in_struct->colorAttachmentCount);
+    }
+}
+
+safe_VkCommandBufferInheritanceRenderingInfo::safe_VkCommandBufferInheritanceRenderingInfo()
+    : sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO),
+      pNext(nullptr),
+      flags(),
+      viewMask(),
+      colorAttachmentCount(),
+      pColorAttachmentFormats(nullptr),
+      depthAttachmentFormat(),
+      stencilAttachmentFormat(),
+      rasterizationSamples() {}
+
+safe_VkCommandBufferInheritanceRenderingInfo::safe_VkCommandBufferInheritanceRenderingInfo(
+    const safe_VkCommandBufferInheritanceRenderingInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    viewMask = copy_src.viewMask;
+    colorAttachmentCount = copy_src.colorAttachmentCount;
+    pColorAttachmentFormats = nullptr;
+    depthAttachmentFormat = copy_src.depthAttachmentFormat;
+    stencilAttachmentFormat = copy_src.stencilAttachmentFormat;
+    rasterizationSamples = copy_src.rasterizationSamples;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pColorAttachmentFormats) {
+        pColorAttachmentFormats = new VkFormat[copy_src.colorAttachmentCount];
+        memcpy((void*)pColorAttachmentFormats, (void*)copy_src.pColorAttachmentFormats,
+               sizeof(VkFormat) * copy_src.colorAttachmentCount);
+    }
+}
+
+safe_VkCommandBufferInheritanceRenderingInfo& safe_VkCommandBufferInheritanceRenderingInfo::operator=(
+    const safe_VkCommandBufferInheritanceRenderingInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pColorAttachmentFormats) delete[] pColorAttachmentFormats;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    viewMask = copy_src.viewMask;
+    colorAttachmentCount = copy_src.colorAttachmentCount;
+    pColorAttachmentFormats = nullptr;
+    depthAttachmentFormat = copy_src.depthAttachmentFormat;
+    stencilAttachmentFormat = copy_src.stencilAttachmentFormat;
+    rasterizationSamples = copy_src.rasterizationSamples;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pColorAttachmentFormats) {
+        pColorAttachmentFormats = new VkFormat[copy_src.colorAttachmentCount];
+        memcpy((void*)pColorAttachmentFormats, (void*)copy_src.pColorAttachmentFormats,
+               sizeof(VkFormat) * copy_src.colorAttachmentCount);
+    }
+
+    return *this;
+}
+
+safe_VkCommandBufferInheritanceRenderingInfo::~safe_VkCommandBufferInheritanceRenderingInfo() {
+    if (pColorAttachmentFormats) delete[] pColorAttachmentFormats;
+    FreePnextChain(pNext);
+}
+
+void safe_VkCommandBufferInheritanceRenderingInfo::initialize(const VkCommandBufferInheritanceRenderingInfo* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pColorAttachmentFormats) delete[] pColorAttachmentFormats;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    viewMask = in_struct->viewMask;
+    colorAttachmentCount = in_struct->colorAttachmentCount;
+    pColorAttachmentFormats = nullptr;
+    depthAttachmentFormat = in_struct->depthAttachmentFormat;
+    stencilAttachmentFormat = in_struct->stencilAttachmentFormat;
+    rasterizationSamples = in_struct->rasterizationSamples;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pColorAttachmentFormats) {
+        pColorAttachmentFormats = new VkFormat[in_struct->colorAttachmentCount];
+        memcpy((void*)pColorAttachmentFormats, (void*)in_struct->pColorAttachmentFormats,
+               sizeof(VkFormat) * in_struct->colorAttachmentCount);
+    }
+}
+
+void safe_VkCommandBufferInheritanceRenderingInfo::initialize(const safe_VkCommandBufferInheritanceRenderingInfo* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    viewMask = copy_src->viewMask;
+    colorAttachmentCount = copy_src->colorAttachmentCount;
+    pColorAttachmentFormats = nullptr;
+    depthAttachmentFormat = copy_src->depthAttachmentFormat;
+    stencilAttachmentFormat = copy_src->stencilAttachmentFormat;
+    rasterizationSamples = copy_src->rasterizationSamples;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pColorAttachmentFormats) {
+        pColorAttachmentFormats = new VkFormat[copy_src->colorAttachmentCount];
+        memcpy((void*)pColorAttachmentFormats, (void*)copy_src->pColorAttachmentFormats,
+               sizeof(VkFormat) * copy_src->colorAttachmentCount);
+    }
+}
+
+safe_VkPhysicalDeviceShaderIntegerDotProductFeatures::safe_VkPhysicalDeviceShaderIntegerDotProductFeatures(
+    const VkPhysicalDeviceShaderIntegerDotProductFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), shaderIntegerDotProduct(in_struct->shaderIntegerDotProduct) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderIntegerDotProductFeatures::safe_VkPhysicalDeviceShaderIntegerDotProductFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES), pNext(nullptr), shaderIntegerDotProduct() {}
+
+safe_VkPhysicalDeviceShaderIntegerDotProductFeatures::safe_VkPhysicalDeviceShaderIntegerDotProductFeatures(
+    const safe_VkPhysicalDeviceShaderIntegerDotProductFeatures& copy_src) {
+    sType = copy_src.sType;
+    shaderIntegerDotProduct = copy_src.shaderIntegerDotProduct;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderIntegerDotProductFeatures& safe_VkPhysicalDeviceShaderIntegerDotProductFeatures::operator=(
+    const safe_VkPhysicalDeviceShaderIntegerDotProductFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderIntegerDotProduct = copy_src.shaderIntegerDotProduct;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderIntegerDotProductFeatures::~safe_VkPhysicalDeviceShaderIntegerDotProductFeatures() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceShaderIntegerDotProductFeatures::initialize(
+    const VkPhysicalDeviceShaderIntegerDotProductFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderIntegerDotProduct = in_struct->shaderIntegerDotProduct;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderIntegerDotProductFeatures::initialize(
+    const safe_VkPhysicalDeviceShaderIntegerDotProductFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderIntegerDotProduct = copy_src->shaderIntegerDotProduct;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceShaderIntegerDotProductProperties::safe_VkPhysicalDeviceShaderIntegerDotProductProperties(
+    const VkPhysicalDeviceShaderIntegerDotProductProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      integerDotProduct8BitUnsignedAccelerated(in_struct->integerDotProduct8BitUnsignedAccelerated),
+      integerDotProduct8BitSignedAccelerated(in_struct->integerDotProduct8BitSignedAccelerated),
+      integerDotProduct8BitMixedSignednessAccelerated(in_struct->integerDotProduct8BitMixedSignednessAccelerated),
+      integerDotProduct4x8BitPackedUnsignedAccelerated(in_struct->integerDotProduct4x8BitPackedUnsignedAccelerated),
+      integerDotProduct4x8BitPackedSignedAccelerated(in_struct->integerDotProduct4x8BitPackedSignedAccelerated),
+      integerDotProduct4x8BitPackedMixedSignednessAccelerated(in_struct->integerDotProduct4x8BitPackedMixedSignednessAccelerated),
+      integerDotProduct16BitUnsignedAccelerated(in_struct->integerDotProduct16BitUnsignedAccelerated),
+      integerDotProduct16BitSignedAccelerated(in_struct->integerDotProduct16BitSignedAccelerated),
+      integerDotProduct16BitMixedSignednessAccelerated(in_struct->integerDotProduct16BitMixedSignednessAccelerated),
+      integerDotProduct32BitUnsignedAccelerated(in_struct->integerDotProduct32BitUnsignedAccelerated),
+      integerDotProduct32BitSignedAccelerated(in_struct->integerDotProduct32BitSignedAccelerated),
+      integerDotProduct32BitMixedSignednessAccelerated(in_struct->integerDotProduct32BitMixedSignednessAccelerated),
+      integerDotProduct64BitUnsignedAccelerated(in_struct->integerDotProduct64BitUnsignedAccelerated),
+      integerDotProduct64BitSignedAccelerated(in_struct->integerDotProduct64BitSignedAccelerated),
+      integerDotProduct64BitMixedSignednessAccelerated(in_struct->integerDotProduct64BitMixedSignednessAccelerated),
+      integerDotProductAccumulatingSaturating8BitUnsignedAccelerated(
+          in_struct->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated),
+      integerDotProductAccumulatingSaturating8BitSignedAccelerated(
+          in_struct->integerDotProductAccumulatingSaturating8BitSignedAccelerated),
+      integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated(
+          in_struct->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated),
+      integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated(
+          in_struct->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated),
+      integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated(
+          in_struct->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated),
+      integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated(
+          in_struct->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated),
+      integerDotProductAccumulatingSaturating16BitUnsignedAccelerated(
+          in_struct->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated),
+      integerDotProductAccumulatingSaturating16BitSignedAccelerated(
+          in_struct->integerDotProductAccumulatingSaturating16BitSignedAccelerated),
+      integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated(
+          in_struct->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated),
+      integerDotProductAccumulatingSaturating32BitUnsignedAccelerated(
+          in_struct->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated),
+      integerDotProductAccumulatingSaturating32BitSignedAccelerated(
+          in_struct->integerDotProductAccumulatingSaturating32BitSignedAccelerated),
+      integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated(
+          in_struct->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated),
+      integerDotProductAccumulatingSaturating64BitUnsignedAccelerated(
+          in_struct->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated),
+      integerDotProductAccumulatingSaturating64BitSignedAccelerated(
+          in_struct->integerDotProductAccumulatingSaturating64BitSignedAccelerated),
+      integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated(
+          in_struct->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderIntegerDotProductProperties::safe_VkPhysicalDeviceShaderIntegerDotProductProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES),
+      pNext(nullptr),
+      integerDotProduct8BitUnsignedAccelerated(),
+      integerDotProduct8BitSignedAccelerated(),
+      integerDotProduct8BitMixedSignednessAccelerated(),
+      integerDotProduct4x8BitPackedUnsignedAccelerated(),
+      integerDotProduct4x8BitPackedSignedAccelerated(),
+      integerDotProduct4x8BitPackedMixedSignednessAccelerated(),
+      integerDotProduct16BitUnsignedAccelerated(),
+      integerDotProduct16BitSignedAccelerated(),
+      integerDotProduct16BitMixedSignednessAccelerated(),
+      integerDotProduct32BitUnsignedAccelerated(),
+      integerDotProduct32BitSignedAccelerated(),
+      integerDotProduct32BitMixedSignednessAccelerated(),
+      integerDotProduct64BitUnsignedAccelerated(),
+      integerDotProduct64BitSignedAccelerated(),
+      integerDotProduct64BitMixedSignednessAccelerated(),
+      integerDotProductAccumulatingSaturating8BitUnsignedAccelerated(),
+      integerDotProductAccumulatingSaturating8BitSignedAccelerated(),
+      integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated(),
+      integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated(),
+      integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated(),
+      integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated(),
+      integerDotProductAccumulatingSaturating16BitUnsignedAccelerated(),
+      integerDotProductAccumulatingSaturating16BitSignedAccelerated(),
+      integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated(),
+      integerDotProductAccumulatingSaturating32BitUnsignedAccelerated(),
+      integerDotProductAccumulatingSaturating32BitSignedAccelerated(),
+      integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated(),
+      integerDotProductAccumulatingSaturating64BitUnsignedAccelerated(),
+      integerDotProductAccumulatingSaturating64BitSignedAccelerated(),
+      integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated() {}
+
+safe_VkPhysicalDeviceShaderIntegerDotProductProperties::safe_VkPhysicalDeviceShaderIntegerDotProductProperties(
+    const safe_VkPhysicalDeviceShaderIntegerDotProductProperties& copy_src) {
+    sType = copy_src.sType;
+    integerDotProduct8BitUnsignedAccelerated = copy_src.integerDotProduct8BitUnsignedAccelerated;
+    integerDotProduct8BitSignedAccelerated = copy_src.integerDotProduct8BitSignedAccelerated;
+    integerDotProduct8BitMixedSignednessAccelerated = copy_src.integerDotProduct8BitMixedSignednessAccelerated;
+    integerDotProduct4x8BitPackedUnsignedAccelerated = copy_src.integerDotProduct4x8BitPackedUnsignedAccelerated;
+    integerDotProduct4x8BitPackedSignedAccelerated = copy_src.integerDotProduct4x8BitPackedSignedAccelerated;
+    integerDotProduct4x8BitPackedMixedSignednessAccelerated = copy_src.integerDotProduct4x8BitPackedMixedSignednessAccelerated;
+    integerDotProduct16BitUnsignedAccelerated = copy_src.integerDotProduct16BitUnsignedAccelerated;
+    integerDotProduct16BitSignedAccelerated = copy_src.integerDotProduct16BitSignedAccelerated;
+    integerDotProduct16BitMixedSignednessAccelerated = copy_src.integerDotProduct16BitMixedSignednessAccelerated;
+    integerDotProduct32BitUnsignedAccelerated = copy_src.integerDotProduct32BitUnsignedAccelerated;
+    integerDotProduct32BitSignedAccelerated = copy_src.integerDotProduct32BitSignedAccelerated;
+    integerDotProduct32BitMixedSignednessAccelerated = copy_src.integerDotProduct32BitMixedSignednessAccelerated;
+    integerDotProduct64BitUnsignedAccelerated = copy_src.integerDotProduct64BitUnsignedAccelerated;
+    integerDotProduct64BitSignedAccelerated = copy_src.integerDotProduct64BitSignedAccelerated;
+    integerDotProduct64BitMixedSignednessAccelerated = copy_src.integerDotProduct64BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating8BitUnsignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating8BitSignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating8BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
+    integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating16BitUnsignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating16BitSignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating16BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating32BitUnsignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating32BitSignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating32BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating64BitUnsignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating64BitSignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating64BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderIntegerDotProductProperties& safe_VkPhysicalDeviceShaderIntegerDotProductProperties::operator=(
+    const safe_VkPhysicalDeviceShaderIntegerDotProductProperties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    integerDotProduct8BitUnsignedAccelerated = copy_src.integerDotProduct8BitUnsignedAccelerated;
+    integerDotProduct8BitSignedAccelerated = copy_src.integerDotProduct8BitSignedAccelerated;
+    integerDotProduct8BitMixedSignednessAccelerated = copy_src.integerDotProduct8BitMixedSignednessAccelerated;
+    integerDotProduct4x8BitPackedUnsignedAccelerated = copy_src.integerDotProduct4x8BitPackedUnsignedAccelerated;
+    integerDotProduct4x8BitPackedSignedAccelerated = copy_src.integerDotProduct4x8BitPackedSignedAccelerated;
+    integerDotProduct4x8BitPackedMixedSignednessAccelerated = copy_src.integerDotProduct4x8BitPackedMixedSignednessAccelerated;
+    integerDotProduct16BitUnsignedAccelerated = copy_src.integerDotProduct16BitUnsignedAccelerated;
+    integerDotProduct16BitSignedAccelerated = copy_src.integerDotProduct16BitSignedAccelerated;
+    integerDotProduct16BitMixedSignednessAccelerated = copy_src.integerDotProduct16BitMixedSignednessAccelerated;
+    integerDotProduct32BitUnsignedAccelerated = copy_src.integerDotProduct32BitUnsignedAccelerated;
+    integerDotProduct32BitSignedAccelerated = copy_src.integerDotProduct32BitSignedAccelerated;
+    integerDotProduct32BitMixedSignednessAccelerated = copy_src.integerDotProduct32BitMixedSignednessAccelerated;
+    integerDotProduct64BitUnsignedAccelerated = copy_src.integerDotProduct64BitUnsignedAccelerated;
+    integerDotProduct64BitSignedAccelerated = copy_src.integerDotProduct64BitSignedAccelerated;
+    integerDotProduct64BitMixedSignednessAccelerated = copy_src.integerDotProduct64BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating8BitUnsignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating8BitSignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating8BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
+    integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating16BitUnsignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating16BitSignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating16BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating32BitUnsignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating32BitSignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating32BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating64BitUnsignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating64BitSignedAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating64BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated =
+        copy_src.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderIntegerDotProductProperties::~safe_VkPhysicalDeviceShaderIntegerDotProductProperties() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceShaderIntegerDotProductProperties::initialize(
+    const VkPhysicalDeviceShaderIntegerDotProductProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    integerDotProduct8BitUnsignedAccelerated = in_struct->integerDotProduct8BitUnsignedAccelerated;
+    integerDotProduct8BitSignedAccelerated = in_struct->integerDotProduct8BitSignedAccelerated;
+    integerDotProduct8BitMixedSignednessAccelerated = in_struct->integerDotProduct8BitMixedSignednessAccelerated;
+    integerDotProduct4x8BitPackedUnsignedAccelerated = in_struct->integerDotProduct4x8BitPackedUnsignedAccelerated;
+    integerDotProduct4x8BitPackedSignedAccelerated = in_struct->integerDotProduct4x8BitPackedSignedAccelerated;
+    integerDotProduct4x8BitPackedMixedSignednessAccelerated = in_struct->integerDotProduct4x8BitPackedMixedSignednessAccelerated;
+    integerDotProduct16BitUnsignedAccelerated = in_struct->integerDotProduct16BitUnsignedAccelerated;
+    integerDotProduct16BitSignedAccelerated = in_struct->integerDotProduct16BitSignedAccelerated;
+    integerDotProduct16BitMixedSignednessAccelerated = in_struct->integerDotProduct16BitMixedSignednessAccelerated;
+    integerDotProduct32BitUnsignedAccelerated = in_struct->integerDotProduct32BitUnsignedAccelerated;
+    integerDotProduct32BitSignedAccelerated = in_struct->integerDotProduct32BitSignedAccelerated;
+    integerDotProduct32BitMixedSignednessAccelerated = in_struct->integerDotProduct32BitMixedSignednessAccelerated;
+    integerDotProduct64BitUnsignedAccelerated = in_struct->integerDotProduct64BitUnsignedAccelerated;
+    integerDotProduct64BitSignedAccelerated = in_struct->integerDotProduct64BitSignedAccelerated;
+    integerDotProduct64BitMixedSignednessAccelerated = in_struct->integerDotProduct64BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating8BitUnsignedAccelerated =
+        in_struct->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating8BitSignedAccelerated =
+        in_struct->integerDotProductAccumulatingSaturating8BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated =
+        in_struct->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated =
+        in_struct->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated =
+        in_struct->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
+    integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated =
+        in_struct->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating16BitUnsignedAccelerated =
+        in_struct->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating16BitSignedAccelerated =
+        in_struct->integerDotProductAccumulatingSaturating16BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated =
+        in_struct->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating32BitUnsignedAccelerated =
+        in_struct->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating32BitSignedAccelerated =
+        in_struct->integerDotProductAccumulatingSaturating32BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated =
+        in_struct->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating64BitUnsignedAccelerated =
+        in_struct->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating64BitSignedAccelerated =
+        in_struct->integerDotProductAccumulatingSaturating64BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated =
+        in_struct->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderIntegerDotProductProperties::initialize(
+    const safe_VkPhysicalDeviceShaderIntegerDotProductProperties* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    integerDotProduct8BitUnsignedAccelerated = copy_src->integerDotProduct8BitUnsignedAccelerated;
+    integerDotProduct8BitSignedAccelerated = copy_src->integerDotProduct8BitSignedAccelerated;
+    integerDotProduct8BitMixedSignednessAccelerated = copy_src->integerDotProduct8BitMixedSignednessAccelerated;
+    integerDotProduct4x8BitPackedUnsignedAccelerated = copy_src->integerDotProduct4x8BitPackedUnsignedAccelerated;
+    integerDotProduct4x8BitPackedSignedAccelerated = copy_src->integerDotProduct4x8BitPackedSignedAccelerated;
+    integerDotProduct4x8BitPackedMixedSignednessAccelerated = copy_src->integerDotProduct4x8BitPackedMixedSignednessAccelerated;
+    integerDotProduct16BitUnsignedAccelerated = copy_src->integerDotProduct16BitUnsignedAccelerated;
+    integerDotProduct16BitSignedAccelerated = copy_src->integerDotProduct16BitSignedAccelerated;
+    integerDotProduct16BitMixedSignednessAccelerated = copy_src->integerDotProduct16BitMixedSignednessAccelerated;
+    integerDotProduct32BitUnsignedAccelerated = copy_src->integerDotProduct32BitUnsignedAccelerated;
+    integerDotProduct32BitSignedAccelerated = copy_src->integerDotProduct32BitSignedAccelerated;
+    integerDotProduct32BitMixedSignednessAccelerated = copy_src->integerDotProduct32BitMixedSignednessAccelerated;
+    integerDotProduct64BitUnsignedAccelerated = copy_src->integerDotProduct64BitUnsignedAccelerated;
+    integerDotProduct64BitSignedAccelerated = copy_src->integerDotProduct64BitSignedAccelerated;
+    integerDotProduct64BitMixedSignednessAccelerated = copy_src->integerDotProduct64BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating8BitUnsignedAccelerated =
+        copy_src->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating8BitSignedAccelerated =
+        copy_src->integerDotProductAccumulatingSaturating8BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated =
+        copy_src->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated =
+        copy_src->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated =
+        copy_src->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;
+    integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated =
+        copy_src->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating16BitUnsignedAccelerated =
+        copy_src->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating16BitSignedAccelerated =
+        copy_src->integerDotProductAccumulatingSaturating16BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated =
+        copy_src->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating32BitUnsignedAccelerated =
+        copy_src->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating32BitSignedAccelerated =
+        copy_src->integerDotProductAccumulatingSaturating32BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated =
+        copy_src->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;
+    integerDotProductAccumulatingSaturating64BitUnsignedAccelerated =
+        copy_src->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;
+    integerDotProductAccumulatingSaturating64BitSignedAccelerated =
+        copy_src->integerDotProductAccumulatingSaturating64BitSignedAccelerated;
+    integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated =
+        copy_src->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceTexelBufferAlignmentProperties::safe_VkPhysicalDeviceTexelBufferAlignmentProperties(
+    const VkPhysicalDeviceTexelBufferAlignmentProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      storageTexelBufferOffsetAlignmentBytes(in_struct->storageTexelBufferOffsetAlignmentBytes),
+      storageTexelBufferOffsetSingleTexelAlignment(in_struct->storageTexelBufferOffsetSingleTexelAlignment),
+      uniformTexelBufferOffsetAlignmentBytes(in_struct->uniformTexelBufferOffsetAlignmentBytes),
+      uniformTexelBufferOffsetSingleTexelAlignment(in_struct->uniformTexelBufferOffsetSingleTexelAlignment) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceTexelBufferAlignmentProperties::safe_VkPhysicalDeviceTexelBufferAlignmentProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES),
+      pNext(nullptr),
+      storageTexelBufferOffsetAlignmentBytes(),
+      storageTexelBufferOffsetSingleTexelAlignment(),
+      uniformTexelBufferOffsetAlignmentBytes(),
+      uniformTexelBufferOffsetSingleTexelAlignment() {}
+
+safe_VkPhysicalDeviceTexelBufferAlignmentProperties::safe_VkPhysicalDeviceTexelBufferAlignmentProperties(
+    const safe_VkPhysicalDeviceTexelBufferAlignmentProperties& copy_src) {
+    sType = copy_src.sType;
+    storageTexelBufferOffsetAlignmentBytes = copy_src.storageTexelBufferOffsetAlignmentBytes;
+    storageTexelBufferOffsetSingleTexelAlignment = copy_src.storageTexelBufferOffsetSingleTexelAlignment;
+    uniformTexelBufferOffsetAlignmentBytes = copy_src.uniformTexelBufferOffsetAlignmentBytes;
+    uniformTexelBufferOffsetSingleTexelAlignment = copy_src.uniformTexelBufferOffsetSingleTexelAlignment;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceTexelBufferAlignmentProperties& safe_VkPhysicalDeviceTexelBufferAlignmentProperties::operator=(
+    const safe_VkPhysicalDeviceTexelBufferAlignmentProperties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    storageTexelBufferOffsetAlignmentBytes = copy_src.storageTexelBufferOffsetAlignmentBytes;
+    storageTexelBufferOffsetSingleTexelAlignment = copy_src.storageTexelBufferOffsetSingleTexelAlignment;
+    uniformTexelBufferOffsetAlignmentBytes = copy_src.uniformTexelBufferOffsetAlignmentBytes;
+    uniformTexelBufferOffsetSingleTexelAlignment = copy_src.uniformTexelBufferOffsetSingleTexelAlignment;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceTexelBufferAlignmentProperties::~safe_VkPhysicalDeviceTexelBufferAlignmentProperties() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceTexelBufferAlignmentProperties::initialize(
+    const VkPhysicalDeviceTexelBufferAlignmentProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    storageTexelBufferOffsetAlignmentBytes = in_struct->storageTexelBufferOffsetAlignmentBytes;
+    storageTexelBufferOffsetSingleTexelAlignment = in_struct->storageTexelBufferOffsetSingleTexelAlignment;
+    uniformTexelBufferOffsetAlignmentBytes = in_struct->uniformTexelBufferOffsetAlignmentBytes;
+    uniformTexelBufferOffsetSingleTexelAlignment = in_struct->uniformTexelBufferOffsetSingleTexelAlignment;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceTexelBufferAlignmentProperties::initialize(
+    const safe_VkPhysicalDeviceTexelBufferAlignmentProperties* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    storageTexelBufferOffsetAlignmentBytes = copy_src->storageTexelBufferOffsetAlignmentBytes;
+    storageTexelBufferOffsetSingleTexelAlignment = copy_src->storageTexelBufferOffsetSingleTexelAlignment;
+    uniformTexelBufferOffsetAlignmentBytes = copy_src->uniformTexelBufferOffsetAlignmentBytes;
+    uniformTexelBufferOffsetSingleTexelAlignment = copy_src->uniformTexelBufferOffsetSingleTexelAlignment;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkFormatProperties3::safe_VkFormatProperties3(const VkFormatProperties3* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      linearTilingFeatures(in_struct->linearTilingFeatures),
+      optimalTilingFeatures(in_struct->optimalTilingFeatures),
+      bufferFeatures(in_struct->bufferFeatures) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkFormatProperties3::safe_VkFormatProperties3()
+    : sType(VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3),
+      pNext(nullptr),
+      linearTilingFeatures(),
+      optimalTilingFeatures(),
+      bufferFeatures() {}
+
+safe_VkFormatProperties3::safe_VkFormatProperties3(const safe_VkFormatProperties3& copy_src) {
+    sType = copy_src.sType;
+    linearTilingFeatures = copy_src.linearTilingFeatures;
+    optimalTilingFeatures = copy_src.optimalTilingFeatures;
+    bufferFeatures = copy_src.bufferFeatures;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkFormatProperties3& safe_VkFormatProperties3::operator=(const safe_VkFormatProperties3& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    linearTilingFeatures = copy_src.linearTilingFeatures;
+    optimalTilingFeatures = copy_src.optimalTilingFeatures;
+    bufferFeatures = copy_src.bufferFeatures;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkFormatProperties3::~safe_VkFormatProperties3() { FreePnextChain(pNext); }
+
+void safe_VkFormatProperties3::initialize(const VkFormatProperties3* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    linearTilingFeatures = in_struct->linearTilingFeatures;
+    optimalTilingFeatures = in_struct->optimalTilingFeatures;
+    bufferFeatures = in_struct->bufferFeatures;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkFormatProperties3::initialize(const safe_VkFormatProperties3* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    linearTilingFeatures = copy_src->linearTilingFeatures;
+    optimalTilingFeatures = copy_src->optimalTilingFeatures;
+    bufferFeatures = copy_src->bufferFeatures;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceMaintenance4Features::safe_VkPhysicalDeviceMaintenance4Features(
+    const VkPhysicalDeviceMaintenance4Features* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), maintenance4(in_struct->maintenance4) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMaintenance4Features::safe_VkPhysicalDeviceMaintenance4Features()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES), pNext(nullptr), maintenance4() {}
+
+safe_VkPhysicalDeviceMaintenance4Features::safe_VkPhysicalDeviceMaintenance4Features(
+    const safe_VkPhysicalDeviceMaintenance4Features& copy_src) {
+    sType = copy_src.sType;
+    maintenance4 = copy_src.maintenance4;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMaintenance4Features& safe_VkPhysicalDeviceMaintenance4Features::operator=(
+    const safe_VkPhysicalDeviceMaintenance4Features& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maintenance4 = copy_src.maintenance4;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMaintenance4Features::~safe_VkPhysicalDeviceMaintenance4Features() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceMaintenance4Features::initialize(const VkPhysicalDeviceMaintenance4Features* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maintenance4 = in_struct->maintenance4;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMaintenance4Features::initialize(const safe_VkPhysicalDeviceMaintenance4Features* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maintenance4 = copy_src->maintenance4;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceMaintenance4Properties::safe_VkPhysicalDeviceMaintenance4Properties(
+    const VkPhysicalDeviceMaintenance4Properties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), maxBufferSize(in_struct->maxBufferSize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMaintenance4Properties::safe_VkPhysicalDeviceMaintenance4Properties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES), pNext(nullptr), maxBufferSize() {}
+
+safe_VkPhysicalDeviceMaintenance4Properties::safe_VkPhysicalDeviceMaintenance4Properties(
+    const safe_VkPhysicalDeviceMaintenance4Properties& copy_src) {
+    sType = copy_src.sType;
+    maxBufferSize = copy_src.maxBufferSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMaintenance4Properties& safe_VkPhysicalDeviceMaintenance4Properties::operator=(
+    const safe_VkPhysicalDeviceMaintenance4Properties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxBufferSize = copy_src.maxBufferSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMaintenance4Properties::~safe_VkPhysicalDeviceMaintenance4Properties() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceMaintenance4Properties::initialize(const VkPhysicalDeviceMaintenance4Properties* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxBufferSize = in_struct->maxBufferSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMaintenance4Properties::initialize(const safe_VkPhysicalDeviceMaintenance4Properties* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxBufferSize = copy_src->maxBufferSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDeviceBufferMemoryRequirements::safe_VkDeviceBufferMemoryRequirements(const VkDeviceBufferMemoryRequirements* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType), pCreateInfo(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pCreateInfo) pCreateInfo = new safe_VkBufferCreateInfo(in_struct->pCreateInfo);
+}
+
+safe_VkDeviceBufferMemoryRequirements::safe_VkDeviceBufferMemoryRequirements()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS), pNext(nullptr), pCreateInfo(nullptr) {}
+
+safe_VkDeviceBufferMemoryRequirements::safe_VkDeviceBufferMemoryRequirements(
+    const safe_VkDeviceBufferMemoryRequirements& copy_src) {
+    sType = copy_src.sType;
+    pCreateInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pCreateInfo) pCreateInfo = new safe_VkBufferCreateInfo(*copy_src.pCreateInfo);
+}
+
+safe_VkDeviceBufferMemoryRequirements& safe_VkDeviceBufferMemoryRequirements::operator=(
+    const safe_VkDeviceBufferMemoryRequirements& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pCreateInfo) delete pCreateInfo;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pCreateInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pCreateInfo) pCreateInfo = new safe_VkBufferCreateInfo(*copy_src.pCreateInfo);
+
+    return *this;
+}
+
+safe_VkDeviceBufferMemoryRequirements::~safe_VkDeviceBufferMemoryRequirements() {
+    if (pCreateInfo) delete pCreateInfo;
+    FreePnextChain(pNext);
+}
+
+void safe_VkDeviceBufferMemoryRequirements::initialize(const VkDeviceBufferMemoryRequirements* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pCreateInfo) delete pCreateInfo;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pCreateInfo = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (in_struct->pCreateInfo) pCreateInfo = new safe_VkBufferCreateInfo(in_struct->pCreateInfo);
+}
+
+void safe_VkDeviceBufferMemoryRequirements::initialize(const safe_VkDeviceBufferMemoryRequirements* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pCreateInfo = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (copy_src->pCreateInfo) pCreateInfo = new safe_VkBufferCreateInfo(*copy_src->pCreateInfo);
+}
+
+safe_VkDeviceImageMemoryRequirements::safe_VkDeviceImageMemoryRequirements(const VkDeviceImageMemoryRequirements* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), pCreateInfo(nullptr), planeAspect(in_struct->planeAspect) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(in_struct->pCreateInfo);
+}
+
+safe_VkDeviceImageMemoryRequirements::safe_VkDeviceImageMemoryRequirements()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS), pNext(nullptr), pCreateInfo(nullptr), planeAspect() {}
+
+safe_VkDeviceImageMemoryRequirements::safe_VkDeviceImageMemoryRequirements(const safe_VkDeviceImageMemoryRequirements& copy_src) {
+    sType = copy_src.sType;
+    pCreateInfo = nullptr;
+    planeAspect = copy_src.planeAspect;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(*copy_src.pCreateInfo);
+}
+
+safe_VkDeviceImageMemoryRequirements& safe_VkDeviceImageMemoryRequirements::operator=(
+    const safe_VkDeviceImageMemoryRequirements& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pCreateInfo) delete pCreateInfo;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pCreateInfo = nullptr;
+    planeAspect = copy_src.planeAspect;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(*copy_src.pCreateInfo);
+
+    return *this;
+}
+
+safe_VkDeviceImageMemoryRequirements::~safe_VkDeviceImageMemoryRequirements() {
+    if (pCreateInfo) delete pCreateInfo;
+    FreePnextChain(pNext);
+}
+
+void safe_VkDeviceImageMemoryRequirements::initialize(const VkDeviceImageMemoryRequirements* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pCreateInfo) delete pCreateInfo;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pCreateInfo = nullptr;
+    planeAspect = in_struct->planeAspect;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (in_struct->pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(in_struct->pCreateInfo);
+}
+
+void safe_VkDeviceImageMemoryRequirements::initialize(const safe_VkDeviceImageMemoryRequirements* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pCreateInfo = nullptr;
+    planeAspect = copy_src->planeAspect;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (copy_src->pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(*copy_src->pCreateInfo);
+}
+
+}  // namespace vku
+
+// NOLINTEND
diff --git a/src/vulkan/vk_safe_struct_ext.cpp b/src/vulkan/vk_safe_struct_ext.cpp
new file mode 100644
index 0000000..0f65c58
--- /dev/null
+++ b/src/vulkan/vk_safe_struct_ext.cpp
@@ -0,0 +1,15447 @@
+// *** THIS FILE IS GENERATED - DO NOT EDIT ***
+// See safe_struct_generator.py for modifications
+
+/***************************************************************************
+ *
+ * Copyright (c) 2015-2024 The Khronos Group Inc.
+ * Copyright (c) 2015-2024 Valve Corporation
+ * Copyright (c) 2015-2024 LunarG, Inc.
+ * Copyright (c) 2015-2024 Google Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ ****************************************************************************/
+
+// NOLINTBEGIN
+
+#include <vulkan/utility/vk_safe_struct.hpp>
+#include <vulkan/utility/vk_struct_helper.hpp>
+
+#include <cstring>
+
+namespace vku {
+
+safe_VkRenderingFragmentDensityMapAttachmentInfoEXT::safe_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+    const VkRenderingFragmentDensityMapAttachmentInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), imageView(in_struct->imageView), imageLayout(in_struct->imageLayout) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkRenderingFragmentDensityMapAttachmentInfoEXT::safe_VkRenderingFragmentDensityMapAttachmentInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT), pNext(nullptr), imageView(), imageLayout() {}
+
+safe_VkRenderingFragmentDensityMapAttachmentInfoEXT::safe_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+    const safe_VkRenderingFragmentDensityMapAttachmentInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    imageView = copy_src.imageView;
+    imageLayout = copy_src.imageLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkRenderingFragmentDensityMapAttachmentInfoEXT& safe_VkRenderingFragmentDensityMapAttachmentInfoEXT::operator=(
+    const safe_VkRenderingFragmentDensityMapAttachmentInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    imageView = copy_src.imageView;
+    imageLayout = copy_src.imageLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkRenderingFragmentDensityMapAttachmentInfoEXT::~safe_VkRenderingFragmentDensityMapAttachmentInfoEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkRenderingFragmentDensityMapAttachmentInfoEXT::initialize(
+    const VkRenderingFragmentDensityMapAttachmentInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    imageView = in_struct->imageView;
+    imageLayout = in_struct->imageLayout;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkRenderingFragmentDensityMapAttachmentInfoEXT::initialize(
+    const safe_VkRenderingFragmentDensityMapAttachmentInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imageView = copy_src->imageView;
+    imageLayout = copy_src->imageLayout;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSetDescriptorBufferOffsetsInfoEXT::safe_VkSetDescriptorBufferOffsetsInfoEXT(
+    const VkSetDescriptorBufferOffsetsInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      stageFlags(in_struct->stageFlags),
+      layout(in_struct->layout),
+      firstSet(in_struct->firstSet),
+      setCount(in_struct->setCount),
+      pBufferIndices(nullptr),
+      pOffsets(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pBufferIndices) {
+        pBufferIndices = new uint32_t[in_struct->setCount];
+        memcpy((void*)pBufferIndices, (void*)in_struct->pBufferIndices, sizeof(uint32_t) * in_struct->setCount);
+    }
+
+    if (in_struct->pOffsets) {
+        pOffsets = new VkDeviceSize[in_struct->setCount];
+        memcpy((void*)pOffsets, (void*)in_struct->pOffsets, sizeof(VkDeviceSize) * in_struct->setCount);
+    }
+}
+
+safe_VkSetDescriptorBufferOffsetsInfoEXT::safe_VkSetDescriptorBufferOffsetsInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT),
+      pNext(nullptr),
+      stageFlags(),
+      layout(),
+      firstSet(),
+      setCount(),
+      pBufferIndices(nullptr),
+      pOffsets(nullptr) {}
+
+safe_VkSetDescriptorBufferOffsetsInfoEXT::safe_VkSetDescriptorBufferOffsetsInfoEXT(
+    const safe_VkSetDescriptorBufferOffsetsInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    stageFlags = copy_src.stageFlags;
+    layout = copy_src.layout;
+    firstSet = copy_src.firstSet;
+    setCount = copy_src.setCount;
+    pBufferIndices = nullptr;
+    pOffsets = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pBufferIndices) {
+        pBufferIndices = new uint32_t[copy_src.setCount];
+        memcpy((void*)pBufferIndices, (void*)copy_src.pBufferIndices, sizeof(uint32_t) * copy_src.setCount);
+    }
+
+    if (copy_src.pOffsets) {
+        pOffsets = new VkDeviceSize[copy_src.setCount];
+        memcpy((void*)pOffsets, (void*)copy_src.pOffsets, sizeof(VkDeviceSize) * copy_src.setCount);
+    }
+}
+
+safe_VkSetDescriptorBufferOffsetsInfoEXT& safe_VkSetDescriptorBufferOffsetsInfoEXT::operator=(
+    const safe_VkSetDescriptorBufferOffsetsInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pBufferIndices) delete[] pBufferIndices;
+    if (pOffsets) delete[] pOffsets;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    stageFlags = copy_src.stageFlags;
+    layout = copy_src.layout;
+    firstSet = copy_src.firstSet;
+    setCount = copy_src.setCount;
+    pBufferIndices = nullptr;
+    pOffsets = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pBufferIndices) {
+        pBufferIndices = new uint32_t[copy_src.setCount];
+        memcpy((void*)pBufferIndices, (void*)copy_src.pBufferIndices, sizeof(uint32_t) * copy_src.setCount);
+    }
+
+    if (copy_src.pOffsets) {
+        pOffsets = new VkDeviceSize[copy_src.setCount];
+        memcpy((void*)pOffsets, (void*)copy_src.pOffsets, sizeof(VkDeviceSize) * copy_src.setCount);
+    }
+
+    return *this;
+}
+
+safe_VkSetDescriptorBufferOffsetsInfoEXT::~safe_VkSetDescriptorBufferOffsetsInfoEXT() {
+    if (pBufferIndices) delete[] pBufferIndices;
+    if (pOffsets) delete[] pOffsets;
+    FreePnextChain(pNext);
+}
+
+void safe_VkSetDescriptorBufferOffsetsInfoEXT::initialize(const VkSetDescriptorBufferOffsetsInfoEXT* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pBufferIndices) delete[] pBufferIndices;
+    if (pOffsets) delete[] pOffsets;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    stageFlags = in_struct->stageFlags;
+    layout = in_struct->layout;
+    firstSet = in_struct->firstSet;
+    setCount = in_struct->setCount;
+    pBufferIndices = nullptr;
+    pOffsets = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pBufferIndices) {
+        pBufferIndices = new uint32_t[in_struct->setCount];
+        memcpy((void*)pBufferIndices, (void*)in_struct->pBufferIndices, sizeof(uint32_t) * in_struct->setCount);
+    }
+
+    if (in_struct->pOffsets) {
+        pOffsets = new VkDeviceSize[in_struct->setCount];
+        memcpy((void*)pOffsets, (void*)in_struct->pOffsets, sizeof(VkDeviceSize) * in_struct->setCount);
+    }
+}
+
+void safe_VkSetDescriptorBufferOffsetsInfoEXT::initialize(const safe_VkSetDescriptorBufferOffsetsInfoEXT* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stageFlags = copy_src->stageFlags;
+    layout = copy_src->layout;
+    firstSet = copy_src->firstSet;
+    setCount = copy_src->setCount;
+    pBufferIndices = nullptr;
+    pOffsets = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pBufferIndices) {
+        pBufferIndices = new uint32_t[copy_src->setCount];
+        memcpy((void*)pBufferIndices, (void*)copy_src->pBufferIndices, sizeof(uint32_t) * copy_src->setCount);
+    }
+
+    if (copy_src->pOffsets) {
+        pOffsets = new VkDeviceSize[copy_src->setCount];
+        memcpy((void*)pOffsets, (void*)copy_src->pOffsets, sizeof(VkDeviceSize) * copy_src->setCount);
+    }
+}
+
+safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT::safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT(
+    const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), stageFlags(in_struct->stageFlags), layout(in_struct->layout), set(in_struct->set) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT::safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT), pNext(nullptr), stageFlags(), layout(), set() {}
+
+safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT::safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT(
+    const safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    stageFlags = copy_src.stageFlags;
+    layout = copy_src.layout;
+    set = copy_src.set;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT& safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT::operator=(
+    const safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    stageFlags = copy_src.stageFlags;
+    layout = copy_src.layout;
+    set = copy_src.set;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT::~safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT::initialize(const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    stageFlags = in_struct->stageFlags;
+    layout = in_struct->layout;
+    set = in_struct->set;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT::initialize(
+    const safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stageFlags = copy_src->stageFlags;
+    layout = copy_src->layout;
+    set = copy_src->set;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDebugReportCallbackCreateInfoEXT::safe_VkDebugReportCallbackCreateInfoEXT(
+    const VkDebugReportCallbackCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags), pfnCallback(in_struct->pfnCallback), pUserData(in_struct->pUserData) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDebugReportCallbackCreateInfoEXT::safe_VkDebugReportCallbackCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT), pNext(nullptr), flags(), pfnCallback(), pUserData(nullptr) {}
+
+safe_VkDebugReportCallbackCreateInfoEXT::safe_VkDebugReportCallbackCreateInfoEXT(
+    const safe_VkDebugReportCallbackCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pfnCallback = copy_src.pfnCallback;
+    pUserData = copy_src.pUserData;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDebugReportCallbackCreateInfoEXT& safe_VkDebugReportCallbackCreateInfoEXT::operator=(
+    const safe_VkDebugReportCallbackCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pfnCallback = copy_src.pfnCallback;
+    pUserData = copy_src.pUserData;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDebugReportCallbackCreateInfoEXT::~safe_VkDebugReportCallbackCreateInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkDebugReportCallbackCreateInfoEXT::initialize(const VkDebugReportCallbackCreateInfoEXT* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    pfnCallback = in_struct->pfnCallback;
+    pUserData = in_struct->pUserData;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDebugReportCallbackCreateInfoEXT::initialize(const safe_VkDebugReportCallbackCreateInfoEXT* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pfnCallback = copy_src->pfnCallback;
+    pUserData = copy_src->pUserData;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDebugMarkerObjectNameInfoEXT::safe_VkDebugMarkerObjectNameInfoEXT(const VkDebugMarkerObjectNameInfoEXT* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType), objectType(in_struct->objectType), object(in_struct->object) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    pObjectName = SafeStringCopy(in_struct->pObjectName);
+}
+
+safe_VkDebugMarkerObjectNameInfoEXT::safe_VkDebugMarkerObjectNameInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT), pNext(nullptr), objectType(), object(), pObjectName(nullptr) {}
+
+safe_VkDebugMarkerObjectNameInfoEXT::safe_VkDebugMarkerObjectNameInfoEXT(const safe_VkDebugMarkerObjectNameInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    objectType = copy_src.objectType;
+    object = copy_src.object;
+    pNext = SafePnextCopy(copy_src.pNext);
+    pObjectName = SafeStringCopy(copy_src.pObjectName);
+}
+
+safe_VkDebugMarkerObjectNameInfoEXT& safe_VkDebugMarkerObjectNameInfoEXT::operator=(
+    const safe_VkDebugMarkerObjectNameInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pObjectName) delete[] pObjectName;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    objectType = copy_src.objectType;
+    object = copy_src.object;
+    pNext = SafePnextCopy(copy_src.pNext);
+    pObjectName = SafeStringCopy(copy_src.pObjectName);
+
+    return *this;
+}
+
+safe_VkDebugMarkerObjectNameInfoEXT::~safe_VkDebugMarkerObjectNameInfoEXT() {
+    if (pObjectName) delete[] pObjectName;
+    FreePnextChain(pNext);
+}
+
+void safe_VkDebugMarkerObjectNameInfoEXT::initialize(const VkDebugMarkerObjectNameInfoEXT* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pObjectName) delete[] pObjectName;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    objectType = in_struct->objectType;
+    object = in_struct->object;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    pObjectName = SafeStringCopy(in_struct->pObjectName);
+}
+
+void safe_VkDebugMarkerObjectNameInfoEXT::initialize(const safe_VkDebugMarkerObjectNameInfoEXT* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    objectType = copy_src->objectType;
+    object = copy_src->object;
+    pNext = SafePnextCopy(copy_src->pNext);
+    pObjectName = SafeStringCopy(copy_src->pObjectName);
+}
+
+safe_VkDebugMarkerObjectTagInfoEXT::safe_VkDebugMarkerObjectTagInfoEXT(const VkDebugMarkerObjectTagInfoEXT* in_struct,
+                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      objectType(in_struct->objectType),
+      object(in_struct->object),
+      tagName(in_struct->tagName),
+      tagSize(in_struct->tagSize),
+      pTag(in_struct->pTag) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDebugMarkerObjectTagInfoEXT::safe_VkDebugMarkerObjectTagInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT),
+      pNext(nullptr),
+      objectType(),
+      object(),
+      tagName(),
+      tagSize(),
+      pTag(nullptr) {}
+
+safe_VkDebugMarkerObjectTagInfoEXT::safe_VkDebugMarkerObjectTagInfoEXT(const safe_VkDebugMarkerObjectTagInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    objectType = copy_src.objectType;
+    object = copy_src.object;
+    tagName = copy_src.tagName;
+    tagSize = copy_src.tagSize;
+    pTag = copy_src.pTag;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDebugMarkerObjectTagInfoEXT& safe_VkDebugMarkerObjectTagInfoEXT::operator=(
+    const safe_VkDebugMarkerObjectTagInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    objectType = copy_src.objectType;
+    object = copy_src.object;
+    tagName = copy_src.tagName;
+    tagSize = copy_src.tagSize;
+    pTag = copy_src.pTag;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDebugMarkerObjectTagInfoEXT::~safe_VkDebugMarkerObjectTagInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkDebugMarkerObjectTagInfoEXT::initialize(const VkDebugMarkerObjectTagInfoEXT* in_struct,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    objectType = in_struct->objectType;
+    object = in_struct->object;
+    tagName = in_struct->tagName;
+    tagSize = in_struct->tagSize;
+    pTag = in_struct->pTag;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDebugMarkerObjectTagInfoEXT::initialize(const safe_VkDebugMarkerObjectTagInfoEXT* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    objectType = copy_src->objectType;
+    object = copy_src->object;
+    tagName = copy_src->tagName;
+    tagSize = copy_src->tagSize;
+    pTag = copy_src->pTag;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDebugMarkerMarkerInfoEXT::safe_VkDebugMarkerMarkerInfoEXT(const VkDebugMarkerMarkerInfoEXT* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    pMarkerName = SafeStringCopy(in_struct->pMarkerName);
+
+    for (uint32_t i = 0; i < 4; ++i) {
+        color[i] = in_struct->color[i];
+    }
+}
+
+safe_VkDebugMarkerMarkerInfoEXT::safe_VkDebugMarkerMarkerInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT), pNext(nullptr), pMarkerName(nullptr) {}
+
+safe_VkDebugMarkerMarkerInfoEXT::safe_VkDebugMarkerMarkerInfoEXT(const safe_VkDebugMarkerMarkerInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+    pMarkerName = SafeStringCopy(copy_src.pMarkerName);
+
+    for (uint32_t i = 0; i < 4; ++i) {
+        color[i] = copy_src.color[i];
+    }
+}
+
+safe_VkDebugMarkerMarkerInfoEXT& safe_VkDebugMarkerMarkerInfoEXT::operator=(const safe_VkDebugMarkerMarkerInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pMarkerName) delete[] pMarkerName;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+    pMarkerName = SafeStringCopy(copy_src.pMarkerName);
+
+    for (uint32_t i = 0; i < 4; ++i) {
+        color[i] = copy_src.color[i];
+    }
+
+    return *this;
+}
+
+safe_VkDebugMarkerMarkerInfoEXT::~safe_VkDebugMarkerMarkerInfoEXT() {
+    if (pMarkerName) delete[] pMarkerName;
+    FreePnextChain(pNext);
+}
+
+void safe_VkDebugMarkerMarkerInfoEXT::initialize(const VkDebugMarkerMarkerInfoEXT* in_struct,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pMarkerName) delete[] pMarkerName;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    pMarkerName = SafeStringCopy(in_struct->pMarkerName);
+
+    for (uint32_t i = 0; i < 4; ++i) {
+        color[i] = in_struct->color[i];
+    }
+}
+
+void safe_VkDebugMarkerMarkerInfoEXT::initialize(const safe_VkDebugMarkerMarkerInfoEXT* copy_src,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pNext = SafePnextCopy(copy_src->pNext);
+    pMarkerName = SafeStringCopy(copy_src->pMarkerName);
+
+    for (uint32_t i = 0; i < 4; ++i) {
+        color[i] = copy_src->color[i];
+    }
+}
+
+safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT::safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
+    const VkPhysicalDeviceTransformFeedbackFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), transformFeedback(in_struct->transformFeedback), geometryStreams(in_struct->geometryStreams) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT::safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT),
+      pNext(nullptr),
+      transformFeedback(),
+      geometryStreams() {}
+
+safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT::safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
+    const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    transformFeedback = copy_src.transformFeedback;
+    geometryStreams = copy_src.geometryStreams;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT& safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    transformFeedback = copy_src.transformFeedback;
+    geometryStreams = copy_src.geometryStreams;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT::~safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT::initialize(const VkPhysicalDeviceTransformFeedbackFeaturesEXT* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    transformFeedback = in_struct->transformFeedback;
+    geometryStreams = in_struct->geometryStreams;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    transformFeedback = copy_src->transformFeedback;
+    geometryStreams = copy_src->geometryStreams;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
+    const VkPhysicalDeviceTransformFeedbackPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      maxTransformFeedbackStreams(in_struct->maxTransformFeedbackStreams),
+      maxTransformFeedbackBuffers(in_struct->maxTransformFeedbackBuffers),
+      maxTransformFeedbackBufferSize(in_struct->maxTransformFeedbackBufferSize),
+      maxTransformFeedbackStreamDataSize(in_struct->maxTransformFeedbackStreamDataSize),
+      maxTransformFeedbackBufferDataSize(in_struct->maxTransformFeedbackBufferDataSize),
+      maxTransformFeedbackBufferDataStride(in_struct->maxTransformFeedbackBufferDataStride),
+      transformFeedbackQueries(in_struct->transformFeedbackQueries),
+      transformFeedbackStreamsLinesTriangles(in_struct->transformFeedbackStreamsLinesTriangles),
+      transformFeedbackRasterizationStreamSelect(in_struct->transformFeedbackRasterizationStreamSelect),
+      transformFeedbackDraw(in_struct->transformFeedbackDraw) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT),
+      pNext(nullptr),
+      maxTransformFeedbackStreams(),
+      maxTransformFeedbackBuffers(),
+      maxTransformFeedbackBufferSize(),
+      maxTransformFeedbackStreamDataSize(),
+      maxTransformFeedbackBufferDataSize(),
+      maxTransformFeedbackBufferDataStride(),
+      transformFeedbackQueries(),
+      transformFeedbackStreamsLinesTriangles(),
+      transformFeedbackRasterizationStreamSelect(),
+      transformFeedbackDraw() {}
+
+safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
+    const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    maxTransformFeedbackStreams = copy_src.maxTransformFeedbackStreams;
+    maxTransformFeedbackBuffers = copy_src.maxTransformFeedbackBuffers;
+    maxTransformFeedbackBufferSize = copy_src.maxTransformFeedbackBufferSize;
+    maxTransformFeedbackStreamDataSize = copy_src.maxTransformFeedbackStreamDataSize;
+    maxTransformFeedbackBufferDataSize = copy_src.maxTransformFeedbackBufferDataSize;
+    maxTransformFeedbackBufferDataStride = copy_src.maxTransformFeedbackBufferDataStride;
+    transformFeedbackQueries = copy_src.transformFeedbackQueries;
+    transformFeedbackStreamsLinesTriangles = copy_src.transformFeedbackStreamsLinesTriangles;
+    transformFeedbackRasterizationStreamSelect = copy_src.transformFeedbackRasterizationStreamSelect;
+    transformFeedbackDraw = copy_src.transformFeedbackDraw;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT& safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::operator=(
+    const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxTransformFeedbackStreams = copy_src.maxTransformFeedbackStreams;
+    maxTransformFeedbackBuffers = copy_src.maxTransformFeedbackBuffers;
+    maxTransformFeedbackBufferSize = copy_src.maxTransformFeedbackBufferSize;
+    maxTransformFeedbackStreamDataSize = copy_src.maxTransformFeedbackStreamDataSize;
+    maxTransformFeedbackBufferDataSize = copy_src.maxTransformFeedbackBufferDataSize;
+    maxTransformFeedbackBufferDataStride = copy_src.maxTransformFeedbackBufferDataStride;
+    transformFeedbackQueries = copy_src.transformFeedbackQueries;
+    transformFeedbackStreamsLinesTriangles = copy_src.transformFeedbackStreamsLinesTriangles;
+    transformFeedbackRasterizationStreamSelect = copy_src.transformFeedbackRasterizationStreamSelect;
+    transformFeedbackDraw = copy_src.transformFeedbackDraw;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::~safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::initialize(
+    const VkPhysicalDeviceTransformFeedbackPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxTransformFeedbackStreams = in_struct->maxTransformFeedbackStreams;
+    maxTransformFeedbackBuffers = in_struct->maxTransformFeedbackBuffers;
+    maxTransformFeedbackBufferSize = in_struct->maxTransformFeedbackBufferSize;
+    maxTransformFeedbackStreamDataSize = in_struct->maxTransformFeedbackStreamDataSize;
+    maxTransformFeedbackBufferDataSize = in_struct->maxTransformFeedbackBufferDataSize;
+    maxTransformFeedbackBufferDataStride = in_struct->maxTransformFeedbackBufferDataStride;
+    transformFeedbackQueries = in_struct->transformFeedbackQueries;
+    transformFeedbackStreamsLinesTriangles = in_struct->transformFeedbackStreamsLinesTriangles;
+    transformFeedbackRasterizationStreamSelect = in_struct->transformFeedbackRasterizationStreamSelect;
+    transformFeedbackDraw = in_struct->transformFeedbackDraw;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::initialize(
+    const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxTransformFeedbackStreams = copy_src->maxTransformFeedbackStreams;
+    maxTransformFeedbackBuffers = copy_src->maxTransformFeedbackBuffers;
+    maxTransformFeedbackBufferSize = copy_src->maxTransformFeedbackBufferSize;
+    maxTransformFeedbackStreamDataSize = copy_src->maxTransformFeedbackStreamDataSize;
+    maxTransformFeedbackBufferDataSize = copy_src->maxTransformFeedbackBufferDataSize;
+    maxTransformFeedbackBufferDataStride = copy_src->maxTransformFeedbackBufferDataStride;
+    transformFeedbackQueries = copy_src->transformFeedbackQueries;
+    transformFeedbackStreamsLinesTriangles = copy_src->transformFeedbackStreamsLinesTriangles;
+    transformFeedbackRasterizationStreamSelect = copy_src->transformFeedbackRasterizationStreamSelect;
+    transformFeedbackDraw = copy_src->transformFeedbackDraw;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineRasterizationStateStreamCreateInfoEXT::safe_VkPipelineRasterizationStateStreamCreateInfoEXT(
+    const VkPipelineRasterizationStateStreamCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags), rasterizationStream(in_struct->rasterizationStream) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPipelineRasterizationStateStreamCreateInfoEXT::safe_VkPipelineRasterizationStateStreamCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT),
+      pNext(nullptr),
+      flags(),
+      rasterizationStream() {}
+
+safe_VkPipelineRasterizationStateStreamCreateInfoEXT::safe_VkPipelineRasterizationStateStreamCreateInfoEXT(
+    const safe_VkPipelineRasterizationStateStreamCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    rasterizationStream = copy_src.rasterizationStream;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPipelineRasterizationStateStreamCreateInfoEXT& safe_VkPipelineRasterizationStateStreamCreateInfoEXT::operator=(
+    const safe_VkPipelineRasterizationStateStreamCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    rasterizationStream = copy_src.rasterizationStream;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineRasterizationStateStreamCreateInfoEXT::~safe_VkPipelineRasterizationStateStreamCreateInfoEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineRasterizationStateStreamCreateInfoEXT::initialize(
+    const VkPipelineRasterizationStateStreamCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    rasterizationStream = in_struct->rasterizationStream;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPipelineRasterizationStateStreamCreateInfoEXT::initialize(
+    const safe_VkPipelineRasterizationStateStreamCreateInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    rasterizationStream = copy_src->rasterizationStream;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkValidationFlagsEXT::safe_VkValidationFlagsEXT(const VkValidationFlagsEXT* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      disabledValidationCheckCount(in_struct->disabledValidationCheckCount),
+      pDisabledValidationChecks(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pDisabledValidationChecks) {
+        pDisabledValidationChecks = new VkValidationCheckEXT[in_struct->disabledValidationCheckCount];
+        memcpy((void*)pDisabledValidationChecks, (void*)in_struct->pDisabledValidationChecks,
+               sizeof(VkValidationCheckEXT) * in_struct->disabledValidationCheckCount);
+    }
+}
+
+safe_VkValidationFlagsEXT::safe_VkValidationFlagsEXT()
+    : sType(VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT),
+      pNext(nullptr),
+      disabledValidationCheckCount(),
+      pDisabledValidationChecks(nullptr) {}
+
+safe_VkValidationFlagsEXT::safe_VkValidationFlagsEXT(const safe_VkValidationFlagsEXT& copy_src) {
+    sType = copy_src.sType;
+    disabledValidationCheckCount = copy_src.disabledValidationCheckCount;
+    pDisabledValidationChecks = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDisabledValidationChecks) {
+        pDisabledValidationChecks = new VkValidationCheckEXT[copy_src.disabledValidationCheckCount];
+        memcpy((void*)pDisabledValidationChecks, (void*)copy_src.pDisabledValidationChecks,
+               sizeof(VkValidationCheckEXT) * copy_src.disabledValidationCheckCount);
+    }
+}
+
+safe_VkValidationFlagsEXT& safe_VkValidationFlagsEXT::operator=(const safe_VkValidationFlagsEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pDisabledValidationChecks) delete[] pDisabledValidationChecks;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    disabledValidationCheckCount = copy_src.disabledValidationCheckCount;
+    pDisabledValidationChecks = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDisabledValidationChecks) {
+        pDisabledValidationChecks = new VkValidationCheckEXT[copy_src.disabledValidationCheckCount];
+        memcpy((void*)pDisabledValidationChecks, (void*)copy_src.pDisabledValidationChecks,
+               sizeof(VkValidationCheckEXT) * copy_src.disabledValidationCheckCount);
+    }
+
+    return *this;
+}
+
+safe_VkValidationFlagsEXT::~safe_VkValidationFlagsEXT() {
+    if (pDisabledValidationChecks) delete[] pDisabledValidationChecks;
+    FreePnextChain(pNext);
+}
+
+void safe_VkValidationFlagsEXT::initialize(const VkValidationFlagsEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pDisabledValidationChecks) delete[] pDisabledValidationChecks;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    disabledValidationCheckCount = in_struct->disabledValidationCheckCount;
+    pDisabledValidationChecks = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pDisabledValidationChecks) {
+        pDisabledValidationChecks = new VkValidationCheckEXT[in_struct->disabledValidationCheckCount];
+        memcpy((void*)pDisabledValidationChecks, (void*)in_struct->pDisabledValidationChecks,
+               sizeof(VkValidationCheckEXT) * in_struct->disabledValidationCheckCount);
+    }
+}
+
+void safe_VkValidationFlagsEXT::initialize(const safe_VkValidationFlagsEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    disabledValidationCheckCount = copy_src->disabledValidationCheckCount;
+    pDisabledValidationChecks = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pDisabledValidationChecks) {
+        pDisabledValidationChecks = new VkValidationCheckEXT[copy_src->disabledValidationCheckCount];
+        memcpy((void*)pDisabledValidationChecks, (void*)copy_src->pDisabledValidationChecks,
+               sizeof(VkValidationCheckEXT) * copy_src->disabledValidationCheckCount);
+    }
+}
+
+safe_VkImageViewASTCDecodeModeEXT::safe_VkImageViewASTCDecodeModeEXT(const VkImageViewASTCDecodeModeEXT* in_struct,
+                                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), decodeMode(in_struct->decodeMode) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImageViewASTCDecodeModeEXT::safe_VkImageViewASTCDecodeModeEXT()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT), pNext(nullptr), decodeMode() {}
+
+safe_VkImageViewASTCDecodeModeEXT::safe_VkImageViewASTCDecodeModeEXT(const safe_VkImageViewASTCDecodeModeEXT& copy_src) {
+    sType = copy_src.sType;
+    decodeMode = copy_src.decodeMode;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImageViewASTCDecodeModeEXT& safe_VkImageViewASTCDecodeModeEXT::operator=(const safe_VkImageViewASTCDecodeModeEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    decodeMode = copy_src.decodeMode;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImageViewASTCDecodeModeEXT::~safe_VkImageViewASTCDecodeModeEXT() { FreePnextChain(pNext); }
+
+void safe_VkImageViewASTCDecodeModeEXT::initialize(const VkImageViewASTCDecodeModeEXT* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    decodeMode = in_struct->decodeMode;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImageViewASTCDecodeModeEXT::initialize(const safe_VkImageViewASTCDecodeModeEXT* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    decodeMode = copy_src->decodeMode;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceASTCDecodeFeaturesEXT::safe_VkPhysicalDeviceASTCDecodeFeaturesEXT(
+    const VkPhysicalDeviceASTCDecodeFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), decodeModeSharedExponent(in_struct->decodeModeSharedExponent) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceASTCDecodeFeaturesEXT::safe_VkPhysicalDeviceASTCDecodeFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT), pNext(nullptr), decodeModeSharedExponent() {}
+
+safe_VkPhysicalDeviceASTCDecodeFeaturesEXT::safe_VkPhysicalDeviceASTCDecodeFeaturesEXT(
+    const safe_VkPhysicalDeviceASTCDecodeFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    decodeModeSharedExponent = copy_src.decodeModeSharedExponent;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceASTCDecodeFeaturesEXT& safe_VkPhysicalDeviceASTCDecodeFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceASTCDecodeFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    decodeModeSharedExponent = copy_src.decodeModeSharedExponent;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceASTCDecodeFeaturesEXT::~safe_VkPhysicalDeviceASTCDecodeFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceASTCDecodeFeaturesEXT::initialize(const VkPhysicalDeviceASTCDecodeFeaturesEXT* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    decodeModeSharedExponent = in_struct->decodeModeSharedExponent;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceASTCDecodeFeaturesEXT::initialize(const safe_VkPhysicalDeviceASTCDecodeFeaturesEXT* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    decodeModeSharedExponent = copy_src->decodeModeSharedExponent;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT::safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
+    const VkPhysicalDevicePipelineRobustnessFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), pipelineRobustness(in_struct->pipelineRobustness) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT::safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT), pNext(nullptr), pipelineRobustness() {}
+
+safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT::safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
+    const safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    pipelineRobustness = copy_src.pipelineRobustness;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT& safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT::operator=(
+    const safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pipelineRobustness = copy_src.pipelineRobustness;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT::~safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT::initialize(const VkPhysicalDevicePipelineRobustnessFeaturesEXT* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pipelineRobustness = in_struct->pipelineRobustness;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT::initialize(
+    const safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pipelineRobustness = copy_src->pipelineRobustness;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT::safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
+    const VkPhysicalDevicePipelineRobustnessPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      defaultRobustnessStorageBuffers(in_struct->defaultRobustnessStorageBuffers),
+      defaultRobustnessUniformBuffers(in_struct->defaultRobustnessUniformBuffers),
+      defaultRobustnessVertexInputs(in_struct->defaultRobustnessVertexInputs),
+      defaultRobustnessImages(in_struct->defaultRobustnessImages) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT::safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT),
+      pNext(nullptr),
+      defaultRobustnessStorageBuffers(),
+      defaultRobustnessUniformBuffers(),
+      defaultRobustnessVertexInputs(),
+      defaultRobustnessImages() {}
+
+safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT::safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
+    const safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    defaultRobustnessStorageBuffers = copy_src.defaultRobustnessStorageBuffers;
+    defaultRobustnessUniformBuffers = copy_src.defaultRobustnessUniformBuffers;
+    defaultRobustnessVertexInputs = copy_src.defaultRobustnessVertexInputs;
+    defaultRobustnessImages = copy_src.defaultRobustnessImages;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT& safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT::operator=(
+    const safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    defaultRobustnessStorageBuffers = copy_src.defaultRobustnessStorageBuffers;
+    defaultRobustnessUniformBuffers = copy_src.defaultRobustnessUniformBuffers;
+    defaultRobustnessVertexInputs = copy_src.defaultRobustnessVertexInputs;
+    defaultRobustnessImages = copy_src.defaultRobustnessImages;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT::~safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT::initialize(
+    const VkPhysicalDevicePipelineRobustnessPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    defaultRobustnessStorageBuffers = in_struct->defaultRobustnessStorageBuffers;
+    defaultRobustnessUniformBuffers = in_struct->defaultRobustnessUniformBuffers;
+    defaultRobustnessVertexInputs = in_struct->defaultRobustnessVertexInputs;
+    defaultRobustnessImages = in_struct->defaultRobustnessImages;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT::initialize(
+    const safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    defaultRobustnessStorageBuffers = copy_src->defaultRobustnessStorageBuffers;
+    defaultRobustnessUniformBuffers = copy_src->defaultRobustnessUniformBuffers;
+    defaultRobustnessVertexInputs = copy_src->defaultRobustnessVertexInputs;
+    defaultRobustnessImages = copy_src->defaultRobustnessImages;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineRobustnessCreateInfoEXT::safe_VkPipelineRobustnessCreateInfoEXT(const VkPipelineRobustnessCreateInfoEXT* in_struct,
+                                                                               [[maybe_unused]] PNextCopyState* copy_state,
+                                                                               bool copy_pnext)
+    : sType(in_struct->sType),
+      storageBuffers(in_struct->storageBuffers),
+      uniformBuffers(in_struct->uniformBuffers),
+      vertexInputs(in_struct->vertexInputs),
+      images(in_struct->images) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPipelineRobustnessCreateInfoEXT::safe_VkPipelineRobustnessCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT),
+      pNext(nullptr),
+      storageBuffers(),
+      uniformBuffers(),
+      vertexInputs(),
+      images() {}
+
+safe_VkPipelineRobustnessCreateInfoEXT::safe_VkPipelineRobustnessCreateInfoEXT(
+    const safe_VkPipelineRobustnessCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    storageBuffers = copy_src.storageBuffers;
+    uniformBuffers = copy_src.uniformBuffers;
+    vertexInputs = copy_src.vertexInputs;
+    images = copy_src.images;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPipelineRobustnessCreateInfoEXT& safe_VkPipelineRobustnessCreateInfoEXT::operator=(
+    const safe_VkPipelineRobustnessCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    storageBuffers = copy_src.storageBuffers;
+    uniformBuffers = copy_src.uniformBuffers;
+    vertexInputs = copy_src.vertexInputs;
+    images = copy_src.images;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineRobustnessCreateInfoEXT::~safe_VkPipelineRobustnessCreateInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkPipelineRobustnessCreateInfoEXT::initialize(const VkPipelineRobustnessCreateInfoEXT* in_struct,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    storageBuffers = in_struct->storageBuffers;
+    uniformBuffers = in_struct->uniformBuffers;
+    vertexInputs = in_struct->vertexInputs;
+    images = in_struct->images;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPipelineRobustnessCreateInfoEXT::initialize(const safe_VkPipelineRobustnessCreateInfoEXT* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    storageBuffers = copy_src->storageBuffers;
+    uniformBuffers = copy_src->uniformBuffers;
+    vertexInputs = copy_src->vertexInputs;
+    images = copy_src->images;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkConditionalRenderingBeginInfoEXT::safe_VkConditionalRenderingBeginInfoEXT(
+    const VkConditionalRenderingBeginInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), buffer(in_struct->buffer), offset(in_struct->offset), flags(in_struct->flags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkConditionalRenderingBeginInfoEXT::safe_VkConditionalRenderingBeginInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT), pNext(nullptr), buffer(), offset(), flags() {}
+
+safe_VkConditionalRenderingBeginInfoEXT::safe_VkConditionalRenderingBeginInfoEXT(
+    const safe_VkConditionalRenderingBeginInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    buffer = copy_src.buffer;
+    offset = copy_src.offset;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkConditionalRenderingBeginInfoEXT& safe_VkConditionalRenderingBeginInfoEXT::operator=(
+    const safe_VkConditionalRenderingBeginInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    buffer = copy_src.buffer;
+    offset = copy_src.offset;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkConditionalRenderingBeginInfoEXT::~safe_VkConditionalRenderingBeginInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkConditionalRenderingBeginInfoEXT::initialize(const VkConditionalRenderingBeginInfoEXT* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    buffer = in_struct->buffer;
+    offset = in_struct->offset;
+    flags = in_struct->flags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkConditionalRenderingBeginInfoEXT::initialize(const safe_VkConditionalRenderingBeginInfoEXT* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    buffer = copy_src->buffer;
+    offset = copy_src->offset;
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT::safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
+    const VkPhysicalDeviceConditionalRenderingFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      conditionalRendering(in_struct->conditionalRendering),
+      inheritedConditionalRendering(in_struct->inheritedConditionalRendering) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT::safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT),
+      pNext(nullptr),
+      conditionalRendering(),
+      inheritedConditionalRendering() {}
+
+safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT::safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
+    const safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    conditionalRendering = copy_src.conditionalRendering;
+    inheritedConditionalRendering = copy_src.inheritedConditionalRendering;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT& safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    conditionalRendering = copy_src.conditionalRendering;
+    inheritedConditionalRendering = copy_src.inheritedConditionalRendering;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT::~safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT::initialize(
+    const VkPhysicalDeviceConditionalRenderingFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    conditionalRendering = in_struct->conditionalRendering;
+    inheritedConditionalRendering = in_struct->inheritedConditionalRendering;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    conditionalRendering = copy_src->conditionalRendering;
+    inheritedConditionalRendering = copy_src->inheritedConditionalRendering;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT::safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
+    const VkCommandBufferInheritanceConditionalRenderingInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), conditionalRenderingEnable(in_struct->conditionalRenderingEnable) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT::safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT),
+      pNext(nullptr),
+      conditionalRenderingEnable() {}
+
+safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT::safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
+    const safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    conditionalRenderingEnable = copy_src.conditionalRenderingEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT& safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT::operator=(
+    const safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    conditionalRenderingEnable = copy_src.conditionalRenderingEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT::~safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT::initialize(
+    const VkCommandBufferInheritanceConditionalRenderingInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    conditionalRenderingEnable = in_struct->conditionalRenderingEnable;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT::initialize(
+    const safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    conditionalRenderingEnable = copy_src->conditionalRenderingEnable;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSurfaceCapabilities2EXT::safe_VkSurfaceCapabilities2EXT(const VkSurfaceCapabilities2EXT* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      minImageCount(in_struct->minImageCount),
+      maxImageCount(in_struct->maxImageCount),
+      currentExtent(in_struct->currentExtent),
+      minImageExtent(in_struct->minImageExtent),
+      maxImageExtent(in_struct->maxImageExtent),
+      maxImageArrayLayers(in_struct->maxImageArrayLayers),
+      supportedTransforms(in_struct->supportedTransforms),
+      currentTransform(in_struct->currentTransform),
+      supportedCompositeAlpha(in_struct->supportedCompositeAlpha),
+      supportedUsageFlags(in_struct->supportedUsageFlags),
+      supportedSurfaceCounters(in_struct->supportedSurfaceCounters) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSurfaceCapabilities2EXT::safe_VkSurfaceCapabilities2EXT()
+    : sType(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT),
+      pNext(nullptr),
+      minImageCount(),
+      maxImageCount(),
+      currentExtent(),
+      minImageExtent(),
+      maxImageExtent(),
+      maxImageArrayLayers(),
+      supportedTransforms(),
+      currentTransform(),
+      supportedCompositeAlpha(),
+      supportedUsageFlags(),
+      supportedSurfaceCounters() {}
+
+safe_VkSurfaceCapabilities2EXT::safe_VkSurfaceCapabilities2EXT(const safe_VkSurfaceCapabilities2EXT& copy_src) {
+    sType = copy_src.sType;
+    minImageCount = copy_src.minImageCount;
+    maxImageCount = copy_src.maxImageCount;
+    currentExtent = copy_src.currentExtent;
+    minImageExtent = copy_src.minImageExtent;
+    maxImageExtent = copy_src.maxImageExtent;
+    maxImageArrayLayers = copy_src.maxImageArrayLayers;
+    supportedTransforms = copy_src.supportedTransforms;
+    currentTransform = copy_src.currentTransform;
+    supportedCompositeAlpha = copy_src.supportedCompositeAlpha;
+    supportedUsageFlags = copy_src.supportedUsageFlags;
+    supportedSurfaceCounters = copy_src.supportedSurfaceCounters;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSurfaceCapabilities2EXT& safe_VkSurfaceCapabilities2EXT::operator=(const safe_VkSurfaceCapabilities2EXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    minImageCount = copy_src.minImageCount;
+    maxImageCount = copy_src.maxImageCount;
+    currentExtent = copy_src.currentExtent;
+    minImageExtent = copy_src.minImageExtent;
+    maxImageExtent = copy_src.maxImageExtent;
+    maxImageArrayLayers = copy_src.maxImageArrayLayers;
+    supportedTransforms = copy_src.supportedTransforms;
+    currentTransform = copy_src.currentTransform;
+    supportedCompositeAlpha = copy_src.supportedCompositeAlpha;
+    supportedUsageFlags = copy_src.supportedUsageFlags;
+    supportedSurfaceCounters = copy_src.supportedSurfaceCounters;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSurfaceCapabilities2EXT::~safe_VkSurfaceCapabilities2EXT() { FreePnextChain(pNext); }
+
+void safe_VkSurfaceCapabilities2EXT::initialize(const VkSurfaceCapabilities2EXT* in_struct,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    minImageCount = in_struct->minImageCount;
+    maxImageCount = in_struct->maxImageCount;
+    currentExtent = in_struct->currentExtent;
+    minImageExtent = in_struct->minImageExtent;
+    maxImageExtent = in_struct->maxImageExtent;
+    maxImageArrayLayers = in_struct->maxImageArrayLayers;
+    supportedTransforms = in_struct->supportedTransforms;
+    currentTransform = in_struct->currentTransform;
+    supportedCompositeAlpha = in_struct->supportedCompositeAlpha;
+    supportedUsageFlags = in_struct->supportedUsageFlags;
+    supportedSurfaceCounters = in_struct->supportedSurfaceCounters;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSurfaceCapabilities2EXT::initialize(const safe_VkSurfaceCapabilities2EXT* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    minImageCount = copy_src->minImageCount;
+    maxImageCount = copy_src->maxImageCount;
+    currentExtent = copy_src->currentExtent;
+    minImageExtent = copy_src->minImageExtent;
+    maxImageExtent = copy_src->maxImageExtent;
+    maxImageArrayLayers = copy_src->maxImageArrayLayers;
+    supportedTransforms = copy_src->supportedTransforms;
+    currentTransform = copy_src->currentTransform;
+    supportedCompositeAlpha = copy_src->supportedCompositeAlpha;
+    supportedUsageFlags = copy_src->supportedUsageFlags;
+    supportedSurfaceCounters = copy_src->supportedSurfaceCounters;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDisplayPowerInfoEXT::safe_VkDisplayPowerInfoEXT(const VkDisplayPowerInfoEXT* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), powerState(in_struct->powerState) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDisplayPowerInfoEXT::safe_VkDisplayPowerInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT), pNext(nullptr), powerState() {}
+
+safe_VkDisplayPowerInfoEXT::safe_VkDisplayPowerInfoEXT(const safe_VkDisplayPowerInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    powerState = copy_src.powerState;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDisplayPowerInfoEXT& safe_VkDisplayPowerInfoEXT::operator=(const safe_VkDisplayPowerInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    powerState = copy_src.powerState;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDisplayPowerInfoEXT::~safe_VkDisplayPowerInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkDisplayPowerInfoEXT::initialize(const VkDisplayPowerInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    powerState = in_struct->powerState;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDisplayPowerInfoEXT::initialize(const safe_VkDisplayPowerInfoEXT* copy_src,
+                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    powerState = copy_src->powerState;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDeviceEventInfoEXT::safe_VkDeviceEventInfoEXT(const VkDeviceEventInfoEXT* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), deviceEvent(in_struct->deviceEvent) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDeviceEventInfoEXT::safe_VkDeviceEventInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT), pNext(nullptr), deviceEvent() {}
+
+safe_VkDeviceEventInfoEXT::safe_VkDeviceEventInfoEXT(const safe_VkDeviceEventInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    deviceEvent = copy_src.deviceEvent;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDeviceEventInfoEXT& safe_VkDeviceEventInfoEXT::operator=(const safe_VkDeviceEventInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    deviceEvent = copy_src.deviceEvent;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDeviceEventInfoEXT::~safe_VkDeviceEventInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkDeviceEventInfoEXT::initialize(const VkDeviceEventInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    deviceEvent = in_struct->deviceEvent;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDeviceEventInfoEXT::initialize(const safe_VkDeviceEventInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    deviceEvent = copy_src->deviceEvent;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDisplayEventInfoEXT::safe_VkDisplayEventInfoEXT(const VkDisplayEventInfoEXT* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), displayEvent(in_struct->displayEvent) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDisplayEventInfoEXT::safe_VkDisplayEventInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT), pNext(nullptr), displayEvent() {}
+
+safe_VkDisplayEventInfoEXT::safe_VkDisplayEventInfoEXT(const safe_VkDisplayEventInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    displayEvent = copy_src.displayEvent;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDisplayEventInfoEXT& safe_VkDisplayEventInfoEXT::operator=(const safe_VkDisplayEventInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    displayEvent = copy_src.displayEvent;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDisplayEventInfoEXT::~safe_VkDisplayEventInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkDisplayEventInfoEXT::initialize(const VkDisplayEventInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    displayEvent = in_struct->displayEvent;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDisplayEventInfoEXT::initialize(const safe_VkDisplayEventInfoEXT* copy_src,
+                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    displayEvent = copy_src->displayEvent;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSwapchainCounterCreateInfoEXT::safe_VkSwapchainCounterCreateInfoEXT(const VkSwapchainCounterCreateInfoEXT* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), surfaceCounters(in_struct->surfaceCounters) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSwapchainCounterCreateInfoEXT::safe_VkSwapchainCounterCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT), pNext(nullptr), surfaceCounters() {}
+
+safe_VkSwapchainCounterCreateInfoEXT::safe_VkSwapchainCounterCreateInfoEXT(const safe_VkSwapchainCounterCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    surfaceCounters = copy_src.surfaceCounters;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSwapchainCounterCreateInfoEXT& safe_VkSwapchainCounterCreateInfoEXT::operator=(
+    const safe_VkSwapchainCounterCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    surfaceCounters = copy_src.surfaceCounters;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSwapchainCounterCreateInfoEXT::~safe_VkSwapchainCounterCreateInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkSwapchainCounterCreateInfoEXT::initialize(const VkSwapchainCounterCreateInfoEXT* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    surfaceCounters = in_struct->surfaceCounters;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSwapchainCounterCreateInfoEXT::initialize(const safe_VkSwapchainCounterCreateInfoEXT* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    surfaceCounters = copy_src->surfaceCounters;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
+    const VkPhysicalDeviceDiscardRectanglePropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), maxDiscardRectangles(in_struct->maxDiscardRectangles) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT), pNext(nullptr), maxDiscardRectangles() {}
+
+safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
+    const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    maxDiscardRectangles = copy_src.maxDiscardRectangles;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT& safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::operator=(
+    const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxDiscardRectangles = copy_src.maxDiscardRectangles;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::~safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::initialize(const VkPhysicalDeviceDiscardRectanglePropertiesEXT* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxDiscardRectangles = in_struct->maxDiscardRectangles;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::initialize(
+    const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxDiscardRectangles = copy_src->maxDiscardRectangles;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineDiscardRectangleStateCreateInfoEXT::safe_VkPipelineDiscardRectangleStateCreateInfoEXT(
+    const VkPipelineDiscardRectangleStateCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      discardRectangleMode(in_struct->discardRectangleMode),
+      discardRectangleCount(in_struct->discardRectangleCount),
+      pDiscardRectangles(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pDiscardRectangles) {
+        pDiscardRectangles = new VkRect2D[in_struct->discardRectangleCount];
+        memcpy((void*)pDiscardRectangles, (void*)in_struct->pDiscardRectangles,
+               sizeof(VkRect2D) * in_struct->discardRectangleCount);
+    }
+}
+
+safe_VkPipelineDiscardRectangleStateCreateInfoEXT::safe_VkPipelineDiscardRectangleStateCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT),
+      pNext(nullptr),
+      flags(),
+      discardRectangleMode(),
+      discardRectangleCount(),
+      pDiscardRectangles(nullptr) {}
+
+safe_VkPipelineDiscardRectangleStateCreateInfoEXT::safe_VkPipelineDiscardRectangleStateCreateInfoEXT(
+    const safe_VkPipelineDiscardRectangleStateCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    discardRectangleMode = copy_src.discardRectangleMode;
+    discardRectangleCount = copy_src.discardRectangleCount;
+    pDiscardRectangles = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDiscardRectangles) {
+        pDiscardRectangles = new VkRect2D[copy_src.discardRectangleCount];
+        memcpy((void*)pDiscardRectangles, (void*)copy_src.pDiscardRectangles, sizeof(VkRect2D) * copy_src.discardRectangleCount);
+    }
+}
+
+safe_VkPipelineDiscardRectangleStateCreateInfoEXT& safe_VkPipelineDiscardRectangleStateCreateInfoEXT::operator=(
+    const safe_VkPipelineDiscardRectangleStateCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pDiscardRectangles) delete[] pDiscardRectangles;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    discardRectangleMode = copy_src.discardRectangleMode;
+    discardRectangleCount = copy_src.discardRectangleCount;
+    pDiscardRectangles = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDiscardRectangles) {
+        pDiscardRectangles = new VkRect2D[copy_src.discardRectangleCount];
+        memcpy((void*)pDiscardRectangles, (void*)copy_src.pDiscardRectangles, sizeof(VkRect2D) * copy_src.discardRectangleCount);
+    }
+
+    return *this;
+}
+
+safe_VkPipelineDiscardRectangleStateCreateInfoEXT::~safe_VkPipelineDiscardRectangleStateCreateInfoEXT() {
+    if (pDiscardRectangles) delete[] pDiscardRectangles;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineDiscardRectangleStateCreateInfoEXT::initialize(const VkPipelineDiscardRectangleStateCreateInfoEXT* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pDiscardRectangles) delete[] pDiscardRectangles;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    discardRectangleMode = in_struct->discardRectangleMode;
+    discardRectangleCount = in_struct->discardRectangleCount;
+    pDiscardRectangles = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pDiscardRectangles) {
+        pDiscardRectangles = new VkRect2D[in_struct->discardRectangleCount];
+        memcpy((void*)pDiscardRectangles, (void*)in_struct->pDiscardRectangles,
+               sizeof(VkRect2D) * in_struct->discardRectangleCount);
+    }
+}
+
+void safe_VkPipelineDiscardRectangleStateCreateInfoEXT::initialize(
+    const safe_VkPipelineDiscardRectangleStateCreateInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    discardRectangleMode = copy_src->discardRectangleMode;
+    discardRectangleCount = copy_src->discardRectangleCount;
+    pDiscardRectangles = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pDiscardRectangles) {
+        pDiscardRectangles = new VkRect2D[copy_src->discardRectangleCount];
+        memcpy((void*)pDiscardRectangles, (void*)copy_src->pDiscardRectangles, sizeof(VkRect2D) * copy_src->discardRectangleCount);
+    }
+}
+
+safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
+    const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      primitiveOverestimationSize(in_struct->primitiveOverestimationSize),
+      maxExtraPrimitiveOverestimationSize(in_struct->maxExtraPrimitiveOverestimationSize),
+      extraPrimitiveOverestimationSizeGranularity(in_struct->extraPrimitiveOverestimationSizeGranularity),
+      primitiveUnderestimation(in_struct->primitiveUnderestimation),
+      conservativePointAndLineRasterization(in_struct->conservativePointAndLineRasterization),
+      degenerateTrianglesRasterized(in_struct->degenerateTrianglesRasterized),
+      degenerateLinesRasterized(in_struct->degenerateLinesRasterized),
+      fullyCoveredFragmentShaderInputVariable(in_struct->fullyCoveredFragmentShaderInputVariable),
+      conservativeRasterizationPostDepthCoverage(in_struct->conservativeRasterizationPostDepthCoverage) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT),
+      pNext(nullptr),
+      primitiveOverestimationSize(),
+      maxExtraPrimitiveOverestimationSize(),
+      extraPrimitiveOverestimationSizeGranularity(),
+      primitiveUnderestimation(),
+      conservativePointAndLineRasterization(),
+      degenerateTrianglesRasterized(),
+      degenerateLinesRasterized(),
+      fullyCoveredFragmentShaderInputVariable(),
+      conservativeRasterizationPostDepthCoverage() {}
+
+safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
+    const safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    primitiveOverestimationSize = copy_src.primitiveOverestimationSize;
+    maxExtraPrimitiveOverestimationSize = copy_src.maxExtraPrimitiveOverestimationSize;
+    extraPrimitiveOverestimationSizeGranularity = copy_src.extraPrimitiveOverestimationSizeGranularity;
+    primitiveUnderestimation = copy_src.primitiveUnderestimation;
+    conservativePointAndLineRasterization = copy_src.conservativePointAndLineRasterization;
+    degenerateTrianglesRasterized = copy_src.degenerateTrianglesRasterized;
+    degenerateLinesRasterized = copy_src.degenerateLinesRasterized;
+    fullyCoveredFragmentShaderInputVariable = copy_src.fullyCoveredFragmentShaderInputVariable;
+    conservativeRasterizationPostDepthCoverage = copy_src.conservativeRasterizationPostDepthCoverage;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT& safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::operator=(
+    const safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    primitiveOverestimationSize = copy_src.primitiveOverestimationSize;
+    maxExtraPrimitiveOverestimationSize = copy_src.maxExtraPrimitiveOverestimationSize;
+    extraPrimitiveOverestimationSizeGranularity = copy_src.extraPrimitiveOverestimationSizeGranularity;
+    primitiveUnderestimation = copy_src.primitiveUnderestimation;
+    conservativePointAndLineRasterization = copy_src.conservativePointAndLineRasterization;
+    degenerateTrianglesRasterized = copy_src.degenerateTrianglesRasterized;
+    degenerateLinesRasterized = copy_src.degenerateLinesRasterized;
+    fullyCoveredFragmentShaderInputVariable = copy_src.fullyCoveredFragmentShaderInputVariable;
+    conservativeRasterizationPostDepthCoverage = copy_src.conservativeRasterizationPostDepthCoverage;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::~safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::initialize(
+    const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    primitiveOverestimationSize = in_struct->primitiveOverestimationSize;
+    maxExtraPrimitiveOverestimationSize = in_struct->maxExtraPrimitiveOverestimationSize;
+    extraPrimitiveOverestimationSizeGranularity = in_struct->extraPrimitiveOverestimationSizeGranularity;
+    primitiveUnderestimation = in_struct->primitiveUnderestimation;
+    conservativePointAndLineRasterization = in_struct->conservativePointAndLineRasterization;
+    degenerateTrianglesRasterized = in_struct->degenerateTrianglesRasterized;
+    degenerateLinesRasterized = in_struct->degenerateLinesRasterized;
+    fullyCoveredFragmentShaderInputVariable = in_struct->fullyCoveredFragmentShaderInputVariable;
+    conservativeRasterizationPostDepthCoverage = in_struct->conservativeRasterizationPostDepthCoverage;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::initialize(
+    const safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    primitiveOverestimationSize = copy_src->primitiveOverestimationSize;
+    maxExtraPrimitiveOverestimationSize = copy_src->maxExtraPrimitiveOverestimationSize;
+    extraPrimitiveOverestimationSizeGranularity = copy_src->extraPrimitiveOverestimationSizeGranularity;
+    primitiveUnderestimation = copy_src->primitiveUnderestimation;
+    conservativePointAndLineRasterization = copy_src->conservativePointAndLineRasterization;
+    degenerateTrianglesRasterized = copy_src->degenerateTrianglesRasterized;
+    degenerateLinesRasterized = copy_src->degenerateLinesRasterized;
+    fullyCoveredFragmentShaderInputVariable = copy_src->fullyCoveredFragmentShaderInputVariable;
+    conservativeRasterizationPostDepthCoverage = copy_src->conservativeRasterizationPostDepthCoverage;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineRasterizationConservativeStateCreateInfoEXT::safe_VkPipelineRasterizationConservativeStateCreateInfoEXT(
+    const VkPipelineRasterizationConservativeStateCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      conservativeRasterizationMode(in_struct->conservativeRasterizationMode),
+      extraPrimitiveOverestimationSize(in_struct->extraPrimitiveOverestimationSize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPipelineRasterizationConservativeStateCreateInfoEXT::safe_VkPipelineRasterizationConservativeStateCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT),
+      pNext(nullptr),
+      flags(),
+      conservativeRasterizationMode(),
+      extraPrimitiveOverestimationSize() {}
+
+safe_VkPipelineRasterizationConservativeStateCreateInfoEXT::safe_VkPipelineRasterizationConservativeStateCreateInfoEXT(
+    const safe_VkPipelineRasterizationConservativeStateCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    conservativeRasterizationMode = copy_src.conservativeRasterizationMode;
+    extraPrimitiveOverestimationSize = copy_src.extraPrimitiveOverestimationSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPipelineRasterizationConservativeStateCreateInfoEXT& safe_VkPipelineRasterizationConservativeStateCreateInfoEXT::operator=(
+    const safe_VkPipelineRasterizationConservativeStateCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    conservativeRasterizationMode = copy_src.conservativeRasterizationMode;
+    extraPrimitiveOverestimationSize = copy_src.extraPrimitiveOverestimationSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineRasterizationConservativeStateCreateInfoEXT::~safe_VkPipelineRasterizationConservativeStateCreateInfoEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineRasterizationConservativeStateCreateInfoEXT::initialize(
+    const VkPipelineRasterizationConservativeStateCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    conservativeRasterizationMode = in_struct->conservativeRasterizationMode;
+    extraPrimitiveOverestimationSize = in_struct->extraPrimitiveOverestimationSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPipelineRasterizationConservativeStateCreateInfoEXT::initialize(
+    const safe_VkPipelineRasterizationConservativeStateCreateInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    conservativeRasterizationMode = copy_src->conservativeRasterizationMode;
+    extraPrimitiveOverestimationSize = copy_src->extraPrimitiveOverestimationSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT::safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+    const VkPhysicalDeviceDepthClipEnableFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), depthClipEnable(in_struct->depthClipEnable) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT::safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT), pNext(nullptr), depthClipEnable() {}
+
+safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT::safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+    const safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    depthClipEnable = copy_src.depthClipEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT& safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    depthClipEnable = copy_src.depthClipEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT::~safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT::initialize(const VkPhysicalDeviceDepthClipEnableFeaturesEXT* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    depthClipEnable = in_struct->depthClipEnable;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT::initialize(const safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    depthClipEnable = copy_src->depthClipEnable;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT::safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+    const VkPipelineRasterizationDepthClipStateCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags), depthClipEnable(in_struct->depthClipEnable) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT::safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT),
+      pNext(nullptr),
+      flags(),
+      depthClipEnable() {}
+
+safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT::safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+    const safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    depthClipEnable = copy_src.depthClipEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT& safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT::operator=(
+    const safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    depthClipEnable = copy_src.depthClipEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT::~safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT::initialize(
+    const VkPipelineRasterizationDepthClipStateCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    depthClipEnable = in_struct->depthClipEnable;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT::initialize(
+    const safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    depthClipEnable = copy_src->depthClipEnable;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkHdrMetadataEXT::safe_VkHdrMetadataEXT(const VkHdrMetadataEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                             bool copy_pnext)
+    : sType(in_struct->sType),
+      displayPrimaryRed(in_struct->displayPrimaryRed),
+      displayPrimaryGreen(in_struct->displayPrimaryGreen),
+      displayPrimaryBlue(in_struct->displayPrimaryBlue),
+      whitePoint(in_struct->whitePoint),
+      maxLuminance(in_struct->maxLuminance),
+      minLuminance(in_struct->minLuminance),
+      maxContentLightLevel(in_struct->maxContentLightLevel),
+      maxFrameAverageLightLevel(in_struct->maxFrameAverageLightLevel) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkHdrMetadataEXT::safe_VkHdrMetadataEXT()
+    : sType(VK_STRUCTURE_TYPE_HDR_METADATA_EXT),
+      pNext(nullptr),
+      displayPrimaryRed(),
+      displayPrimaryGreen(),
+      displayPrimaryBlue(),
+      whitePoint(),
+      maxLuminance(),
+      minLuminance(),
+      maxContentLightLevel(),
+      maxFrameAverageLightLevel() {}
+
+safe_VkHdrMetadataEXT::safe_VkHdrMetadataEXT(const safe_VkHdrMetadataEXT& copy_src) {
+    sType = copy_src.sType;
+    displayPrimaryRed = copy_src.displayPrimaryRed;
+    displayPrimaryGreen = copy_src.displayPrimaryGreen;
+    displayPrimaryBlue = copy_src.displayPrimaryBlue;
+    whitePoint = copy_src.whitePoint;
+    maxLuminance = copy_src.maxLuminance;
+    minLuminance = copy_src.minLuminance;
+    maxContentLightLevel = copy_src.maxContentLightLevel;
+    maxFrameAverageLightLevel = copy_src.maxFrameAverageLightLevel;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkHdrMetadataEXT& safe_VkHdrMetadataEXT::operator=(const safe_VkHdrMetadataEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    displayPrimaryRed = copy_src.displayPrimaryRed;
+    displayPrimaryGreen = copy_src.displayPrimaryGreen;
+    displayPrimaryBlue = copy_src.displayPrimaryBlue;
+    whitePoint = copy_src.whitePoint;
+    maxLuminance = copy_src.maxLuminance;
+    minLuminance = copy_src.minLuminance;
+    maxContentLightLevel = copy_src.maxContentLightLevel;
+    maxFrameAverageLightLevel = copy_src.maxFrameAverageLightLevel;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkHdrMetadataEXT::~safe_VkHdrMetadataEXT() { FreePnextChain(pNext); }
+
+void safe_VkHdrMetadataEXT::initialize(const VkHdrMetadataEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    displayPrimaryRed = in_struct->displayPrimaryRed;
+    displayPrimaryGreen = in_struct->displayPrimaryGreen;
+    displayPrimaryBlue = in_struct->displayPrimaryBlue;
+    whitePoint = in_struct->whitePoint;
+    maxLuminance = in_struct->maxLuminance;
+    minLuminance = in_struct->minLuminance;
+    maxContentLightLevel = in_struct->maxContentLightLevel;
+    maxFrameAverageLightLevel = in_struct->maxFrameAverageLightLevel;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkHdrMetadataEXT::initialize(const safe_VkHdrMetadataEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    displayPrimaryRed = copy_src->displayPrimaryRed;
+    displayPrimaryGreen = copy_src->displayPrimaryGreen;
+    displayPrimaryBlue = copy_src->displayPrimaryBlue;
+    whitePoint = copy_src->whitePoint;
+    maxLuminance = copy_src->maxLuminance;
+    minLuminance = copy_src->minLuminance;
+    maxContentLightLevel = copy_src->maxContentLightLevel;
+    maxFrameAverageLightLevel = copy_src->maxFrameAverageLightLevel;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDebugUtilsLabelEXT::safe_VkDebugUtilsLabelEXT(const VkDebugUtilsLabelEXT* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    pLabelName = SafeStringCopy(in_struct->pLabelName);
+
+    for (uint32_t i = 0; i < 4; ++i) {
+        color[i] = in_struct->color[i];
+    }
+}
+
+safe_VkDebugUtilsLabelEXT::safe_VkDebugUtilsLabelEXT()
+    : sType(VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT), pNext(nullptr), pLabelName(nullptr) {}
+
+safe_VkDebugUtilsLabelEXT::safe_VkDebugUtilsLabelEXT(const safe_VkDebugUtilsLabelEXT& copy_src) {
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+    pLabelName = SafeStringCopy(copy_src.pLabelName);
+
+    for (uint32_t i = 0; i < 4; ++i) {
+        color[i] = copy_src.color[i];
+    }
+}
+
+safe_VkDebugUtilsLabelEXT& safe_VkDebugUtilsLabelEXT::operator=(const safe_VkDebugUtilsLabelEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pLabelName) delete[] pLabelName;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+    pLabelName = SafeStringCopy(copy_src.pLabelName);
+
+    for (uint32_t i = 0; i < 4; ++i) {
+        color[i] = copy_src.color[i];
+    }
+
+    return *this;
+}
+
+safe_VkDebugUtilsLabelEXT::~safe_VkDebugUtilsLabelEXT() {
+    if (pLabelName) delete[] pLabelName;
+    FreePnextChain(pNext);
+}
+
+void safe_VkDebugUtilsLabelEXT::initialize(const VkDebugUtilsLabelEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pLabelName) delete[] pLabelName;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    pLabelName = SafeStringCopy(in_struct->pLabelName);
+
+    for (uint32_t i = 0; i < 4; ++i) {
+        color[i] = in_struct->color[i];
+    }
+}
+
+void safe_VkDebugUtilsLabelEXT::initialize(const safe_VkDebugUtilsLabelEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pNext = SafePnextCopy(copy_src->pNext);
+    pLabelName = SafeStringCopy(copy_src->pLabelName);
+
+    for (uint32_t i = 0; i < 4; ++i) {
+        color[i] = copy_src->color[i];
+    }
+}
+
+safe_VkDebugUtilsObjectNameInfoEXT::safe_VkDebugUtilsObjectNameInfoEXT(const VkDebugUtilsObjectNameInfoEXT* in_struct,
+                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), objectType(in_struct->objectType), objectHandle(in_struct->objectHandle) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    pObjectName = SafeStringCopy(in_struct->pObjectName);
+}
+
+safe_VkDebugUtilsObjectNameInfoEXT::safe_VkDebugUtilsObjectNameInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT),
+      pNext(nullptr),
+      objectType(),
+      objectHandle(),
+      pObjectName(nullptr) {}
+
+safe_VkDebugUtilsObjectNameInfoEXT::safe_VkDebugUtilsObjectNameInfoEXT(const safe_VkDebugUtilsObjectNameInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    objectType = copy_src.objectType;
+    objectHandle = copy_src.objectHandle;
+    pNext = SafePnextCopy(copy_src.pNext);
+    pObjectName = SafeStringCopy(copy_src.pObjectName);
+}
+
+safe_VkDebugUtilsObjectNameInfoEXT& safe_VkDebugUtilsObjectNameInfoEXT::operator=(
+    const safe_VkDebugUtilsObjectNameInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pObjectName) delete[] pObjectName;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    objectType = copy_src.objectType;
+    objectHandle = copy_src.objectHandle;
+    pNext = SafePnextCopy(copy_src.pNext);
+    pObjectName = SafeStringCopy(copy_src.pObjectName);
+
+    return *this;
+}
+
+safe_VkDebugUtilsObjectNameInfoEXT::~safe_VkDebugUtilsObjectNameInfoEXT() {
+    if (pObjectName) delete[] pObjectName;
+    FreePnextChain(pNext);
+}
+
+void safe_VkDebugUtilsObjectNameInfoEXT::initialize(const VkDebugUtilsObjectNameInfoEXT* in_struct,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pObjectName) delete[] pObjectName;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    objectType = in_struct->objectType;
+    objectHandle = in_struct->objectHandle;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    pObjectName = SafeStringCopy(in_struct->pObjectName);
+}
+
+void safe_VkDebugUtilsObjectNameInfoEXT::initialize(const safe_VkDebugUtilsObjectNameInfoEXT* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    objectType = copy_src->objectType;
+    objectHandle = copy_src->objectHandle;
+    pNext = SafePnextCopy(copy_src->pNext);
+    pObjectName = SafeStringCopy(copy_src->pObjectName);
+}
+
+safe_VkDebugUtilsMessengerCallbackDataEXT::safe_VkDebugUtilsMessengerCallbackDataEXT(
+    const VkDebugUtilsMessengerCallbackDataEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      messageIdNumber(in_struct->messageIdNumber),
+      queueLabelCount(in_struct->queueLabelCount),
+      pQueueLabels(nullptr),
+      cmdBufLabelCount(in_struct->cmdBufLabelCount),
+      pCmdBufLabels(nullptr),
+      objectCount(in_struct->objectCount),
+      pObjects(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    pMessageIdName = SafeStringCopy(in_struct->pMessageIdName);
+    pMessage = SafeStringCopy(in_struct->pMessage);
+    if (queueLabelCount && in_struct->pQueueLabels) {
+        pQueueLabels = new safe_VkDebugUtilsLabelEXT[queueLabelCount];
+        for (uint32_t i = 0; i < queueLabelCount; ++i) {
+            pQueueLabels[i].initialize(&in_struct->pQueueLabels[i]);
+        }
+    }
+    if (cmdBufLabelCount && in_struct->pCmdBufLabels) {
+        pCmdBufLabels = new safe_VkDebugUtilsLabelEXT[cmdBufLabelCount];
+        for (uint32_t i = 0; i < cmdBufLabelCount; ++i) {
+            pCmdBufLabels[i].initialize(&in_struct->pCmdBufLabels[i]);
+        }
+    }
+    if (objectCount && in_struct->pObjects) {
+        pObjects = new safe_VkDebugUtilsObjectNameInfoEXT[objectCount];
+        for (uint32_t i = 0; i < objectCount; ++i) {
+            pObjects[i].initialize(&in_struct->pObjects[i]);
+        }
+    }
+}
+
+safe_VkDebugUtilsMessengerCallbackDataEXT::safe_VkDebugUtilsMessengerCallbackDataEXT()
+    : sType(VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT),
+      pNext(nullptr),
+      flags(),
+      pMessageIdName(nullptr),
+      messageIdNumber(),
+      pMessage(nullptr),
+      queueLabelCount(),
+      pQueueLabels(nullptr),
+      cmdBufLabelCount(),
+      pCmdBufLabels(nullptr),
+      objectCount(),
+      pObjects(nullptr) {}
+
+safe_VkDebugUtilsMessengerCallbackDataEXT::safe_VkDebugUtilsMessengerCallbackDataEXT(
+    const safe_VkDebugUtilsMessengerCallbackDataEXT& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    messageIdNumber = copy_src.messageIdNumber;
+    queueLabelCount = copy_src.queueLabelCount;
+    pQueueLabels = nullptr;
+    cmdBufLabelCount = copy_src.cmdBufLabelCount;
+    pCmdBufLabels = nullptr;
+    objectCount = copy_src.objectCount;
+    pObjects = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    pMessageIdName = SafeStringCopy(copy_src.pMessageIdName);
+    pMessage = SafeStringCopy(copy_src.pMessage);
+    if (queueLabelCount && copy_src.pQueueLabels) {
+        pQueueLabels = new safe_VkDebugUtilsLabelEXT[queueLabelCount];
+        for (uint32_t i = 0; i < queueLabelCount; ++i) {
+            pQueueLabels[i].initialize(&copy_src.pQueueLabels[i]);
+        }
+    }
+    if (cmdBufLabelCount && copy_src.pCmdBufLabels) {
+        pCmdBufLabels = new safe_VkDebugUtilsLabelEXT[cmdBufLabelCount];
+        for (uint32_t i = 0; i < cmdBufLabelCount; ++i) {
+            pCmdBufLabels[i].initialize(&copy_src.pCmdBufLabels[i]);
+        }
+    }
+    if (objectCount && copy_src.pObjects) {
+        pObjects = new safe_VkDebugUtilsObjectNameInfoEXT[objectCount];
+        for (uint32_t i = 0; i < objectCount; ++i) {
+            pObjects[i].initialize(&copy_src.pObjects[i]);
+        }
+    }
+}
+
+safe_VkDebugUtilsMessengerCallbackDataEXT& safe_VkDebugUtilsMessengerCallbackDataEXT::operator=(
+    const safe_VkDebugUtilsMessengerCallbackDataEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pMessageIdName) delete[] pMessageIdName;
+    if (pMessage) delete[] pMessage;
+    if (pQueueLabels) delete[] pQueueLabels;
+    if (pCmdBufLabels) delete[] pCmdBufLabels;
+    if (pObjects) delete[] pObjects;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    messageIdNumber = copy_src.messageIdNumber;
+    queueLabelCount = copy_src.queueLabelCount;
+    pQueueLabels = nullptr;
+    cmdBufLabelCount = copy_src.cmdBufLabelCount;
+    pCmdBufLabels = nullptr;
+    objectCount = copy_src.objectCount;
+    pObjects = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    pMessageIdName = SafeStringCopy(copy_src.pMessageIdName);
+    pMessage = SafeStringCopy(copy_src.pMessage);
+    if (queueLabelCount && copy_src.pQueueLabels) {
+        pQueueLabels = new safe_VkDebugUtilsLabelEXT[queueLabelCount];
+        for (uint32_t i = 0; i < queueLabelCount; ++i) {
+            pQueueLabels[i].initialize(&copy_src.pQueueLabels[i]);
+        }
+    }
+    if (cmdBufLabelCount && copy_src.pCmdBufLabels) {
+        pCmdBufLabels = new safe_VkDebugUtilsLabelEXT[cmdBufLabelCount];
+        for (uint32_t i = 0; i < cmdBufLabelCount; ++i) {
+            pCmdBufLabels[i].initialize(&copy_src.pCmdBufLabels[i]);
+        }
+    }
+    if (objectCount && copy_src.pObjects) {
+        pObjects = new safe_VkDebugUtilsObjectNameInfoEXT[objectCount];
+        for (uint32_t i = 0; i < objectCount; ++i) {
+            pObjects[i].initialize(&copy_src.pObjects[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkDebugUtilsMessengerCallbackDataEXT::~safe_VkDebugUtilsMessengerCallbackDataEXT() {
+    if (pMessageIdName) delete[] pMessageIdName;
+    if (pMessage) delete[] pMessage;
+    if (pQueueLabels) delete[] pQueueLabels;
+    if (pCmdBufLabels) delete[] pCmdBufLabels;
+    if (pObjects) delete[] pObjects;
+    FreePnextChain(pNext);
+}
+
+void safe_VkDebugUtilsMessengerCallbackDataEXT::initialize(const VkDebugUtilsMessengerCallbackDataEXT* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pMessageIdName) delete[] pMessageIdName;
+    if (pMessage) delete[] pMessage;
+    if (pQueueLabels) delete[] pQueueLabels;
+    if (pCmdBufLabels) delete[] pCmdBufLabels;
+    if (pObjects) delete[] pObjects;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    messageIdNumber = in_struct->messageIdNumber;
+    queueLabelCount = in_struct->queueLabelCount;
+    pQueueLabels = nullptr;
+    cmdBufLabelCount = in_struct->cmdBufLabelCount;
+    pCmdBufLabels = nullptr;
+    objectCount = in_struct->objectCount;
+    pObjects = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    pMessageIdName = SafeStringCopy(in_struct->pMessageIdName);
+    pMessage = SafeStringCopy(in_struct->pMessage);
+    if (queueLabelCount && in_struct->pQueueLabels) {
+        pQueueLabels = new safe_VkDebugUtilsLabelEXT[queueLabelCount];
+        for (uint32_t i = 0; i < queueLabelCount; ++i) {
+            pQueueLabels[i].initialize(&in_struct->pQueueLabels[i]);
+        }
+    }
+    if (cmdBufLabelCount && in_struct->pCmdBufLabels) {
+        pCmdBufLabels = new safe_VkDebugUtilsLabelEXT[cmdBufLabelCount];
+        for (uint32_t i = 0; i < cmdBufLabelCount; ++i) {
+            pCmdBufLabels[i].initialize(&in_struct->pCmdBufLabels[i]);
+        }
+    }
+    if (objectCount && in_struct->pObjects) {
+        pObjects = new safe_VkDebugUtilsObjectNameInfoEXT[objectCount];
+        for (uint32_t i = 0; i < objectCount; ++i) {
+            pObjects[i].initialize(&in_struct->pObjects[i]);
+        }
+    }
+}
+
+void safe_VkDebugUtilsMessengerCallbackDataEXT::initialize(const safe_VkDebugUtilsMessengerCallbackDataEXT* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    messageIdNumber = copy_src->messageIdNumber;
+    queueLabelCount = copy_src->queueLabelCount;
+    pQueueLabels = nullptr;
+    cmdBufLabelCount = copy_src->cmdBufLabelCount;
+    pCmdBufLabels = nullptr;
+    objectCount = copy_src->objectCount;
+    pObjects = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    pMessageIdName = SafeStringCopy(copy_src->pMessageIdName);
+    pMessage = SafeStringCopy(copy_src->pMessage);
+    if (queueLabelCount && copy_src->pQueueLabels) {
+        pQueueLabels = new safe_VkDebugUtilsLabelEXT[queueLabelCount];
+        for (uint32_t i = 0; i < queueLabelCount; ++i) {
+            pQueueLabels[i].initialize(&copy_src->pQueueLabels[i]);
+        }
+    }
+    if (cmdBufLabelCount && copy_src->pCmdBufLabels) {
+        pCmdBufLabels = new safe_VkDebugUtilsLabelEXT[cmdBufLabelCount];
+        for (uint32_t i = 0; i < cmdBufLabelCount; ++i) {
+            pCmdBufLabels[i].initialize(&copy_src->pCmdBufLabels[i]);
+        }
+    }
+    if (objectCount && copy_src->pObjects) {
+        pObjects = new safe_VkDebugUtilsObjectNameInfoEXT[objectCount];
+        for (uint32_t i = 0; i < objectCount; ++i) {
+            pObjects[i].initialize(&copy_src->pObjects[i]);
+        }
+    }
+}
+
+safe_VkDebugUtilsMessengerCreateInfoEXT::safe_VkDebugUtilsMessengerCreateInfoEXT(
+    const VkDebugUtilsMessengerCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      messageSeverity(in_struct->messageSeverity),
+      messageType(in_struct->messageType),
+      pfnUserCallback(in_struct->pfnUserCallback),
+      pUserData(in_struct->pUserData) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDebugUtilsMessengerCreateInfoEXT::safe_VkDebugUtilsMessengerCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT),
+      pNext(nullptr),
+      flags(),
+      messageSeverity(),
+      messageType(),
+      pfnUserCallback(),
+      pUserData(nullptr) {}
+
+safe_VkDebugUtilsMessengerCreateInfoEXT::safe_VkDebugUtilsMessengerCreateInfoEXT(
+    const safe_VkDebugUtilsMessengerCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    messageSeverity = copy_src.messageSeverity;
+    messageType = copy_src.messageType;
+    pfnUserCallback = copy_src.pfnUserCallback;
+    pUserData = copy_src.pUserData;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDebugUtilsMessengerCreateInfoEXT& safe_VkDebugUtilsMessengerCreateInfoEXT::operator=(
+    const safe_VkDebugUtilsMessengerCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    messageSeverity = copy_src.messageSeverity;
+    messageType = copy_src.messageType;
+    pfnUserCallback = copy_src.pfnUserCallback;
+    pUserData = copy_src.pUserData;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDebugUtilsMessengerCreateInfoEXT::~safe_VkDebugUtilsMessengerCreateInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkDebugUtilsMessengerCreateInfoEXT::initialize(const VkDebugUtilsMessengerCreateInfoEXT* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    messageSeverity = in_struct->messageSeverity;
+    messageType = in_struct->messageType;
+    pfnUserCallback = in_struct->pfnUserCallback;
+    pUserData = in_struct->pUserData;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDebugUtilsMessengerCreateInfoEXT::initialize(const safe_VkDebugUtilsMessengerCreateInfoEXT* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    messageSeverity = copy_src->messageSeverity;
+    messageType = copy_src->messageType;
+    pfnUserCallback = copy_src->pfnUserCallback;
+    pUserData = copy_src->pUserData;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDebugUtilsObjectTagInfoEXT::safe_VkDebugUtilsObjectTagInfoEXT(const VkDebugUtilsObjectTagInfoEXT* in_struct,
+                                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      objectType(in_struct->objectType),
+      objectHandle(in_struct->objectHandle),
+      tagName(in_struct->tagName),
+      tagSize(in_struct->tagSize),
+      pTag(in_struct->pTag) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDebugUtilsObjectTagInfoEXT::safe_VkDebugUtilsObjectTagInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT),
+      pNext(nullptr),
+      objectType(),
+      objectHandle(),
+      tagName(),
+      tagSize(),
+      pTag(nullptr) {}
+
+safe_VkDebugUtilsObjectTagInfoEXT::safe_VkDebugUtilsObjectTagInfoEXT(const safe_VkDebugUtilsObjectTagInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    objectType = copy_src.objectType;
+    objectHandle = copy_src.objectHandle;
+    tagName = copy_src.tagName;
+    tagSize = copy_src.tagSize;
+    pTag = copy_src.pTag;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDebugUtilsObjectTagInfoEXT& safe_VkDebugUtilsObjectTagInfoEXT::operator=(const safe_VkDebugUtilsObjectTagInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    objectType = copy_src.objectType;
+    objectHandle = copy_src.objectHandle;
+    tagName = copy_src.tagName;
+    tagSize = copy_src.tagSize;
+    pTag = copy_src.pTag;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDebugUtilsObjectTagInfoEXT::~safe_VkDebugUtilsObjectTagInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkDebugUtilsObjectTagInfoEXT::initialize(const VkDebugUtilsObjectTagInfoEXT* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    objectType = in_struct->objectType;
+    objectHandle = in_struct->objectHandle;
+    tagName = in_struct->tagName;
+    tagSize = in_struct->tagSize;
+    pTag = in_struct->pTag;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDebugUtilsObjectTagInfoEXT::initialize(const safe_VkDebugUtilsObjectTagInfoEXT* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    objectType = copy_src->objectType;
+    objectHandle = copy_src->objectHandle;
+    tagName = copy_src->tagName;
+    tagSize = copy_src->tagSize;
+    pTag = copy_src->pTag;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSampleLocationsInfoEXT::safe_VkSampleLocationsInfoEXT(const VkSampleLocationsInfoEXT* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      sampleLocationsPerPixel(in_struct->sampleLocationsPerPixel),
+      sampleLocationGridSize(in_struct->sampleLocationGridSize),
+      sampleLocationsCount(in_struct->sampleLocationsCount),
+      pSampleLocations(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pSampleLocations) {
+        pSampleLocations = new VkSampleLocationEXT[in_struct->sampleLocationsCount];
+        memcpy((void*)pSampleLocations, (void*)in_struct->pSampleLocations,
+               sizeof(VkSampleLocationEXT) * in_struct->sampleLocationsCount);
+    }
+}
+
+safe_VkSampleLocationsInfoEXT::safe_VkSampleLocationsInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT),
+      pNext(nullptr),
+      sampleLocationsPerPixel(),
+      sampleLocationGridSize(),
+      sampleLocationsCount(),
+      pSampleLocations(nullptr) {}
+
+safe_VkSampleLocationsInfoEXT::safe_VkSampleLocationsInfoEXT(const safe_VkSampleLocationsInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    sampleLocationsPerPixel = copy_src.sampleLocationsPerPixel;
+    sampleLocationGridSize = copy_src.sampleLocationGridSize;
+    sampleLocationsCount = copy_src.sampleLocationsCount;
+    pSampleLocations = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pSampleLocations) {
+        pSampleLocations = new VkSampleLocationEXT[copy_src.sampleLocationsCount];
+        memcpy((void*)pSampleLocations, (void*)copy_src.pSampleLocations,
+               sizeof(VkSampleLocationEXT) * copy_src.sampleLocationsCount);
+    }
+}
+
+safe_VkSampleLocationsInfoEXT& safe_VkSampleLocationsInfoEXT::operator=(const safe_VkSampleLocationsInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pSampleLocations) delete[] pSampleLocations;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    sampleLocationsPerPixel = copy_src.sampleLocationsPerPixel;
+    sampleLocationGridSize = copy_src.sampleLocationGridSize;
+    sampleLocationsCount = copy_src.sampleLocationsCount;
+    pSampleLocations = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pSampleLocations) {
+        pSampleLocations = new VkSampleLocationEXT[copy_src.sampleLocationsCount];
+        memcpy((void*)pSampleLocations, (void*)copy_src.pSampleLocations,
+               sizeof(VkSampleLocationEXT) * copy_src.sampleLocationsCount);
+    }
+
+    return *this;
+}
+
+safe_VkSampleLocationsInfoEXT::~safe_VkSampleLocationsInfoEXT() {
+    if (pSampleLocations) delete[] pSampleLocations;
+    FreePnextChain(pNext);
+}
+
+void safe_VkSampleLocationsInfoEXT::initialize(const VkSampleLocationsInfoEXT* in_struct,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pSampleLocations) delete[] pSampleLocations;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    sampleLocationsPerPixel = in_struct->sampleLocationsPerPixel;
+    sampleLocationGridSize = in_struct->sampleLocationGridSize;
+    sampleLocationsCount = in_struct->sampleLocationsCount;
+    pSampleLocations = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pSampleLocations) {
+        pSampleLocations = new VkSampleLocationEXT[in_struct->sampleLocationsCount];
+        memcpy((void*)pSampleLocations, (void*)in_struct->pSampleLocations,
+               sizeof(VkSampleLocationEXT) * in_struct->sampleLocationsCount);
+    }
+}
+
+void safe_VkSampleLocationsInfoEXT::initialize(const safe_VkSampleLocationsInfoEXT* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    sampleLocationsPerPixel = copy_src->sampleLocationsPerPixel;
+    sampleLocationGridSize = copy_src->sampleLocationGridSize;
+    sampleLocationsCount = copy_src->sampleLocationsCount;
+    pSampleLocations = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pSampleLocations) {
+        pSampleLocations = new VkSampleLocationEXT[copy_src->sampleLocationsCount];
+        memcpy((void*)pSampleLocations, (void*)copy_src->pSampleLocations,
+               sizeof(VkSampleLocationEXT) * copy_src->sampleLocationsCount);
+    }
+}
+
+safe_VkRenderPassSampleLocationsBeginInfoEXT::safe_VkRenderPassSampleLocationsBeginInfoEXT(
+    const VkRenderPassSampleLocationsBeginInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      attachmentInitialSampleLocationsCount(in_struct->attachmentInitialSampleLocationsCount),
+      pAttachmentInitialSampleLocations(nullptr),
+      postSubpassSampleLocationsCount(in_struct->postSubpassSampleLocationsCount),
+      pPostSubpassSampleLocations(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pAttachmentInitialSampleLocations) {
+        pAttachmentInitialSampleLocations = new VkAttachmentSampleLocationsEXT[in_struct->attachmentInitialSampleLocationsCount];
+        memcpy((void*)pAttachmentInitialSampleLocations, (void*)in_struct->pAttachmentInitialSampleLocations,
+               sizeof(VkAttachmentSampleLocationsEXT) * in_struct->attachmentInitialSampleLocationsCount);
+    }
+
+    if (in_struct->pPostSubpassSampleLocations) {
+        pPostSubpassSampleLocations = new VkSubpassSampleLocationsEXT[in_struct->postSubpassSampleLocationsCount];
+        memcpy((void*)pPostSubpassSampleLocations, (void*)in_struct->pPostSubpassSampleLocations,
+               sizeof(VkSubpassSampleLocationsEXT) * in_struct->postSubpassSampleLocationsCount);
+    }
+}
+
+safe_VkRenderPassSampleLocationsBeginInfoEXT::safe_VkRenderPassSampleLocationsBeginInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT),
+      pNext(nullptr),
+      attachmentInitialSampleLocationsCount(),
+      pAttachmentInitialSampleLocations(nullptr),
+      postSubpassSampleLocationsCount(),
+      pPostSubpassSampleLocations(nullptr) {}
+
+safe_VkRenderPassSampleLocationsBeginInfoEXT::safe_VkRenderPassSampleLocationsBeginInfoEXT(
+    const safe_VkRenderPassSampleLocationsBeginInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    attachmentInitialSampleLocationsCount = copy_src.attachmentInitialSampleLocationsCount;
+    pAttachmentInitialSampleLocations = nullptr;
+    postSubpassSampleLocationsCount = copy_src.postSubpassSampleLocationsCount;
+    pPostSubpassSampleLocations = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pAttachmentInitialSampleLocations) {
+        pAttachmentInitialSampleLocations = new VkAttachmentSampleLocationsEXT[copy_src.attachmentInitialSampleLocationsCount];
+        memcpy((void*)pAttachmentInitialSampleLocations, (void*)copy_src.pAttachmentInitialSampleLocations,
+               sizeof(VkAttachmentSampleLocationsEXT) * copy_src.attachmentInitialSampleLocationsCount);
+    }
+
+    if (copy_src.pPostSubpassSampleLocations) {
+        pPostSubpassSampleLocations = new VkSubpassSampleLocationsEXT[copy_src.postSubpassSampleLocationsCount];
+        memcpy((void*)pPostSubpassSampleLocations, (void*)copy_src.pPostSubpassSampleLocations,
+               sizeof(VkSubpassSampleLocationsEXT) * copy_src.postSubpassSampleLocationsCount);
+    }
+}
+
+safe_VkRenderPassSampleLocationsBeginInfoEXT& safe_VkRenderPassSampleLocationsBeginInfoEXT::operator=(
+    const safe_VkRenderPassSampleLocationsBeginInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pAttachmentInitialSampleLocations) delete[] pAttachmentInitialSampleLocations;
+    if (pPostSubpassSampleLocations) delete[] pPostSubpassSampleLocations;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    attachmentInitialSampleLocationsCount = copy_src.attachmentInitialSampleLocationsCount;
+    pAttachmentInitialSampleLocations = nullptr;
+    postSubpassSampleLocationsCount = copy_src.postSubpassSampleLocationsCount;
+    pPostSubpassSampleLocations = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pAttachmentInitialSampleLocations) {
+        pAttachmentInitialSampleLocations = new VkAttachmentSampleLocationsEXT[copy_src.attachmentInitialSampleLocationsCount];
+        memcpy((void*)pAttachmentInitialSampleLocations, (void*)copy_src.pAttachmentInitialSampleLocations,
+               sizeof(VkAttachmentSampleLocationsEXT) * copy_src.attachmentInitialSampleLocationsCount);
+    }
+
+    if (copy_src.pPostSubpassSampleLocations) {
+        pPostSubpassSampleLocations = new VkSubpassSampleLocationsEXT[copy_src.postSubpassSampleLocationsCount];
+        memcpy((void*)pPostSubpassSampleLocations, (void*)copy_src.pPostSubpassSampleLocations,
+               sizeof(VkSubpassSampleLocationsEXT) * copy_src.postSubpassSampleLocationsCount);
+    }
+
+    return *this;
+}
+
+safe_VkRenderPassSampleLocationsBeginInfoEXT::~safe_VkRenderPassSampleLocationsBeginInfoEXT() {
+    if (pAttachmentInitialSampleLocations) delete[] pAttachmentInitialSampleLocations;
+    if (pPostSubpassSampleLocations) delete[] pPostSubpassSampleLocations;
+    FreePnextChain(pNext);
+}
+
+void safe_VkRenderPassSampleLocationsBeginInfoEXT::initialize(const VkRenderPassSampleLocationsBeginInfoEXT* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pAttachmentInitialSampleLocations) delete[] pAttachmentInitialSampleLocations;
+    if (pPostSubpassSampleLocations) delete[] pPostSubpassSampleLocations;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    attachmentInitialSampleLocationsCount = in_struct->attachmentInitialSampleLocationsCount;
+    pAttachmentInitialSampleLocations = nullptr;
+    postSubpassSampleLocationsCount = in_struct->postSubpassSampleLocationsCount;
+    pPostSubpassSampleLocations = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pAttachmentInitialSampleLocations) {
+        pAttachmentInitialSampleLocations = new VkAttachmentSampleLocationsEXT[in_struct->attachmentInitialSampleLocationsCount];
+        memcpy((void*)pAttachmentInitialSampleLocations, (void*)in_struct->pAttachmentInitialSampleLocations,
+               sizeof(VkAttachmentSampleLocationsEXT) * in_struct->attachmentInitialSampleLocationsCount);
+    }
+
+    if (in_struct->pPostSubpassSampleLocations) {
+        pPostSubpassSampleLocations = new VkSubpassSampleLocationsEXT[in_struct->postSubpassSampleLocationsCount];
+        memcpy((void*)pPostSubpassSampleLocations, (void*)in_struct->pPostSubpassSampleLocations,
+               sizeof(VkSubpassSampleLocationsEXT) * in_struct->postSubpassSampleLocationsCount);
+    }
+}
+
+void safe_VkRenderPassSampleLocationsBeginInfoEXT::initialize(const safe_VkRenderPassSampleLocationsBeginInfoEXT* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    attachmentInitialSampleLocationsCount = copy_src->attachmentInitialSampleLocationsCount;
+    pAttachmentInitialSampleLocations = nullptr;
+    postSubpassSampleLocationsCount = copy_src->postSubpassSampleLocationsCount;
+    pPostSubpassSampleLocations = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pAttachmentInitialSampleLocations) {
+        pAttachmentInitialSampleLocations = new VkAttachmentSampleLocationsEXT[copy_src->attachmentInitialSampleLocationsCount];
+        memcpy((void*)pAttachmentInitialSampleLocations, (void*)copy_src->pAttachmentInitialSampleLocations,
+               sizeof(VkAttachmentSampleLocationsEXT) * copy_src->attachmentInitialSampleLocationsCount);
+    }
+
+    if (copy_src->pPostSubpassSampleLocations) {
+        pPostSubpassSampleLocations = new VkSubpassSampleLocationsEXT[copy_src->postSubpassSampleLocationsCount];
+        memcpy((void*)pPostSubpassSampleLocations, (void*)copy_src->pPostSubpassSampleLocations,
+               sizeof(VkSubpassSampleLocationsEXT) * copy_src->postSubpassSampleLocationsCount);
+    }
+}
+
+safe_VkPipelineSampleLocationsStateCreateInfoEXT::safe_VkPipelineSampleLocationsStateCreateInfoEXT(
+    const VkPipelineSampleLocationsStateCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      sampleLocationsEnable(in_struct->sampleLocationsEnable),
+      sampleLocationsInfo(&in_struct->sampleLocationsInfo) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPipelineSampleLocationsStateCreateInfoEXT::safe_VkPipelineSampleLocationsStateCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT), pNext(nullptr), sampleLocationsEnable() {}
+
+safe_VkPipelineSampleLocationsStateCreateInfoEXT::safe_VkPipelineSampleLocationsStateCreateInfoEXT(
+    const safe_VkPipelineSampleLocationsStateCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    sampleLocationsEnable = copy_src.sampleLocationsEnable;
+    sampleLocationsInfo.initialize(&copy_src.sampleLocationsInfo);
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPipelineSampleLocationsStateCreateInfoEXT& safe_VkPipelineSampleLocationsStateCreateInfoEXT::operator=(
+    const safe_VkPipelineSampleLocationsStateCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    sampleLocationsEnable = copy_src.sampleLocationsEnable;
+    sampleLocationsInfo.initialize(&copy_src.sampleLocationsInfo);
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineSampleLocationsStateCreateInfoEXT::~safe_VkPipelineSampleLocationsStateCreateInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkPipelineSampleLocationsStateCreateInfoEXT::initialize(const VkPipelineSampleLocationsStateCreateInfoEXT* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    sampleLocationsEnable = in_struct->sampleLocationsEnable;
+    sampleLocationsInfo.initialize(&in_struct->sampleLocationsInfo);
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPipelineSampleLocationsStateCreateInfoEXT::initialize(const safe_VkPipelineSampleLocationsStateCreateInfoEXT* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    sampleLocationsEnable = copy_src->sampleLocationsEnable;
+    sampleLocationsInfo.initialize(&copy_src->sampleLocationsInfo);
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceSampleLocationsPropertiesEXT::safe_VkPhysicalDeviceSampleLocationsPropertiesEXT(
+    const VkPhysicalDeviceSampleLocationsPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      sampleLocationSampleCounts(in_struct->sampleLocationSampleCounts),
+      maxSampleLocationGridSize(in_struct->maxSampleLocationGridSize),
+      sampleLocationSubPixelBits(in_struct->sampleLocationSubPixelBits),
+      variableSampleLocations(in_struct->variableSampleLocations) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    for (uint32_t i = 0; i < 2; ++i) {
+        sampleLocationCoordinateRange[i] = in_struct->sampleLocationCoordinateRange[i];
+    }
+}
+
+safe_VkPhysicalDeviceSampleLocationsPropertiesEXT::safe_VkPhysicalDeviceSampleLocationsPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT),
+      pNext(nullptr),
+      sampleLocationSampleCounts(),
+      maxSampleLocationGridSize(),
+      sampleLocationSubPixelBits(),
+      variableSampleLocations() {}
+
+safe_VkPhysicalDeviceSampleLocationsPropertiesEXT::safe_VkPhysicalDeviceSampleLocationsPropertiesEXT(
+    const safe_VkPhysicalDeviceSampleLocationsPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    sampleLocationSampleCounts = copy_src.sampleLocationSampleCounts;
+    maxSampleLocationGridSize = copy_src.maxSampleLocationGridSize;
+    sampleLocationSubPixelBits = copy_src.sampleLocationSubPixelBits;
+    variableSampleLocations = copy_src.variableSampleLocations;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < 2; ++i) {
+        sampleLocationCoordinateRange[i] = copy_src.sampleLocationCoordinateRange[i];
+    }
+}
+
+safe_VkPhysicalDeviceSampleLocationsPropertiesEXT& safe_VkPhysicalDeviceSampleLocationsPropertiesEXT::operator=(
+    const safe_VkPhysicalDeviceSampleLocationsPropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    sampleLocationSampleCounts = copy_src.sampleLocationSampleCounts;
+    maxSampleLocationGridSize = copy_src.maxSampleLocationGridSize;
+    sampleLocationSubPixelBits = copy_src.sampleLocationSubPixelBits;
+    variableSampleLocations = copy_src.variableSampleLocations;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < 2; ++i) {
+        sampleLocationCoordinateRange[i] = copy_src.sampleLocationCoordinateRange[i];
+    }
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceSampleLocationsPropertiesEXT::~safe_VkPhysicalDeviceSampleLocationsPropertiesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceSampleLocationsPropertiesEXT::initialize(const VkPhysicalDeviceSampleLocationsPropertiesEXT* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    sampleLocationSampleCounts = in_struct->sampleLocationSampleCounts;
+    maxSampleLocationGridSize = in_struct->maxSampleLocationGridSize;
+    sampleLocationSubPixelBits = in_struct->sampleLocationSubPixelBits;
+    variableSampleLocations = in_struct->variableSampleLocations;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    for (uint32_t i = 0; i < 2; ++i) {
+        sampleLocationCoordinateRange[i] = in_struct->sampleLocationCoordinateRange[i];
+    }
+}
+
+void safe_VkPhysicalDeviceSampleLocationsPropertiesEXT::initialize(
+    const safe_VkPhysicalDeviceSampleLocationsPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    sampleLocationSampleCounts = copy_src->sampleLocationSampleCounts;
+    maxSampleLocationGridSize = copy_src->maxSampleLocationGridSize;
+    sampleLocationSubPixelBits = copy_src->sampleLocationSubPixelBits;
+    variableSampleLocations = copy_src->variableSampleLocations;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    for (uint32_t i = 0; i < 2; ++i) {
+        sampleLocationCoordinateRange[i] = copy_src->sampleLocationCoordinateRange[i];
+    }
+}
+
+safe_VkMultisamplePropertiesEXT::safe_VkMultisamplePropertiesEXT(const VkMultisamplePropertiesEXT* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), maxSampleLocationGridSize(in_struct->maxSampleLocationGridSize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMultisamplePropertiesEXT::safe_VkMultisamplePropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT), pNext(nullptr), maxSampleLocationGridSize() {}
+
+safe_VkMultisamplePropertiesEXT::safe_VkMultisamplePropertiesEXT(const safe_VkMultisamplePropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    maxSampleLocationGridSize = copy_src.maxSampleLocationGridSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMultisamplePropertiesEXT& safe_VkMultisamplePropertiesEXT::operator=(const safe_VkMultisamplePropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxSampleLocationGridSize = copy_src.maxSampleLocationGridSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMultisamplePropertiesEXT::~safe_VkMultisamplePropertiesEXT() { FreePnextChain(pNext); }
+
+void safe_VkMultisamplePropertiesEXT::initialize(const VkMultisamplePropertiesEXT* in_struct,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxSampleLocationGridSize = in_struct->maxSampleLocationGridSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMultisamplePropertiesEXT::initialize(const safe_VkMultisamplePropertiesEXT* copy_src,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxSampleLocationGridSize = copy_src->maxSampleLocationGridSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
+    const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), advancedBlendCoherentOperations(in_struct->advancedBlendCoherentOperations) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT),
+      pNext(nullptr),
+      advancedBlendCoherentOperations() {}
+
+safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
+    const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    advancedBlendCoherentOperations = copy_src.advancedBlendCoherentOperations;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    advancedBlendCoherentOperations = copy_src.advancedBlendCoherentOperations;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::~safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::initialize(
+    const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    advancedBlendCoherentOperations = in_struct->advancedBlendCoherentOperations;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    advancedBlendCoherentOperations = copy_src->advancedBlendCoherentOperations;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
+    const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      advancedBlendMaxColorAttachments(in_struct->advancedBlendMaxColorAttachments),
+      advancedBlendIndependentBlend(in_struct->advancedBlendIndependentBlend),
+      advancedBlendNonPremultipliedSrcColor(in_struct->advancedBlendNonPremultipliedSrcColor),
+      advancedBlendNonPremultipliedDstColor(in_struct->advancedBlendNonPremultipliedDstColor),
+      advancedBlendCorrelatedOverlap(in_struct->advancedBlendCorrelatedOverlap),
+      advancedBlendAllOperations(in_struct->advancedBlendAllOperations) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT),
+      pNext(nullptr),
+      advancedBlendMaxColorAttachments(),
+      advancedBlendIndependentBlend(),
+      advancedBlendNonPremultipliedSrcColor(),
+      advancedBlendNonPremultipliedDstColor(),
+      advancedBlendCorrelatedOverlap(),
+      advancedBlendAllOperations() {}
+
+safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
+    const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    advancedBlendMaxColorAttachments = copy_src.advancedBlendMaxColorAttachments;
+    advancedBlendIndependentBlend = copy_src.advancedBlendIndependentBlend;
+    advancedBlendNonPremultipliedSrcColor = copy_src.advancedBlendNonPremultipliedSrcColor;
+    advancedBlendNonPremultipliedDstColor = copy_src.advancedBlendNonPremultipliedDstColor;
+    advancedBlendCorrelatedOverlap = copy_src.advancedBlendCorrelatedOverlap;
+    advancedBlendAllOperations = copy_src.advancedBlendAllOperations;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::operator=(
+    const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    advancedBlendMaxColorAttachments = copy_src.advancedBlendMaxColorAttachments;
+    advancedBlendIndependentBlend = copy_src.advancedBlendIndependentBlend;
+    advancedBlendNonPremultipliedSrcColor = copy_src.advancedBlendNonPremultipliedSrcColor;
+    advancedBlendNonPremultipliedDstColor = copy_src.advancedBlendNonPremultipliedDstColor;
+    advancedBlendCorrelatedOverlap = copy_src.advancedBlendCorrelatedOverlap;
+    advancedBlendAllOperations = copy_src.advancedBlendAllOperations;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::~safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::initialize(
+    const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    advancedBlendMaxColorAttachments = in_struct->advancedBlendMaxColorAttachments;
+    advancedBlendIndependentBlend = in_struct->advancedBlendIndependentBlend;
+    advancedBlendNonPremultipliedSrcColor = in_struct->advancedBlendNonPremultipliedSrcColor;
+    advancedBlendNonPremultipliedDstColor = in_struct->advancedBlendNonPremultipliedDstColor;
+    advancedBlendCorrelatedOverlap = in_struct->advancedBlendCorrelatedOverlap;
+    advancedBlendAllOperations = in_struct->advancedBlendAllOperations;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::initialize(
+    const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    advancedBlendMaxColorAttachments = copy_src->advancedBlendMaxColorAttachments;
+    advancedBlendIndependentBlend = copy_src->advancedBlendIndependentBlend;
+    advancedBlendNonPremultipliedSrcColor = copy_src->advancedBlendNonPremultipliedSrcColor;
+    advancedBlendNonPremultipliedDstColor = copy_src->advancedBlendNonPremultipliedDstColor;
+    advancedBlendCorrelatedOverlap = copy_src->advancedBlendCorrelatedOverlap;
+    advancedBlendAllOperations = copy_src->advancedBlendAllOperations;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
+    const VkPipelineColorBlendAdvancedStateCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      srcPremultiplied(in_struct->srcPremultiplied),
+      dstPremultiplied(in_struct->dstPremultiplied),
+      blendOverlap(in_struct->blendOverlap) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT),
+      pNext(nullptr),
+      srcPremultiplied(),
+      dstPremultiplied(),
+      blendOverlap() {}
+
+safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
+    const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    srcPremultiplied = copy_src.srcPremultiplied;
+    dstPremultiplied = copy_src.dstPremultiplied;
+    blendOverlap = copy_src.blendOverlap;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT& safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::operator=(
+    const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    srcPremultiplied = copy_src.srcPremultiplied;
+    dstPremultiplied = copy_src.dstPremultiplied;
+    blendOverlap = copy_src.blendOverlap;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::~safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::initialize(
+    const VkPipelineColorBlendAdvancedStateCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    srcPremultiplied = in_struct->srcPremultiplied;
+    dstPremultiplied = in_struct->dstPremultiplied;
+    blendOverlap = in_struct->blendOverlap;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::initialize(
+    const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    srcPremultiplied = copy_src->srcPremultiplied;
+    dstPremultiplied = copy_src->dstPremultiplied;
+    blendOverlap = copy_src->blendOverlap;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDrmFormatModifierPropertiesListEXT::safe_VkDrmFormatModifierPropertiesListEXT(
+    const VkDrmFormatModifierPropertiesListEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), drmFormatModifierCount(in_struct->drmFormatModifierCount), pDrmFormatModifierProperties(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pDrmFormatModifierProperties) {
+        pDrmFormatModifierProperties = new VkDrmFormatModifierPropertiesEXT[in_struct->drmFormatModifierCount];
+        memcpy((void*)pDrmFormatModifierProperties, (void*)in_struct->pDrmFormatModifierProperties,
+               sizeof(VkDrmFormatModifierPropertiesEXT) * in_struct->drmFormatModifierCount);
+    }
+}
+
+safe_VkDrmFormatModifierPropertiesListEXT::safe_VkDrmFormatModifierPropertiesListEXT()
+    : sType(VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT),
+      pNext(nullptr),
+      drmFormatModifierCount(),
+      pDrmFormatModifierProperties(nullptr) {}
+
+safe_VkDrmFormatModifierPropertiesListEXT::safe_VkDrmFormatModifierPropertiesListEXT(
+    const safe_VkDrmFormatModifierPropertiesListEXT& copy_src) {
+    sType = copy_src.sType;
+    drmFormatModifierCount = copy_src.drmFormatModifierCount;
+    pDrmFormatModifierProperties = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDrmFormatModifierProperties) {
+        pDrmFormatModifierProperties = new VkDrmFormatModifierPropertiesEXT[copy_src.drmFormatModifierCount];
+        memcpy((void*)pDrmFormatModifierProperties, (void*)copy_src.pDrmFormatModifierProperties,
+               sizeof(VkDrmFormatModifierPropertiesEXT) * copy_src.drmFormatModifierCount);
+    }
+}
+
+safe_VkDrmFormatModifierPropertiesListEXT& safe_VkDrmFormatModifierPropertiesListEXT::operator=(
+    const safe_VkDrmFormatModifierPropertiesListEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pDrmFormatModifierProperties) delete[] pDrmFormatModifierProperties;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    drmFormatModifierCount = copy_src.drmFormatModifierCount;
+    pDrmFormatModifierProperties = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDrmFormatModifierProperties) {
+        pDrmFormatModifierProperties = new VkDrmFormatModifierPropertiesEXT[copy_src.drmFormatModifierCount];
+        memcpy((void*)pDrmFormatModifierProperties, (void*)copy_src.pDrmFormatModifierProperties,
+               sizeof(VkDrmFormatModifierPropertiesEXT) * copy_src.drmFormatModifierCount);
+    }
+
+    return *this;
+}
+
+safe_VkDrmFormatModifierPropertiesListEXT::~safe_VkDrmFormatModifierPropertiesListEXT() {
+    if (pDrmFormatModifierProperties) delete[] pDrmFormatModifierProperties;
+    FreePnextChain(pNext);
+}
+
+void safe_VkDrmFormatModifierPropertiesListEXT::initialize(const VkDrmFormatModifierPropertiesListEXT* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pDrmFormatModifierProperties) delete[] pDrmFormatModifierProperties;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    drmFormatModifierCount = in_struct->drmFormatModifierCount;
+    pDrmFormatModifierProperties = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pDrmFormatModifierProperties) {
+        pDrmFormatModifierProperties = new VkDrmFormatModifierPropertiesEXT[in_struct->drmFormatModifierCount];
+        memcpy((void*)pDrmFormatModifierProperties, (void*)in_struct->pDrmFormatModifierProperties,
+               sizeof(VkDrmFormatModifierPropertiesEXT) * in_struct->drmFormatModifierCount);
+    }
+}
+
+void safe_VkDrmFormatModifierPropertiesListEXT::initialize(const safe_VkDrmFormatModifierPropertiesListEXT* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    drmFormatModifierCount = copy_src->drmFormatModifierCount;
+    pDrmFormatModifierProperties = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pDrmFormatModifierProperties) {
+        pDrmFormatModifierProperties = new VkDrmFormatModifierPropertiesEXT[copy_src->drmFormatModifierCount];
+        memcpy((void*)pDrmFormatModifierProperties, (void*)copy_src->pDrmFormatModifierProperties,
+               sizeof(VkDrmFormatModifierPropertiesEXT) * copy_src->drmFormatModifierCount);
+    }
+}
+
+safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT::safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
+    const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      drmFormatModifier(in_struct->drmFormatModifier),
+      sharingMode(in_struct->sharingMode),
+      queueFamilyIndexCount(0),
+      pQueueFamilyIndices(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if ((in_struct->sharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->pQueueFamilyIndices) {
+        pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
+        memcpy((void*)pQueueFamilyIndices, (void*)in_struct->pQueueFamilyIndices,
+               sizeof(uint32_t) * in_struct->queueFamilyIndexCount);
+        queueFamilyIndexCount = in_struct->queueFamilyIndexCount;
+    } else {
+        queueFamilyIndexCount = 0;
+    }
+}
+
+safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT::safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT),
+      pNext(nullptr),
+      drmFormatModifier(),
+      sharingMode(),
+      queueFamilyIndexCount(),
+      pQueueFamilyIndices(nullptr) {}
+
+safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT::safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
+    const safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    drmFormatModifier = copy_src.drmFormatModifier;
+    sharingMode = copy_src.sharingMode;
+    pQueueFamilyIndices = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if ((copy_src.sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src.pQueueFamilyIndices) {
+        pQueueFamilyIndices = new uint32_t[copy_src.queueFamilyIndexCount];
+        memcpy((void*)pQueueFamilyIndices, (void*)copy_src.pQueueFamilyIndices, sizeof(uint32_t) * copy_src.queueFamilyIndexCount);
+        queueFamilyIndexCount = copy_src.queueFamilyIndexCount;
+    } else {
+        queueFamilyIndexCount = 0;
+    }
+}
+
+safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT& safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT::operator=(
+    const safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pQueueFamilyIndices) delete[] pQueueFamilyIndices;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    drmFormatModifier = copy_src.drmFormatModifier;
+    sharingMode = copy_src.sharingMode;
+    pQueueFamilyIndices = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if ((copy_src.sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src.pQueueFamilyIndices) {
+        pQueueFamilyIndices = new uint32_t[copy_src.queueFamilyIndexCount];
+        memcpy((void*)pQueueFamilyIndices, (void*)copy_src.pQueueFamilyIndices, sizeof(uint32_t) * copy_src.queueFamilyIndexCount);
+        queueFamilyIndexCount = copy_src.queueFamilyIndexCount;
+    } else {
+        queueFamilyIndexCount = 0;
+    }
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT::~safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT() {
+    if (pQueueFamilyIndices) delete[] pQueueFamilyIndices;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT::initialize(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pQueueFamilyIndices) delete[] pQueueFamilyIndices;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    drmFormatModifier = in_struct->drmFormatModifier;
+    sharingMode = in_struct->sharingMode;
+    pQueueFamilyIndices = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if ((in_struct->sharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->pQueueFamilyIndices) {
+        pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
+        memcpy((void*)pQueueFamilyIndices, (void*)in_struct->pQueueFamilyIndices,
+               sizeof(uint32_t) * in_struct->queueFamilyIndexCount);
+        queueFamilyIndexCount = in_struct->queueFamilyIndexCount;
+    } else {
+        queueFamilyIndexCount = 0;
+    }
+}
+
+void safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT::initialize(
+    const safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    drmFormatModifier = copy_src->drmFormatModifier;
+    sharingMode = copy_src->sharingMode;
+    pQueueFamilyIndices = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if ((copy_src->sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src->pQueueFamilyIndices) {
+        pQueueFamilyIndices = new uint32_t[copy_src->queueFamilyIndexCount];
+        memcpy((void*)pQueueFamilyIndices, (void*)copy_src->pQueueFamilyIndices,
+               sizeof(uint32_t) * copy_src->queueFamilyIndexCount);
+        queueFamilyIndexCount = copy_src->queueFamilyIndexCount;
+    } else {
+        queueFamilyIndexCount = 0;
+    }
+}
+
+safe_VkImageDrmFormatModifierListCreateInfoEXT::safe_VkImageDrmFormatModifierListCreateInfoEXT(
+    const VkImageDrmFormatModifierListCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), drmFormatModifierCount(in_struct->drmFormatModifierCount), pDrmFormatModifiers(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pDrmFormatModifiers) {
+        pDrmFormatModifiers = new uint64_t[in_struct->drmFormatModifierCount];
+        memcpy((void*)pDrmFormatModifiers, (void*)in_struct->pDrmFormatModifiers,
+               sizeof(uint64_t) * in_struct->drmFormatModifierCount);
+    }
+}
+
+safe_VkImageDrmFormatModifierListCreateInfoEXT::safe_VkImageDrmFormatModifierListCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT),
+      pNext(nullptr),
+      drmFormatModifierCount(),
+      pDrmFormatModifiers(nullptr) {}
+
+safe_VkImageDrmFormatModifierListCreateInfoEXT::safe_VkImageDrmFormatModifierListCreateInfoEXT(
+    const safe_VkImageDrmFormatModifierListCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    drmFormatModifierCount = copy_src.drmFormatModifierCount;
+    pDrmFormatModifiers = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDrmFormatModifiers) {
+        pDrmFormatModifiers = new uint64_t[copy_src.drmFormatModifierCount];
+        memcpy((void*)pDrmFormatModifiers, (void*)copy_src.pDrmFormatModifiers, sizeof(uint64_t) * copy_src.drmFormatModifierCount);
+    }
+}
+
+safe_VkImageDrmFormatModifierListCreateInfoEXT& safe_VkImageDrmFormatModifierListCreateInfoEXT::operator=(
+    const safe_VkImageDrmFormatModifierListCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pDrmFormatModifiers) delete[] pDrmFormatModifiers;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    drmFormatModifierCount = copy_src.drmFormatModifierCount;
+    pDrmFormatModifiers = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDrmFormatModifiers) {
+        pDrmFormatModifiers = new uint64_t[copy_src.drmFormatModifierCount];
+        memcpy((void*)pDrmFormatModifiers, (void*)copy_src.pDrmFormatModifiers, sizeof(uint64_t) * copy_src.drmFormatModifierCount);
+    }
+
+    return *this;
+}
+
+safe_VkImageDrmFormatModifierListCreateInfoEXT::~safe_VkImageDrmFormatModifierListCreateInfoEXT() {
+    if (pDrmFormatModifiers) delete[] pDrmFormatModifiers;
+    FreePnextChain(pNext);
+}
+
+void safe_VkImageDrmFormatModifierListCreateInfoEXT::initialize(const VkImageDrmFormatModifierListCreateInfoEXT* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pDrmFormatModifiers) delete[] pDrmFormatModifiers;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    drmFormatModifierCount = in_struct->drmFormatModifierCount;
+    pDrmFormatModifiers = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pDrmFormatModifiers) {
+        pDrmFormatModifiers = new uint64_t[in_struct->drmFormatModifierCount];
+        memcpy((void*)pDrmFormatModifiers, (void*)in_struct->pDrmFormatModifiers,
+               sizeof(uint64_t) * in_struct->drmFormatModifierCount);
+    }
+}
+
+void safe_VkImageDrmFormatModifierListCreateInfoEXT::initialize(const safe_VkImageDrmFormatModifierListCreateInfoEXT* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    drmFormatModifierCount = copy_src->drmFormatModifierCount;
+    pDrmFormatModifiers = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pDrmFormatModifiers) {
+        pDrmFormatModifiers = new uint64_t[copy_src->drmFormatModifierCount];
+        memcpy((void*)pDrmFormatModifiers, (void*)copy_src->pDrmFormatModifiers,
+               sizeof(uint64_t) * copy_src->drmFormatModifierCount);
+    }
+}
+
+safe_VkImageDrmFormatModifierExplicitCreateInfoEXT::safe_VkImageDrmFormatModifierExplicitCreateInfoEXT(
+    const VkImageDrmFormatModifierExplicitCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      drmFormatModifier(in_struct->drmFormatModifier),
+      drmFormatModifierPlaneCount(in_struct->drmFormatModifierPlaneCount),
+      pPlaneLayouts(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pPlaneLayouts) {
+        pPlaneLayouts = new VkSubresourceLayout[in_struct->drmFormatModifierPlaneCount];
+        memcpy((void*)pPlaneLayouts, (void*)in_struct->pPlaneLayouts,
+               sizeof(VkSubresourceLayout) * in_struct->drmFormatModifierPlaneCount);
+    }
+}
+
+safe_VkImageDrmFormatModifierExplicitCreateInfoEXT::safe_VkImageDrmFormatModifierExplicitCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT),
+      pNext(nullptr),
+      drmFormatModifier(),
+      drmFormatModifierPlaneCount(),
+      pPlaneLayouts(nullptr) {}
+
+safe_VkImageDrmFormatModifierExplicitCreateInfoEXT::safe_VkImageDrmFormatModifierExplicitCreateInfoEXT(
+    const safe_VkImageDrmFormatModifierExplicitCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    drmFormatModifier = copy_src.drmFormatModifier;
+    drmFormatModifierPlaneCount = copy_src.drmFormatModifierPlaneCount;
+    pPlaneLayouts = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pPlaneLayouts) {
+        pPlaneLayouts = new VkSubresourceLayout[copy_src.drmFormatModifierPlaneCount];
+        memcpy((void*)pPlaneLayouts, (void*)copy_src.pPlaneLayouts,
+               sizeof(VkSubresourceLayout) * copy_src.drmFormatModifierPlaneCount);
+    }
+}
+
+safe_VkImageDrmFormatModifierExplicitCreateInfoEXT& safe_VkImageDrmFormatModifierExplicitCreateInfoEXT::operator=(
+    const safe_VkImageDrmFormatModifierExplicitCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pPlaneLayouts) delete[] pPlaneLayouts;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    drmFormatModifier = copy_src.drmFormatModifier;
+    drmFormatModifierPlaneCount = copy_src.drmFormatModifierPlaneCount;
+    pPlaneLayouts = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pPlaneLayouts) {
+        pPlaneLayouts = new VkSubresourceLayout[copy_src.drmFormatModifierPlaneCount];
+        memcpy((void*)pPlaneLayouts, (void*)copy_src.pPlaneLayouts,
+               sizeof(VkSubresourceLayout) * copy_src.drmFormatModifierPlaneCount);
+    }
+
+    return *this;
+}
+
+safe_VkImageDrmFormatModifierExplicitCreateInfoEXT::~safe_VkImageDrmFormatModifierExplicitCreateInfoEXT() {
+    if (pPlaneLayouts) delete[] pPlaneLayouts;
+    FreePnextChain(pNext);
+}
+
+void safe_VkImageDrmFormatModifierExplicitCreateInfoEXT::initialize(const VkImageDrmFormatModifierExplicitCreateInfoEXT* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pPlaneLayouts) delete[] pPlaneLayouts;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    drmFormatModifier = in_struct->drmFormatModifier;
+    drmFormatModifierPlaneCount = in_struct->drmFormatModifierPlaneCount;
+    pPlaneLayouts = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pPlaneLayouts) {
+        pPlaneLayouts = new VkSubresourceLayout[in_struct->drmFormatModifierPlaneCount];
+        memcpy((void*)pPlaneLayouts, (void*)in_struct->pPlaneLayouts,
+               sizeof(VkSubresourceLayout) * in_struct->drmFormatModifierPlaneCount);
+    }
+}
+
+void safe_VkImageDrmFormatModifierExplicitCreateInfoEXT::initialize(
+    const safe_VkImageDrmFormatModifierExplicitCreateInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    drmFormatModifier = copy_src->drmFormatModifier;
+    drmFormatModifierPlaneCount = copy_src->drmFormatModifierPlaneCount;
+    pPlaneLayouts = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pPlaneLayouts) {
+        pPlaneLayouts = new VkSubresourceLayout[copy_src->drmFormatModifierPlaneCount];
+        memcpy((void*)pPlaneLayouts, (void*)copy_src->pPlaneLayouts,
+               sizeof(VkSubresourceLayout) * copy_src->drmFormatModifierPlaneCount);
+    }
+}
+
+safe_VkImageDrmFormatModifierPropertiesEXT::safe_VkImageDrmFormatModifierPropertiesEXT(
+    const VkImageDrmFormatModifierPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), drmFormatModifier(in_struct->drmFormatModifier) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImageDrmFormatModifierPropertiesEXT::safe_VkImageDrmFormatModifierPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT), pNext(nullptr), drmFormatModifier() {}
+
+safe_VkImageDrmFormatModifierPropertiesEXT::safe_VkImageDrmFormatModifierPropertiesEXT(
+    const safe_VkImageDrmFormatModifierPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    drmFormatModifier = copy_src.drmFormatModifier;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImageDrmFormatModifierPropertiesEXT& safe_VkImageDrmFormatModifierPropertiesEXT::operator=(
+    const safe_VkImageDrmFormatModifierPropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    drmFormatModifier = copy_src.drmFormatModifier;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImageDrmFormatModifierPropertiesEXT::~safe_VkImageDrmFormatModifierPropertiesEXT() { FreePnextChain(pNext); }
+
+void safe_VkImageDrmFormatModifierPropertiesEXT::initialize(const VkImageDrmFormatModifierPropertiesEXT* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    drmFormatModifier = in_struct->drmFormatModifier;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImageDrmFormatModifierPropertiesEXT::initialize(const safe_VkImageDrmFormatModifierPropertiesEXT* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    drmFormatModifier = copy_src->drmFormatModifier;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDrmFormatModifierPropertiesList2EXT::safe_VkDrmFormatModifierPropertiesList2EXT(
+    const VkDrmFormatModifierPropertiesList2EXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), drmFormatModifierCount(in_struct->drmFormatModifierCount), pDrmFormatModifierProperties(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pDrmFormatModifierProperties) {
+        pDrmFormatModifierProperties = new VkDrmFormatModifierProperties2EXT[in_struct->drmFormatModifierCount];
+        memcpy((void*)pDrmFormatModifierProperties, (void*)in_struct->pDrmFormatModifierProperties,
+               sizeof(VkDrmFormatModifierProperties2EXT) * in_struct->drmFormatModifierCount);
+    }
+}
+
+safe_VkDrmFormatModifierPropertiesList2EXT::safe_VkDrmFormatModifierPropertiesList2EXT()
+    : sType(VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT),
+      pNext(nullptr),
+      drmFormatModifierCount(),
+      pDrmFormatModifierProperties(nullptr) {}
+
+safe_VkDrmFormatModifierPropertiesList2EXT::safe_VkDrmFormatModifierPropertiesList2EXT(
+    const safe_VkDrmFormatModifierPropertiesList2EXT& copy_src) {
+    sType = copy_src.sType;
+    drmFormatModifierCount = copy_src.drmFormatModifierCount;
+    pDrmFormatModifierProperties = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDrmFormatModifierProperties) {
+        pDrmFormatModifierProperties = new VkDrmFormatModifierProperties2EXT[copy_src.drmFormatModifierCount];
+        memcpy((void*)pDrmFormatModifierProperties, (void*)copy_src.pDrmFormatModifierProperties,
+               sizeof(VkDrmFormatModifierProperties2EXT) * copy_src.drmFormatModifierCount);
+    }
+}
+
+safe_VkDrmFormatModifierPropertiesList2EXT& safe_VkDrmFormatModifierPropertiesList2EXT::operator=(
+    const safe_VkDrmFormatModifierPropertiesList2EXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pDrmFormatModifierProperties) delete[] pDrmFormatModifierProperties;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    drmFormatModifierCount = copy_src.drmFormatModifierCount;
+    pDrmFormatModifierProperties = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDrmFormatModifierProperties) {
+        pDrmFormatModifierProperties = new VkDrmFormatModifierProperties2EXT[copy_src.drmFormatModifierCount];
+        memcpy((void*)pDrmFormatModifierProperties, (void*)copy_src.pDrmFormatModifierProperties,
+               sizeof(VkDrmFormatModifierProperties2EXT) * copy_src.drmFormatModifierCount);
+    }
+
+    return *this;
+}
+
+safe_VkDrmFormatModifierPropertiesList2EXT::~safe_VkDrmFormatModifierPropertiesList2EXT() {
+    if (pDrmFormatModifierProperties) delete[] pDrmFormatModifierProperties;
+    FreePnextChain(pNext);
+}
+
+void safe_VkDrmFormatModifierPropertiesList2EXT::initialize(const VkDrmFormatModifierPropertiesList2EXT* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pDrmFormatModifierProperties) delete[] pDrmFormatModifierProperties;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    drmFormatModifierCount = in_struct->drmFormatModifierCount;
+    pDrmFormatModifierProperties = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pDrmFormatModifierProperties) {
+        pDrmFormatModifierProperties = new VkDrmFormatModifierProperties2EXT[in_struct->drmFormatModifierCount];
+        memcpy((void*)pDrmFormatModifierProperties, (void*)in_struct->pDrmFormatModifierProperties,
+               sizeof(VkDrmFormatModifierProperties2EXT) * in_struct->drmFormatModifierCount);
+    }
+}
+
+void safe_VkDrmFormatModifierPropertiesList2EXT::initialize(const safe_VkDrmFormatModifierPropertiesList2EXT* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    drmFormatModifierCount = copy_src->drmFormatModifierCount;
+    pDrmFormatModifierProperties = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pDrmFormatModifierProperties) {
+        pDrmFormatModifierProperties = new VkDrmFormatModifierProperties2EXT[copy_src->drmFormatModifierCount];
+        memcpy((void*)pDrmFormatModifierProperties, (void*)copy_src->pDrmFormatModifierProperties,
+               sizeof(VkDrmFormatModifierProperties2EXT) * copy_src->drmFormatModifierCount);
+    }
+}
+
+safe_VkValidationCacheCreateInfoEXT::safe_VkValidationCacheCreateInfoEXT(const VkValidationCacheCreateInfoEXT* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      initialDataSize(in_struct->initialDataSize),
+      pInitialData(in_struct->pInitialData) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkValidationCacheCreateInfoEXT::safe_VkValidationCacheCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT),
+      pNext(nullptr),
+      flags(),
+      initialDataSize(),
+      pInitialData(nullptr) {}
+
+safe_VkValidationCacheCreateInfoEXT::safe_VkValidationCacheCreateInfoEXT(const safe_VkValidationCacheCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    initialDataSize = copy_src.initialDataSize;
+    pInitialData = copy_src.pInitialData;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkValidationCacheCreateInfoEXT& safe_VkValidationCacheCreateInfoEXT::operator=(
+    const safe_VkValidationCacheCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    initialDataSize = copy_src.initialDataSize;
+    pInitialData = copy_src.pInitialData;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkValidationCacheCreateInfoEXT::~safe_VkValidationCacheCreateInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkValidationCacheCreateInfoEXT::initialize(const VkValidationCacheCreateInfoEXT* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    initialDataSize = in_struct->initialDataSize;
+    pInitialData = in_struct->pInitialData;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkValidationCacheCreateInfoEXT::initialize(const safe_VkValidationCacheCreateInfoEXT* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    initialDataSize = copy_src->initialDataSize;
+    pInitialData = copy_src->pInitialData;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkShaderModuleValidationCacheCreateInfoEXT::safe_VkShaderModuleValidationCacheCreateInfoEXT(
+    const VkShaderModuleValidationCacheCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), validationCache(in_struct->validationCache) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkShaderModuleValidationCacheCreateInfoEXT::safe_VkShaderModuleValidationCacheCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT), pNext(nullptr), validationCache() {}
+
+safe_VkShaderModuleValidationCacheCreateInfoEXT::safe_VkShaderModuleValidationCacheCreateInfoEXT(
+    const safe_VkShaderModuleValidationCacheCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    validationCache = copy_src.validationCache;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkShaderModuleValidationCacheCreateInfoEXT& safe_VkShaderModuleValidationCacheCreateInfoEXT::operator=(
+    const safe_VkShaderModuleValidationCacheCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    validationCache = copy_src.validationCache;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkShaderModuleValidationCacheCreateInfoEXT::~safe_VkShaderModuleValidationCacheCreateInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkShaderModuleValidationCacheCreateInfoEXT::initialize(const VkShaderModuleValidationCacheCreateInfoEXT* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    validationCache = in_struct->validationCache;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkShaderModuleValidationCacheCreateInfoEXT::initialize(const safe_VkShaderModuleValidationCacheCreateInfoEXT* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    validationCache = copy_src->validationCache;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceImageViewImageFormatInfoEXT::safe_VkPhysicalDeviceImageViewImageFormatInfoEXT(
+    const VkPhysicalDeviceImageViewImageFormatInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), imageViewType(in_struct->imageViewType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceImageViewImageFormatInfoEXT::safe_VkPhysicalDeviceImageViewImageFormatInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT), pNext(nullptr), imageViewType() {}
+
+safe_VkPhysicalDeviceImageViewImageFormatInfoEXT::safe_VkPhysicalDeviceImageViewImageFormatInfoEXT(
+    const safe_VkPhysicalDeviceImageViewImageFormatInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    imageViewType = copy_src.imageViewType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceImageViewImageFormatInfoEXT& safe_VkPhysicalDeviceImageViewImageFormatInfoEXT::operator=(
+    const safe_VkPhysicalDeviceImageViewImageFormatInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    imageViewType = copy_src.imageViewType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceImageViewImageFormatInfoEXT::~safe_VkPhysicalDeviceImageViewImageFormatInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceImageViewImageFormatInfoEXT::initialize(const VkPhysicalDeviceImageViewImageFormatInfoEXT* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    imageViewType = in_struct->imageViewType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceImageViewImageFormatInfoEXT::initialize(const safe_VkPhysicalDeviceImageViewImageFormatInfoEXT* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imageViewType = copy_src->imageViewType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkFilterCubicImageViewImageFormatPropertiesEXT::safe_VkFilterCubicImageViewImageFormatPropertiesEXT(
+    const VkFilterCubicImageViewImageFormatPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), filterCubic(in_struct->filterCubic), filterCubicMinmax(in_struct->filterCubicMinmax) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkFilterCubicImageViewImageFormatPropertiesEXT::safe_VkFilterCubicImageViewImageFormatPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT),
+      pNext(nullptr),
+      filterCubic(),
+      filterCubicMinmax() {}
+
+safe_VkFilterCubicImageViewImageFormatPropertiesEXT::safe_VkFilterCubicImageViewImageFormatPropertiesEXT(
+    const safe_VkFilterCubicImageViewImageFormatPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    filterCubic = copy_src.filterCubic;
+    filterCubicMinmax = copy_src.filterCubicMinmax;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkFilterCubicImageViewImageFormatPropertiesEXT& safe_VkFilterCubicImageViewImageFormatPropertiesEXT::operator=(
+    const safe_VkFilterCubicImageViewImageFormatPropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    filterCubic = copy_src.filterCubic;
+    filterCubicMinmax = copy_src.filterCubicMinmax;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkFilterCubicImageViewImageFormatPropertiesEXT::~safe_VkFilterCubicImageViewImageFormatPropertiesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkFilterCubicImageViewImageFormatPropertiesEXT::initialize(
+    const VkFilterCubicImageViewImageFormatPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    filterCubic = in_struct->filterCubic;
+    filterCubicMinmax = in_struct->filterCubicMinmax;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkFilterCubicImageViewImageFormatPropertiesEXT::initialize(
+    const safe_VkFilterCubicImageViewImageFormatPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    filterCubic = copy_src->filterCubic;
+    filterCubicMinmax = copy_src->filterCubicMinmax;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkImportMemoryHostPointerInfoEXT::safe_VkImportMemoryHostPointerInfoEXT(const VkImportMemoryHostPointerInfoEXT* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType), handleType(in_struct->handleType), pHostPointer(in_struct->pHostPointer) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImportMemoryHostPointerInfoEXT::safe_VkImportMemoryHostPointerInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT), pNext(nullptr), handleType(), pHostPointer(nullptr) {}
+
+safe_VkImportMemoryHostPointerInfoEXT::safe_VkImportMemoryHostPointerInfoEXT(
+    const safe_VkImportMemoryHostPointerInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    handleType = copy_src.handleType;
+    pHostPointer = copy_src.pHostPointer;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImportMemoryHostPointerInfoEXT& safe_VkImportMemoryHostPointerInfoEXT::operator=(
+    const safe_VkImportMemoryHostPointerInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    handleType = copy_src.handleType;
+    pHostPointer = copy_src.pHostPointer;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImportMemoryHostPointerInfoEXT::~safe_VkImportMemoryHostPointerInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkImportMemoryHostPointerInfoEXT::initialize(const VkImportMemoryHostPointerInfoEXT* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    handleType = in_struct->handleType;
+    pHostPointer = in_struct->pHostPointer;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImportMemoryHostPointerInfoEXT::initialize(const safe_VkImportMemoryHostPointerInfoEXT* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    handleType = copy_src->handleType;
+    pHostPointer = copy_src->pHostPointer;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkMemoryHostPointerPropertiesEXT::safe_VkMemoryHostPointerPropertiesEXT(const VkMemoryHostPointerPropertiesEXT* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType), memoryTypeBits(in_struct->memoryTypeBits) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMemoryHostPointerPropertiesEXT::safe_VkMemoryHostPointerPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT), pNext(nullptr), memoryTypeBits() {}
+
+safe_VkMemoryHostPointerPropertiesEXT::safe_VkMemoryHostPointerPropertiesEXT(
+    const safe_VkMemoryHostPointerPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    memoryTypeBits = copy_src.memoryTypeBits;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMemoryHostPointerPropertiesEXT& safe_VkMemoryHostPointerPropertiesEXT::operator=(
+    const safe_VkMemoryHostPointerPropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    memoryTypeBits = copy_src.memoryTypeBits;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMemoryHostPointerPropertiesEXT::~safe_VkMemoryHostPointerPropertiesEXT() { FreePnextChain(pNext); }
+
+void safe_VkMemoryHostPointerPropertiesEXT::initialize(const VkMemoryHostPointerPropertiesEXT* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    memoryTypeBits = in_struct->memoryTypeBits;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMemoryHostPointerPropertiesEXT::initialize(const safe_VkMemoryHostPointerPropertiesEXT* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memoryTypeBits = copy_src->memoryTypeBits;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT::safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+    const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), minImportedHostPointerAlignment(in_struct->minImportedHostPointerAlignment) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT::safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT),
+      pNext(nullptr),
+      minImportedHostPointerAlignment() {}
+
+safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT::safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
+    const safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    minImportedHostPointerAlignment = copy_src.minImportedHostPointerAlignment;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT& safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT::operator=(
+    const safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    minImportedHostPointerAlignment = copy_src.minImportedHostPointerAlignment;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT::~safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT::initialize(
+    const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    minImportedHostPointerAlignment = in_struct->minImportedHostPointerAlignment;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT::initialize(
+    const safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    minImportedHostPointerAlignment = copy_src->minImportedHostPointerAlignment;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
+    const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), maxVertexAttribDivisor(in_struct->maxVertexAttribDivisor) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT), pNext(nullptr), maxVertexAttribDivisor() {}
+
+safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
+    const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    maxVertexAttribDivisor = copy_src.maxVertexAttribDivisor;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::operator=(
+    const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxVertexAttribDivisor = copy_src.maxVertexAttribDivisor;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::~safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::initialize(
+    const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxVertexAttribDivisor = in_struct->maxVertexAttribDivisor;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::initialize(
+    const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxVertexAttribDivisor = copy_src->maxVertexAttribDivisor;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDevicePCIBusInfoPropertiesEXT::safe_VkPhysicalDevicePCIBusInfoPropertiesEXT(
+    const VkPhysicalDevicePCIBusInfoPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      pciDomain(in_struct->pciDomain),
+      pciBus(in_struct->pciBus),
+      pciDevice(in_struct->pciDevice),
+      pciFunction(in_struct->pciFunction) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePCIBusInfoPropertiesEXT::safe_VkPhysicalDevicePCIBusInfoPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT),
+      pNext(nullptr),
+      pciDomain(),
+      pciBus(),
+      pciDevice(),
+      pciFunction() {}
+
+safe_VkPhysicalDevicePCIBusInfoPropertiesEXT::safe_VkPhysicalDevicePCIBusInfoPropertiesEXT(
+    const safe_VkPhysicalDevicePCIBusInfoPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    pciDomain = copy_src.pciDomain;
+    pciBus = copy_src.pciBus;
+    pciDevice = copy_src.pciDevice;
+    pciFunction = copy_src.pciFunction;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePCIBusInfoPropertiesEXT& safe_VkPhysicalDevicePCIBusInfoPropertiesEXT::operator=(
+    const safe_VkPhysicalDevicePCIBusInfoPropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pciDomain = copy_src.pciDomain;
+    pciBus = copy_src.pciBus;
+    pciDevice = copy_src.pciDevice;
+    pciFunction = copy_src.pciFunction;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePCIBusInfoPropertiesEXT::~safe_VkPhysicalDevicePCIBusInfoPropertiesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDevicePCIBusInfoPropertiesEXT::initialize(const VkPhysicalDevicePCIBusInfoPropertiesEXT* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pciDomain = in_struct->pciDomain;
+    pciBus = in_struct->pciBus;
+    pciDevice = in_struct->pciDevice;
+    pciFunction = in_struct->pciFunction;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePCIBusInfoPropertiesEXT::initialize(const safe_VkPhysicalDevicePCIBusInfoPropertiesEXT* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pciDomain = copy_src->pciDomain;
+    pciBus = copy_src->pciBus;
+    pciDevice = copy_src->pciDevice;
+    pciFunction = copy_src->pciFunction;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT::safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
+    const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      fragmentDensityMap(in_struct->fragmentDensityMap),
+      fragmentDensityMapDynamic(in_struct->fragmentDensityMapDynamic),
+      fragmentDensityMapNonSubsampledImages(in_struct->fragmentDensityMapNonSubsampledImages) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT::safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT),
+      pNext(nullptr),
+      fragmentDensityMap(),
+      fragmentDensityMapDynamic(),
+      fragmentDensityMapNonSubsampledImages() {}
+
+safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT::safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
+    const safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    fragmentDensityMap = copy_src.fragmentDensityMap;
+    fragmentDensityMapDynamic = copy_src.fragmentDensityMapDynamic;
+    fragmentDensityMapNonSubsampledImages = copy_src.fragmentDensityMapNonSubsampledImages;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT& safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    fragmentDensityMap = copy_src.fragmentDensityMap;
+    fragmentDensityMapDynamic = copy_src.fragmentDensityMapDynamic;
+    fragmentDensityMapNonSubsampledImages = copy_src.fragmentDensityMapNonSubsampledImages;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT::~safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT::initialize(const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    fragmentDensityMap = in_struct->fragmentDensityMap;
+    fragmentDensityMapDynamic = in_struct->fragmentDensityMapDynamic;
+    fragmentDensityMapNonSubsampledImages = in_struct->fragmentDensityMapNonSubsampledImages;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    fragmentDensityMap = copy_src->fragmentDensityMap;
+    fragmentDensityMapDynamic = copy_src->fragmentDensityMapDynamic;
+    fragmentDensityMapNonSubsampledImages = copy_src->fragmentDensityMapNonSubsampledImages;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT::safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
+    const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      minFragmentDensityTexelSize(in_struct->minFragmentDensityTexelSize),
+      maxFragmentDensityTexelSize(in_struct->maxFragmentDensityTexelSize),
+      fragmentDensityInvocations(in_struct->fragmentDensityInvocations) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT::safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT),
+      pNext(nullptr),
+      minFragmentDensityTexelSize(),
+      maxFragmentDensityTexelSize(),
+      fragmentDensityInvocations() {}
+
+safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT::safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
+    const safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    minFragmentDensityTexelSize = copy_src.minFragmentDensityTexelSize;
+    maxFragmentDensityTexelSize = copy_src.maxFragmentDensityTexelSize;
+    fragmentDensityInvocations = copy_src.fragmentDensityInvocations;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT& safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT::operator=(
+    const safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    minFragmentDensityTexelSize = copy_src.minFragmentDensityTexelSize;
+    maxFragmentDensityTexelSize = copy_src.maxFragmentDensityTexelSize;
+    fragmentDensityInvocations = copy_src.fragmentDensityInvocations;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT::~safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT::initialize(
+    const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    minFragmentDensityTexelSize = in_struct->minFragmentDensityTexelSize;
+    maxFragmentDensityTexelSize = in_struct->maxFragmentDensityTexelSize;
+    fragmentDensityInvocations = in_struct->fragmentDensityInvocations;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT::initialize(
+    const safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    minFragmentDensityTexelSize = copy_src->minFragmentDensityTexelSize;
+    maxFragmentDensityTexelSize = copy_src->maxFragmentDensityTexelSize;
+    fragmentDensityInvocations = copy_src->fragmentDensityInvocations;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkRenderPassFragmentDensityMapCreateInfoEXT::safe_VkRenderPassFragmentDensityMapCreateInfoEXT(
+    const VkRenderPassFragmentDensityMapCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), fragmentDensityMapAttachment(in_struct->fragmentDensityMapAttachment) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkRenderPassFragmentDensityMapCreateInfoEXT::safe_VkRenderPassFragmentDensityMapCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT), pNext(nullptr), fragmentDensityMapAttachment() {}
+
+safe_VkRenderPassFragmentDensityMapCreateInfoEXT::safe_VkRenderPassFragmentDensityMapCreateInfoEXT(
+    const safe_VkRenderPassFragmentDensityMapCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    fragmentDensityMapAttachment = copy_src.fragmentDensityMapAttachment;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkRenderPassFragmentDensityMapCreateInfoEXT& safe_VkRenderPassFragmentDensityMapCreateInfoEXT::operator=(
+    const safe_VkRenderPassFragmentDensityMapCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    fragmentDensityMapAttachment = copy_src.fragmentDensityMapAttachment;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkRenderPassFragmentDensityMapCreateInfoEXT::~safe_VkRenderPassFragmentDensityMapCreateInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkRenderPassFragmentDensityMapCreateInfoEXT::initialize(const VkRenderPassFragmentDensityMapCreateInfoEXT* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    fragmentDensityMapAttachment = in_struct->fragmentDensityMapAttachment;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkRenderPassFragmentDensityMapCreateInfoEXT::initialize(const safe_VkRenderPassFragmentDensityMapCreateInfoEXT* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    fragmentDensityMapAttachment = copy_src->fragmentDensityMapAttachment;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT::safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
+    const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      shaderImageInt64Atomics(in_struct->shaderImageInt64Atomics),
+      sparseImageInt64Atomics(in_struct->sparseImageInt64Atomics) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT::safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT),
+      pNext(nullptr),
+      shaderImageInt64Atomics(),
+      sparseImageInt64Atomics() {}
+
+safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT::safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
+    const safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    shaderImageInt64Atomics = copy_src.shaderImageInt64Atomics;
+    sparseImageInt64Atomics = copy_src.sparseImageInt64Atomics;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderImageInt64Atomics = copy_src.shaderImageInt64Atomics;
+    sparseImageInt64Atomics = copy_src.sparseImageInt64Atomics;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT::~safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT::initialize(
+    const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderImageInt64Atomics = in_struct->shaderImageInt64Atomics;
+    sparseImageInt64Atomics = in_struct->sparseImageInt64Atomics;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderImageInt64Atomics = copy_src->shaderImageInt64Atomics;
+    sparseImageInt64Atomics = copy_src->sparseImageInt64Atomics;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT::safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
+    const VkPhysicalDeviceMemoryBudgetPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) {
+        heapBudget[i] = in_struct->heapBudget[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) {
+        heapUsage[i] = in_struct->heapUsage[i];
+    }
+}
+
+safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT::safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT), pNext(nullptr) {}
+
+safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT::safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
+    const safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) {
+        heapBudget[i] = copy_src.heapBudget[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) {
+        heapUsage[i] = copy_src.heapUsage[i];
+    }
+}
+
+safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT& safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT::operator=(
+    const safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) {
+        heapBudget[i] = copy_src.heapBudget[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) {
+        heapUsage[i] = copy_src.heapUsage[i];
+    }
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT::~safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT::initialize(const VkPhysicalDeviceMemoryBudgetPropertiesEXT* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) {
+        heapBudget[i] = in_struct->heapBudget[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) {
+        heapUsage[i] = in_struct->heapUsage[i];
+    }
+}
+
+void safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT::initialize(const safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) {
+        heapBudget[i] = copy_src->heapBudget[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) {
+        heapUsage[i] = copy_src->heapUsage[i];
+    }
+}
+
+safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT::safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
+    const VkPhysicalDeviceMemoryPriorityFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), memoryPriority(in_struct->memoryPriority) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT::safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT), pNext(nullptr), memoryPriority() {}
+
+safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT::safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
+    const safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    memoryPriority = copy_src.memoryPriority;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT& safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    memoryPriority = copy_src.memoryPriority;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT::~safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT::initialize(const VkPhysicalDeviceMemoryPriorityFeaturesEXT* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    memoryPriority = in_struct->memoryPriority;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT::initialize(const safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memoryPriority = copy_src->memoryPriority;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkMemoryPriorityAllocateInfoEXT::safe_VkMemoryPriorityAllocateInfoEXT(const VkMemoryPriorityAllocateInfoEXT* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), priority(in_struct->priority) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMemoryPriorityAllocateInfoEXT::safe_VkMemoryPriorityAllocateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT), pNext(nullptr), priority() {}
+
+safe_VkMemoryPriorityAllocateInfoEXT::safe_VkMemoryPriorityAllocateInfoEXT(const safe_VkMemoryPriorityAllocateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    priority = copy_src.priority;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMemoryPriorityAllocateInfoEXT& safe_VkMemoryPriorityAllocateInfoEXT::operator=(
+    const safe_VkMemoryPriorityAllocateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    priority = copy_src.priority;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMemoryPriorityAllocateInfoEXT::~safe_VkMemoryPriorityAllocateInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkMemoryPriorityAllocateInfoEXT::initialize(const VkMemoryPriorityAllocateInfoEXT* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    priority = in_struct->priority;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMemoryPriorityAllocateInfoEXT::initialize(const safe_VkMemoryPriorityAllocateInfoEXT* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    priority = copy_src->priority;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
+    const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      bufferDeviceAddress(in_struct->bufferDeviceAddress),
+      bufferDeviceAddressCaptureReplay(in_struct->bufferDeviceAddressCaptureReplay),
+      bufferDeviceAddressMultiDevice(in_struct->bufferDeviceAddressMultiDevice) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT),
+      pNext(nullptr),
+      bufferDeviceAddress(),
+      bufferDeviceAddressCaptureReplay(),
+      bufferDeviceAddressMultiDevice() {}
+
+safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
+    const safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    bufferDeviceAddress = copy_src.bufferDeviceAddress;
+    bufferDeviceAddressCaptureReplay = copy_src.bufferDeviceAddressCaptureReplay;
+    bufferDeviceAddressMultiDevice = copy_src.bufferDeviceAddressMultiDevice;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    bufferDeviceAddress = copy_src.bufferDeviceAddress;
+    bufferDeviceAddressCaptureReplay = copy_src.bufferDeviceAddressCaptureReplay;
+    bufferDeviceAddressMultiDevice = copy_src.bufferDeviceAddressMultiDevice;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::~safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::initialize(
+    const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    bufferDeviceAddress = in_struct->bufferDeviceAddress;
+    bufferDeviceAddressCaptureReplay = in_struct->bufferDeviceAddressCaptureReplay;
+    bufferDeviceAddressMultiDevice = in_struct->bufferDeviceAddressMultiDevice;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    bufferDeviceAddress = copy_src->bufferDeviceAddress;
+    bufferDeviceAddressCaptureReplay = copy_src->bufferDeviceAddressCaptureReplay;
+    bufferDeviceAddressMultiDevice = copy_src->bufferDeviceAddressMultiDevice;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkBufferDeviceAddressCreateInfoEXT::safe_VkBufferDeviceAddressCreateInfoEXT(
+    const VkBufferDeviceAddressCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), deviceAddress(in_struct->deviceAddress) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkBufferDeviceAddressCreateInfoEXT::safe_VkBufferDeviceAddressCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT), pNext(nullptr), deviceAddress() {}
+
+safe_VkBufferDeviceAddressCreateInfoEXT::safe_VkBufferDeviceAddressCreateInfoEXT(
+    const safe_VkBufferDeviceAddressCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    deviceAddress = copy_src.deviceAddress;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBufferDeviceAddressCreateInfoEXT& safe_VkBufferDeviceAddressCreateInfoEXT::operator=(
+    const safe_VkBufferDeviceAddressCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    deviceAddress = copy_src.deviceAddress;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkBufferDeviceAddressCreateInfoEXT::~safe_VkBufferDeviceAddressCreateInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkBufferDeviceAddressCreateInfoEXT::initialize(const VkBufferDeviceAddressCreateInfoEXT* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    deviceAddress = in_struct->deviceAddress;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkBufferDeviceAddressCreateInfoEXT::initialize(const safe_VkBufferDeviceAddressCreateInfoEXT* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    deviceAddress = copy_src->deviceAddress;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkValidationFeaturesEXT::safe_VkValidationFeaturesEXT(const VkValidationFeaturesEXT* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      enabledValidationFeatureCount(in_struct->enabledValidationFeatureCount),
+      pEnabledValidationFeatures(nullptr),
+      disabledValidationFeatureCount(in_struct->disabledValidationFeatureCount),
+      pDisabledValidationFeatures(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pEnabledValidationFeatures) {
+        pEnabledValidationFeatures = new VkValidationFeatureEnableEXT[in_struct->enabledValidationFeatureCount];
+        memcpy((void*)pEnabledValidationFeatures, (void*)in_struct->pEnabledValidationFeatures,
+               sizeof(VkValidationFeatureEnableEXT) * in_struct->enabledValidationFeatureCount);
+    }
+
+    if (in_struct->pDisabledValidationFeatures) {
+        pDisabledValidationFeatures = new VkValidationFeatureDisableEXT[in_struct->disabledValidationFeatureCount];
+        memcpy((void*)pDisabledValidationFeatures, (void*)in_struct->pDisabledValidationFeatures,
+               sizeof(VkValidationFeatureDisableEXT) * in_struct->disabledValidationFeatureCount);
+    }
+}
+
+safe_VkValidationFeaturesEXT::safe_VkValidationFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT),
+      pNext(nullptr),
+      enabledValidationFeatureCount(),
+      pEnabledValidationFeatures(nullptr),
+      disabledValidationFeatureCount(),
+      pDisabledValidationFeatures(nullptr) {}
+
+safe_VkValidationFeaturesEXT::safe_VkValidationFeaturesEXT(const safe_VkValidationFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    enabledValidationFeatureCount = copy_src.enabledValidationFeatureCount;
+    pEnabledValidationFeatures = nullptr;
+    disabledValidationFeatureCount = copy_src.disabledValidationFeatureCount;
+    pDisabledValidationFeatures = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pEnabledValidationFeatures) {
+        pEnabledValidationFeatures = new VkValidationFeatureEnableEXT[copy_src.enabledValidationFeatureCount];
+        memcpy((void*)pEnabledValidationFeatures, (void*)copy_src.pEnabledValidationFeatures,
+               sizeof(VkValidationFeatureEnableEXT) * copy_src.enabledValidationFeatureCount);
+    }
+
+    if (copy_src.pDisabledValidationFeatures) {
+        pDisabledValidationFeatures = new VkValidationFeatureDisableEXT[copy_src.disabledValidationFeatureCount];
+        memcpy((void*)pDisabledValidationFeatures, (void*)copy_src.pDisabledValidationFeatures,
+               sizeof(VkValidationFeatureDisableEXT) * copy_src.disabledValidationFeatureCount);
+    }
+}
+
+safe_VkValidationFeaturesEXT& safe_VkValidationFeaturesEXT::operator=(const safe_VkValidationFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pEnabledValidationFeatures) delete[] pEnabledValidationFeatures;
+    if (pDisabledValidationFeatures) delete[] pDisabledValidationFeatures;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    enabledValidationFeatureCount = copy_src.enabledValidationFeatureCount;
+    pEnabledValidationFeatures = nullptr;
+    disabledValidationFeatureCount = copy_src.disabledValidationFeatureCount;
+    pDisabledValidationFeatures = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pEnabledValidationFeatures) {
+        pEnabledValidationFeatures = new VkValidationFeatureEnableEXT[copy_src.enabledValidationFeatureCount];
+        memcpy((void*)pEnabledValidationFeatures, (void*)copy_src.pEnabledValidationFeatures,
+               sizeof(VkValidationFeatureEnableEXT) * copy_src.enabledValidationFeatureCount);
+    }
+
+    if (copy_src.pDisabledValidationFeatures) {
+        pDisabledValidationFeatures = new VkValidationFeatureDisableEXT[copy_src.disabledValidationFeatureCount];
+        memcpy((void*)pDisabledValidationFeatures, (void*)copy_src.pDisabledValidationFeatures,
+               sizeof(VkValidationFeatureDisableEXT) * copy_src.disabledValidationFeatureCount);
+    }
+
+    return *this;
+}
+
+safe_VkValidationFeaturesEXT::~safe_VkValidationFeaturesEXT() {
+    if (pEnabledValidationFeatures) delete[] pEnabledValidationFeatures;
+    if (pDisabledValidationFeatures) delete[] pDisabledValidationFeatures;
+    FreePnextChain(pNext);
+}
+
+void safe_VkValidationFeaturesEXT::initialize(const VkValidationFeaturesEXT* in_struct,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pEnabledValidationFeatures) delete[] pEnabledValidationFeatures;
+    if (pDisabledValidationFeatures) delete[] pDisabledValidationFeatures;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    enabledValidationFeatureCount = in_struct->enabledValidationFeatureCount;
+    pEnabledValidationFeatures = nullptr;
+    disabledValidationFeatureCount = in_struct->disabledValidationFeatureCount;
+    pDisabledValidationFeatures = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pEnabledValidationFeatures) {
+        pEnabledValidationFeatures = new VkValidationFeatureEnableEXT[in_struct->enabledValidationFeatureCount];
+        memcpy((void*)pEnabledValidationFeatures, (void*)in_struct->pEnabledValidationFeatures,
+               sizeof(VkValidationFeatureEnableEXT) * in_struct->enabledValidationFeatureCount);
+    }
+
+    if (in_struct->pDisabledValidationFeatures) {
+        pDisabledValidationFeatures = new VkValidationFeatureDisableEXT[in_struct->disabledValidationFeatureCount];
+        memcpy((void*)pDisabledValidationFeatures, (void*)in_struct->pDisabledValidationFeatures,
+               sizeof(VkValidationFeatureDisableEXT) * in_struct->disabledValidationFeatureCount);
+    }
+}
+
+void safe_VkValidationFeaturesEXT::initialize(const safe_VkValidationFeaturesEXT* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    enabledValidationFeatureCount = copy_src->enabledValidationFeatureCount;
+    pEnabledValidationFeatures = nullptr;
+    disabledValidationFeatureCount = copy_src->disabledValidationFeatureCount;
+    pDisabledValidationFeatures = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pEnabledValidationFeatures) {
+        pEnabledValidationFeatures = new VkValidationFeatureEnableEXT[copy_src->enabledValidationFeatureCount];
+        memcpy((void*)pEnabledValidationFeatures, (void*)copy_src->pEnabledValidationFeatures,
+               sizeof(VkValidationFeatureEnableEXT) * copy_src->enabledValidationFeatureCount);
+    }
+
+    if (copy_src->pDisabledValidationFeatures) {
+        pDisabledValidationFeatures = new VkValidationFeatureDisableEXT[copy_src->disabledValidationFeatureCount];
+        memcpy((void*)pDisabledValidationFeatures, (void*)copy_src->pDisabledValidationFeatures,
+               sizeof(VkValidationFeatureDisableEXT) * copy_src->disabledValidationFeatureCount);
+    }
+}
+
+safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
+    const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      fragmentShaderSampleInterlock(in_struct->fragmentShaderSampleInterlock),
+      fragmentShaderPixelInterlock(in_struct->fragmentShaderPixelInterlock),
+      fragmentShaderShadingRateInterlock(in_struct->fragmentShaderShadingRateInterlock) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT),
+      pNext(nullptr),
+      fragmentShaderSampleInterlock(),
+      fragmentShaderPixelInterlock(),
+      fragmentShaderShadingRateInterlock() {}
+
+safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
+    const safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    fragmentShaderSampleInterlock = copy_src.fragmentShaderSampleInterlock;
+    fragmentShaderPixelInterlock = copy_src.fragmentShaderPixelInterlock;
+    fragmentShaderShadingRateInterlock = copy_src.fragmentShaderShadingRateInterlock;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    fragmentShaderSampleInterlock = copy_src.fragmentShaderSampleInterlock;
+    fragmentShaderPixelInterlock = copy_src.fragmentShaderPixelInterlock;
+    fragmentShaderShadingRateInterlock = copy_src.fragmentShaderShadingRateInterlock;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::~safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::initialize(
+    const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    fragmentShaderSampleInterlock = in_struct->fragmentShaderSampleInterlock;
+    fragmentShaderPixelInterlock = in_struct->fragmentShaderPixelInterlock;
+    fragmentShaderShadingRateInterlock = in_struct->fragmentShaderShadingRateInterlock;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    fragmentShaderSampleInterlock = copy_src->fragmentShaderSampleInterlock;
+    fragmentShaderPixelInterlock = copy_src->fragmentShaderPixelInterlock;
+    fragmentShaderShadingRateInterlock = copy_src->fragmentShaderShadingRateInterlock;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
+    const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), ycbcrImageArrays(in_struct->ycbcrImageArrays) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT), pNext(nullptr), ycbcrImageArrays() {}
+
+safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
+    const safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    ycbcrImageArrays = copy_src.ycbcrImageArrays;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    ycbcrImageArrays = copy_src.ycbcrImageArrays;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::~safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::initialize(const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    ycbcrImageArrays = in_struct->ycbcrImageArrays;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::initialize(const safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    ycbcrImageArrays = copy_src->ycbcrImageArrays;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceProvokingVertexFeaturesEXT::safe_VkPhysicalDeviceProvokingVertexFeaturesEXT(
+    const VkPhysicalDeviceProvokingVertexFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      provokingVertexLast(in_struct->provokingVertexLast),
+      transformFeedbackPreservesProvokingVertex(in_struct->transformFeedbackPreservesProvokingVertex) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceProvokingVertexFeaturesEXT::safe_VkPhysicalDeviceProvokingVertexFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT),
+      pNext(nullptr),
+      provokingVertexLast(),
+      transformFeedbackPreservesProvokingVertex() {}
+
+safe_VkPhysicalDeviceProvokingVertexFeaturesEXT::safe_VkPhysicalDeviceProvokingVertexFeaturesEXT(
+    const safe_VkPhysicalDeviceProvokingVertexFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    provokingVertexLast = copy_src.provokingVertexLast;
+    transformFeedbackPreservesProvokingVertex = copy_src.transformFeedbackPreservesProvokingVertex;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceProvokingVertexFeaturesEXT& safe_VkPhysicalDeviceProvokingVertexFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceProvokingVertexFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    provokingVertexLast = copy_src.provokingVertexLast;
+    transformFeedbackPreservesProvokingVertex = copy_src.transformFeedbackPreservesProvokingVertex;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceProvokingVertexFeaturesEXT::~safe_VkPhysicalDeviceProvokingVertexFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceProvokingVertexFeaturesEXT::initialize(const VkPhysicalDeviceProvokingVertexFeaturesEXT* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    provokingVertexLast = in_struct->provokingVertexLast;
+    transformFeedbackPreservesProvokingVertex = in_struct->transformFeedbackPreservesProvokingVertex;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceProvokingVertexFeaturesEXT::initialize(const safe_VkPhysicalDeviceProvokingVertexFeaturesEXT* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    provokingVertexLast = copy_src->provokingVertexLast;
+    transformFeedbackPreservesProvokingVertex = copy_src->transformFeedbackPreservesProvokingVertex;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceProvokingVertexPropertiesEXT::safe_VkPhysicalDeviceProvokingVertexPropertiesEXT(
+    const VkPhysicalDeviceProvokingVertexPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      provokingVertexModePerPipeline(in_struct->provokingVertexModePerPipeline),
+      transformFeedbackPreservesTriangleFanProvokingVertex(in_struct->transformFeedbackPreservesTriangleFanProvokingVertex) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceProvokingVertexPropertiesEXT::safe_VkPhysicalDeviceProvokingVertexPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT),
+      pNext(nullptr),
+      provokingVertexModePerPipeline(),
+      transformFeedbackPreservesTriangleFanProvokingVertex() {}
+
+safe_VkPhysicalDeviceProvokingVertexPropertiesEXT::safe_VkPhysicalDeviceProvokingVertexPropertiesEXT(
+    const safe_VkPhysicalDeviceProvokingVertexPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    provokingVertexModePerPipeline = copy_src.provokingVertexModePerPipeline;
+    transformFeedbackPreservesTriangleFanProvokingVertex = copy_src.transformFeedbackPreservesTriangleFanProvokingVertex;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceProvokingVertexPropertiesEXT& safe_VkPhysicalDeviceProvokingVertexPropertiesEXT::operator=(
+    const safe_VkPhysicalDeviceProvokingVertexPropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    provokingVertexModePerPipeline = copy_src.provokingVertexModePerPipeline;
+    transformFeedbackPreservesTriangleFanProvokingVertex = copy_src.transformFeedbackPreservesTriangleFanProvokingVertex;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceProvokingVertexPropertiesEXT::~safe_VkPhysicalDeviceProvokingVertexPropertiesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceProvokingVertexPropertiesEXT::initialize(const VkPhysicalDeviceProvokingVertexPropertiesEXT* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    provokingVertexModePerPipeline = in_struct->provokingVertexModePerPipeline;
+    transformFeedbackPreservesTriangleFanProvokingVertex = in_struct->transformFeedbackPreservesTriangleFanProvokingVertex;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceProvokingVertexPropertiesEXT::initialize(
+    const safe_VkPhysicalDeviceProvokingVertexPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    provokingVertexModePerPipeline = copy_src->provokingVertexModePerPipeline;
+    transformFeedbackPreservesTriangleFanProvokingVertex = copy_src->transformFeedbackPreservesTriangleFanProvokingVertex;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT::safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
+    const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), provokingVertexMode(in_struct->provokingVertexMode) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT::safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT),
+      pNext(nullptr),
+      provokingVertexMode() {}
+
+safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT::safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
+    const safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    provokingVertexMode = copy_src.provokingVertexMode;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT&
+safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT::operator=(
+    const safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    provokingVertexMode = copy_src.provokingVertexMode;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT::~safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT::initialize(
+    const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    provokingVertexMode = in_struct->provokingVertexMode;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT::initialize(
+    const safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    provokingVertexMode = copy_src->provokingVertexMode;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+safe_VkSurfaceFullScreenExclusiveInfoEXT::safe_VkSurfaceFullScreenExclusiveInfoEXT(
+    const VkSurfaceFullScreenExclusiveInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), fullScreenExclusive(in_struct->fullScreenExclusive) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSurfaceFullScreenExclusiveInfoEXT::safe_VkSurfaceFullScreenExclusiveInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT), pNext(nullptr), fullScreenExclusive() {}
+
+safe_VkSurfaceFullScreenExclusiveInfoEXT::safe_VkSurfaceFullScreenExclusiveInfoEXT(
+    const safe_VkSurfaceFullScreenExclusiveInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    fullScreenExclusive = copy_src.fullScreenExclusive;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSurfaceFullScreenExclusiveInfoEXT& safe_VkSurfaceFullScreenExclusiveInfoEXT::operator=(
+    const safe_VkSurfaceFullScreenExclusiveInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    fullScreenExclusive = copy_src.fullScreenExclusive;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSurfaceFullScreenExclusiveInfoEXT::~safe_VkSurfaceFullScreenExclusiveInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkSurfaceFullScreenExclusiveInfoEXT::initialize(const VkSurfaceFullScreenExclusiveInfoEXT* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    fullScreenExclusive = in_struct->fullScreenExclusive;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSurfaceFullScreenExclusiveInfoEXT::initialize(const safe_VkSurfaceFullScreenExclusiveInfoEXT* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    fullScreenExclusive = copy_src->fullScreenExclusive;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
+    const VkSurfaceCapabilitiesFullScreenExclusiveEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), fullScreenExclusiveSupported(in_struct->fullScreenExclusiveSupported) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT()
+    : sType(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT), pNext(nullptr), fullScreenExclusiveSupported() {}
+
+safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
+    const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT& copy_src) {
+    sType = copy_src.sType;
+    fullScreenExclusiveSupported = copy_src.fullScreenExclusiveSupported;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT& safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::operator=(
+    const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    fullScreenExclusiveSupported = copy_src.fullScreenExclusiveSupported;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::~safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT() { FreePnextChain(pNext); }
+
+void safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::initialize(const VkSurfaceCapabilitiesFullScreenExclusiveEXT* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    fullScreenExclusiveSupported = in_struct->fullScreenExclusiveSupported;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::initialize(const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    fullScreenExclusiveSupported = copy_src->fullScreenExclusiveSupported;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::safe_VkSurfaceFullScreenExclusiveWin32InfoEXT(
+    const VkSurfaceFullScreenExclusiveWin32InfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), hmonitor(in_struct->hmonitor) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::safe_VkSurfaceFullScreenExclusiveWin32InfoEXT()
+    : sType(VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT), pNext(nullptr), hmonitor() {}
+
+safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::safe_VkSurfaceFullScreenExclusiveWin32InfoEXT(
+    const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT& copy_src) {
+    sType = copy_src.sType;
+    hmonitor = copy_src.hmonitor;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSurfaceFullScreenExclusiveWin32InfoEXT& safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::operator=(
+    const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    hmonitor = copy_src.hmonitor;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::~safe_VkSurfaceFullScreenExclusiveWin32InfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::initialize(const VkSurfaceFullScreenExclusiveWin32InfoEXT* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    hmonitor = in_struct->hmonitor;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::initialize(const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    hmonitor = copy_src->hmonitor;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+
+safe_VkHeadlessSurfaceCreateInfoEXT::safe_VkHeadlessSurfaceCreateInfoEXT(const VkHeadlessSurfaceCreateInfoEXT* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkHeadlessSurfaceCreateInfoEXT::safe_VkHeadlessSurfaceCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT), pNext(nullptr), flags() {}
+
+safe_VkHeadlessSurfaceCreateInfoEXT::safe_VkHeadlessSurfaceCreateInfoEXT(const safe_VkHeadlessSurfaceCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkHeadlessSurfaceCreateInfoEXT& safe_VkHeadlessSurfaceCreateInfoEXT::operator=(
+    const safe_VkHeadlessSurfaceCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkHeadlessSurfaceCreateInfoEXT::~safe_VkHeadlessSurfaceCreateInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkHeadlessSurfaceCreateInfoEXT::initialize(const VkHeadlessSurfaceCreateInfoEXT* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkHeadlessSurfaceCreateInfoEXT::initialize(const safe_VkHeadlessSurfaceCreateInfoEXT* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
+    const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      shaderBufferFloat32Atomics(in_struct->shaderBufferFloat32Atomics),
+      shaderBufferFloat32AtomicAdd(in_struct->shaderBufferFloat32AtomicAdd),
+      shaderBufferFloat64Atomics(in_struct->shaderBufferFloat64Atomics),
+      shaderBufferFloat64AtomicAdd(in_struct->shaderBufferFloat64AtomicAdd),
+      shaderSharedFloat32Atomics(in_struct->shaderSharedFloat32Atomics),
+      shaderSharedFloat32AtomicAdd(in_struct->shaderSharedFloat32AtomicAdd),
+      shaderSharedFloat64Atomics(in_struct->shaderSharedFloat64Atomics),
+      shaderSharedFloat64AtomicAdd(in_struct->shaderSharedFloat64AtomicAdd),
+      shaderImageFloat32Atomics(in_struct->shaderImageFloat32Atomics),
+      shaderImageFloat32AtomicAdd(in_struct->shaderImageFloat32AtomicAdd),
+      sparseImageFloat32Atomics(in_struct->sparseImageFloat32Atomics),
+      sparseImageFloat32AtomicAdd(in_struct->sparseImageFloat32AtomicAdd) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT),
+      pNext(nullptr),
+      shaderBufferFloat32Atomics(),
+      shaderBufferFloat32AtomicAdd(),
+      shaderBufferFloat64Atomics(),
+      shaderBufferFloat64AtomicAdd(),
+      shaderSharedFloat32Atomics(),
+      shaderSharedFloat32AtomicAdd(),
+      shaderSharedFloat64Atomics(),
+      shaderSharedFloat64AtomicAdd(),
+      shaderImageFloat32Atomics(),
+      shaderImageFloat32AtomicAdd(),
+      sparseImageFloat32Atomics(),
+      sparseImageFloat32AtomicAdd() {}
+
+safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
+    const safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    shaderBufferFloat32Atomics = copy_src.shaderBufferFloat32Atomics;
+    shaderBufferFloat32AtomicAdd = copy_src.shaderBufferFloat32AtomicAdd;
+    shaderBufferFloat64Atomics = copy_src.shaderBufferFloat64Atomics;
+    shaderBufferFloat64AtomicAdd = copy_src.shaderBufferFloat64AtomicAdd;
+    shaderSharedFloat32Atomics = copy_src.shaderSharedFloat32Atomics;
+    shaderSharedFloat32AtomicAdd = copy_src.shaderSharedFloat32AtomicAdd;
+    shaderSharedFloat64Atomics = copy_src.shaderSharedFloat64Atomics;
+    shaderSharedFloat64AtomicAdd = copy_src.shaderSharedFloat64AtomicAdd;
+    shaderImageFloat32Atomics = copy_src.shaderImageFloat32Atomics;
+    shaderImageFloat32AtomicAdd = copy_src.shaderImageFloat32AtomicAdd;
+    sparseImageFloat32Atomics = copy_src.sparseImageFloat32Atomics;
+    sparseImageFloat32AtomicAdd = copy_src.sparseImageFloat32AtomicAdd;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderBufferFloat32Atomics = copy_src.shaderBufferFloat32Atomics;
+    shaderBufferFloat32AtomicAdd = copy_src.shaderBufferFloat32AtomicAdd;
+    shaderBufferFloat64Atomics = copy_src.shaderBufferFloat64Atomics;
+    shaderBufferFloat64AtomicAdd = copy_src.shaderBufferFloat64AtomicAdd;
+    shaderSharedFloat32Atomics = copy_src.shaderSharedFloat32Atomics;
+    shaderSharedFloat32AtomicAdd = copy_src.shaderSharedFloat32AtomicAdd;
+    shaderSharedFloat64Atomics = copy_src.shaderSharedFloat64Atomics;
+    shaderSharedFloat64AtomicAdd = copy_src.shaderSharedFloat64AtomicAdd;
+    shaderImageFloat32Atomics = copy_src.shaderImageFloat32Atomics;
+    shaderImageFloat32AtomicAdd = copy_src.shaderImageFloat32AtomicAdd;
+    sparseImageFloat32Atomics = copy_src.sparseImageFloat32Atomics;
+    sparseImageFloat32AtomicAdd = copy_src.sparseImageFloat32AtomicAdd;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::~safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::initialize(const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderBufferFloat32Atomics = in_struct->shaderBufferFloat32Atomics;
+    shaderBufferFloat32AtomicAdd = in_struct->shaderBufferFloat32AtomicAdd;
+    shaderBufferFloat64Atomics = in_struct->shaderBufferFloat64Atomics;
+    shaderBufferFloat64AtomicAdd = in_struct->shaderBufferFloat64AtomicAdd;
+    shaderSharedFloat32Atomics = in_struct->shaderSharedFloat32Atomics;
+    shaderSharedFloat32AtomicAdd = in_struct->shaderSharedFloat32AtomicAdd;
+    shaderSharedFloat64Atomics = in_struct->shaderSharedFloat64Atomics;
+    shaderSharedFloat64AtomicAdd = in_struct->shaderSharedFloat64AtomicAdd;
+    shaderImageFloat32Atomics = in_struct->shaderImageFloat32Atomics;
+    shaderImageFloat32AtomicAdd = in_struct->shaderImageFloat32AtomicAdd;
+    sparseImageFloat32Atomics = in_struct->sparseImageFloat32Atomics;
+    sparseImageFloat32AtomicAdd = in_struct->sparseImageFloat32AtomicAdd;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderBufferFloat32Atomics = copy_src->shaderBufferFloat32Atomics;
+    shaderBufferFloat32AtomicAdd = copy_src->shaderBufferFloat32AtomicAdd;
+    shaderBufferFloat64Atomics = copy_src->shaderBufferFloat64Atomics;
+    shaderBufferFloat64AtomicAdd = copy_src->shaderBufferFloat64AtomicAdd;
+    shaderSharedFloat32Atomics = copy_src->shaderSharedFloat32Atomics;
+    shaderSharedFloat32AtomicAdd = copy_src->shaderSharedFloat32AtomicAdd;
+    shaderSharedFloat64Atomics = copy_src->shaderSharedFloat64Atomics;
+    shaderSharedFloat64AtomicAdd = copy_src->shaderSharedFloat64AtomicAdd;
+    shaderImageFloat32Atomics = copy_src->shaderImageFloat32Atomics;
+    shaderImageFloat32AtomicAdd = copy_src->shaderImageFloat32AtomicAdd;
+    sparseImageFloat32Atomics = copy_src->sparseImageFloat32Atomics;
+    sparseImageFloat32AtomicAdd = copy_src->sparseImageFloat32AtomicAdd;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
+    const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), extendedDynamicState(in_struct->extendedDynamicState) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT), pNext(nullptr), extendedDynamicState() {}
+
+safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
+    const safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    extendedDynamicState = copy_src.extendedDynamicState;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    extendedDynamicState = copy_src.extendedDynamicState;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::~safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::initialize(
+    const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    extendedDynamicState = in_struct->extendedDynamicState;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    extendedDynamicState = copy_src->extendedDynamicState;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceHostImageCopyFeaturesEXT::safe_VkPhysicalDeviceHostImageCopyFeaturesEXT(
+    const VkPhysicalDeviceHostImageCopyFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), hostImageCopy(in_struct->hostImageCopy) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceHostImageCopyFeaturesEXT::safe_VkPhysicalDeviceHostImageCopyFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT), pNext(nullptr), hostImageCopy() {}
+
+safe_VkPhysicalDeviceHostImageCopyFeaturesEXT::safe_VkPhysicalDeviceHostImageCopyFeaturesEXT(
+    const safe_VkPhysicalDeviceHostImageCopyFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    hostImageCopy = copy_src.hostImageCopy;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceHostImageCopyFeaturesEXT& safe_VkPhysicalDeviceHostImageCopyFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceHostImageCopyFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    hostImageCopy = copy_src.hostImageCopy;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceHostImageCopyFeaturesEXT::~safe_VkPhysicalDeviceHostImageCopyFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceHostImageCopyFeaturesEXT::initialize(const VkPhysicalDeviceHostImageCopyFeaturesEXT* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    hostImageCopy = in_struct->hostImageCopy;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceHostImageCopyFeaturesEXT::initialize(const safe_VkPhysicalDeviceHostImageCopyFeaturesEXT* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    hostImageCopy = copy_src->hostImageCopy;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceHostImageCopyPropertiesEXT::safe_VkPhysicalDeviceHostImageCopyPropertiesEXT(
+    const VkPhysicalDeviceHostImageCopyPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      copySrcLayoutCount(in_struct->copySrcLayoutCount),
+      pCopySrcLayouts(nullptr),
+      copyDstLayoutCount(in_struct->copyDstLayoutCount),
+      pCopyDstLayouts(nullptr),
+      identicalMemoryTypeRequirements(in_struct->identicalMemoryTypeRequirements) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pCopySrcLayouts) {
+        pCopySrcLayouts = new VkImageLayout[in_struct->copySrcLayoutCount];
+        memcpy((void*)pCopySrcLayouts, (void*)in_struct->pCopySrcLayouts, sizeof(VkImageLayout) * in_struct->copySrcLayoutCount);
+    }
+
+    if (in_struct->pCopyDstLayouts) {
+        pCopyDstLayouts = new VkImageLayout[in_struct->copyDstLayoutCount];
+        memcpy((void*)pCopyDstLayouts, (void*)in_struct->pCopyDstLayouts, sizeof(VkImageLayout) * in_struct->copyDstLayoutCount);
+    }
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        optimalTilingLayoutUUID[i] = in_struct->optimalTilingLayoutUUID[i];
+    }
+}
+
+safe_VkPhysicalDeviceHostImageCopyPropertiesEXT::safe_VkPhysicalDeviceHostImageCopyPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT),
+      pNext(nullptr),
+      copySrcLayoutCount(),
+      pCopySrcLayouts(nullptr),
+      copyDstLayoutCount(),
+      pCopyDstLayouts(nullptr),
+      identicalMemoryTypeRequirements() {}
+
+safe_VkPhysicalDeviceHostImageCopyPropertiesEXT::safe_VkPhysicalDeviceHostImageCopyPropertiesEXT(
+    const safe_VkPhysicalDeviceHostImageCopyPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    copySrcLayoutCount = copy_src.copySrcLayoutCount;
+    pCopySrcLayouts = nullptr;
+    copyDstLayoutCount = copy_src.copyDstLayoutCount;
+    pCopyDstLayouts = nullptr;
+    identicalMemoryTypeRequirements = copy_src.identicalMemoryTypeRequirements;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pCopySrcLayouts) {
+        pCopySrcLayouts = new VkImageLayout[copy_src.copySrcLayoutCount];
+        memcpy((void*)pCopySrcLayouts, (void*)copy_src.pCopySrcLayouts, sizeof(VkImageLayout) * copy_src.copySrcLayoutCount);
+    }
+
+    if (copy_src.pCopyDstLayouts) {
+        pCopyDstLayouts = new VkImageLayout[copy_src.copyDstLayoutCount];
+        memcpy((void*)pCopyDstLayouts, (void*)copy_src.pCopyDstLayouts, sizeof(VkImageLayout) * copy_src.copyDstLayoutCount);
+    }
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        optimalTilingLayoutUUID[i] = copy_src.optimalTilingLayoutUUID[i];
+    }
+}
+
+safe_VkPhysicalDeviceHostImageCopyPropertiesEXT& safe_VkPhysicalDeviceHostImageCopyPropertiesEXT::operator=(
+    const safe_VkPhysicalDeviceHostImageCopyPropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pCopySrcLayouts) delete[] pCopySrcLayouts;
+    if (pCopyDstLayouts) delete[] pCopyDstLayouts;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    copySrcLayoutCount = copy_src.copySrcLayoutCount;
+    pCopySrcLayouts = nullptr;
+    copyDstLayoutCount = copy_src.copyDstLayoutCount;
+    pCopyDstLayouts = nullptr;
+    identicalMemoryTypeRequirements = copy_src.identicalMemoryTypeRequirements;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pCopySrcLayouts) {
+        pCopySrcLayouts = new VkImageLayout[copy_src.copySrcLayoutCount];
+        memcpy((void*)pCopySrcLayouts, (void*)copy_src.pCopySrcLayouts, sizeof(VkImageLayout) * copy_src.copySrcLayoutCount);
+    }
+
+    if (copy_src.pCopyDstLayouts) {
+        pCopyDstLayouts = new VkImageLayout[copy_src.copyDstLayoutCount];
+        memcpy((void*)pCopyDstLayouts, (void*)copy_src.pCopyDstLayouts, sizeof(VkImageLayout) * copy_src.copyDstLayoutCount);
+    }
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        optimalTilingLayoutUUID[i] = copy_src.optimalTilingLayoutUUID[i];
+    }
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceHostImageCopyPropertiesEXT::~safe_VkPhysicalDeviceHostImageCopyPropertiesEXT() {
+    if (pCopySrcLayouts) delete[] pCopySrcLayouts;
+    if (pCopyDstLayouts) delete[] pCopyDstLayouts;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceHostImageCopyPropertiesEXT::initialize(const VkPhysicalDeviceHostImageCopyPropertiesEXT* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pCopySrcLayouts) delete[] pCopySrcLayouts;
+    if (pCopyDstLayouts) delete[] pCopyDstLayouts;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    copySrcLayoutCount = in_struct->copySrcLayoutCount;
+    pCopySrcLayouts = nullptr;
+    copyDstLayoutCount = in_struct->copyDstLayoutCount;
+    pCopyDstLayouts = nullptr;
+    identicalMemoryTypeRequirements = in_struct->identicalMemoryTypeRequirements;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pCopySrcLayouts) {
+        pCopySrcLayouts = new VkImageLayout[in_struct->copySrcLayoutCount];
+        memcpy((void*)pCopySrcLayouts, (void*)in_struct->pCopySrcLayouts, sizeof(VkImageLayout) * in_struct->copySrcLayoutCount);
+    }
+
+    if (in_struct->pCopyDstLayouts) {
+        pCopyDstLayouts = new VkImageLayout[in_struct->copyDstLayoutCount];
+        memcpy((void*)pCopyDstLayouts, (void*)in_struct->pCopyDstLayouts, sizeof(VkImageLayout) * in_struct->copyDstLayoutCount);
+    }
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        optimalTilingLayoutUUID[i] = in_struct->optimalTilingLayoutUUID[i];
+    }
+}
+
+void safe_VkPhysicalDeviceHostImageCopyPropertiesEXT::initialize(const safe_VkPhysicalDeviceHostImageCopyPropertiesEXT* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    copySrcLayoutCount = copy_src->copySrcLayoutCount;
+    pCopySrcLayouts = nullptr;
+    copyDstLayoutCount = copy_src->copyDstLayoutCount;
+    pCopyDstLayouts = nullptr;
+    identicalMemoryTypeRequirements = copy_src->identicalMemoryTypeRequirements;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pCopySrcLayouts) {
+        pCopySrcLayouts = new VkImageLayout[copy_src->copySrcLayoutCount];
+        memcpy((void*)pCopySrcLayouts, (void*)copy_src->pCopySrcLayouts, sizeof(VkImageLayout) * copy_src->copySrcLayoutCount);
+    }
+
+    if (copy_src->pCopyDstLayouts) {
+        pCopyDstLayouts = new VkImageLayout[copy_src->copyDstLayoutCount];
+        memcpy((void*)pCopyDstLayouts, (void*)copy_src->pCopyDstLayouts, sizeof(VkImageLayout) * copy_src->copyDstLayoutCount);
+    }
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        optimalTilingLayoutUUID[i] = copy_src->optimalTilingLayoutUUID[i];
+    }
+}
+
+safe_VkMemoryToImageCopyEXT::safe_VkMemoryToImageCopyEXT(const VkMemoryToImageCopyEXT* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      pHostPointer(in_struct->pHostPointer),
+      memoryRowLength(in_struct->memoryRowLength),
+      memoryImageHeight(in_struct->memoryImageHeight),
+      imageSubresource(in_struct->imageSubresource),
+      imageOffset(in_struct->imageOffset),
+      imageExtent(in_struct->imageExtent) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMemoryToImageCopyEXT::safe_VkMemoryToImageCopyEXT()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT),
+      pNext(nullptr),
+      pHostPointer(nullptr),
+      memoryRowLength(),
+      memoryImageHeight(),
+      imageSubresource(),
+      imageOffset(),
+      imageExtent() {}
+
+safe_VkMemoryToImageCopyEXT::safe_VkMemoryToImageCopyEXT(const safe_VkMemoryToImageCopyEXT& copy_src) {
+    sType = copy_src.sType;
+    pHostPointer = copy_src.pHostPointer;
+    memoryRowLength = copy_src.memoryRowLength;
+    memoryImageHeight = copy_src.memoryImageHeight;
+    imageSubresource = copy_src.imageSubresource;
+    imageOffset = copy_src.imageOffset;
+    imageExtent = copy_src.imageExtent;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMemoryToImageCopyEXT& safe_VkMemoryToImageCopyEXT::operator=(const safe_VkMemoryToImageCopyEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pHostPointer = copy_src.pHostPointer;
+    memoryRowLength = copy_src.memoryRowLength;
+    memoryImageHeight = copy_src.memoryImageHeight;
+    imageSubresource = copy_src.imageSubresource;
+    imageOffset = copy_src.imageOffset;
+    imageExtent = copy_src.imageExtent;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMemoryToImageCopyEXT::~safe_VkMemoryToImageCopyEXT() { FreePnextChain(pNext); }
+
+void safe_VkMemoryToImageCopyEXT::initialize(const VkMemoryToImageCopyEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pHostPointer = in_struct->pHostPointer;
+    memoryRowLength = in_struct->memoryRowLength;
+    memoryImageHeight = in_struct->memoryImageHeight;
+    imageSubresource = in_struct->imageSubresource;
+    imageOffset = in_struct->imageOffset;
+    imageExtent = in_struct->imageExtent;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMemoryToImageCopyEXT::initialize(const safe_VkMemoryToImageCopyEXT* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pHostPointer = copy_src->pHostPointer;
+    memoryRowLength = copy_src->memoryRowLength;
+    memoryImageHeight = copy_src->memoryImageHeight;
+    imageSubresource = copy_src->imageSubresource;
+    imageOffset = copy_src->imageOffset;
+    imageExtent = copy_src->imageExtent;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkImageToMemoryCopyEXT::safe_VkImageToMemoryCopyEXT(const VkImageToMemoryCopyEXT* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      pHostPointer(in_struct->pHostPointer),
+      memoryRowLength(in_struct->memoryRowLength),
+      memoryImageHeight(in_struct->memoryImageHeight),
+      imageSubresource(in_struct->imageSubresource),
+      imageOffset(in_struct->imageOffset),
+      imageExtent(in_struct->imageExtent) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImageToMemoryCopyEXT::safe_VkImageToMemoryCopyEXT()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT),
+      pNext(nullptr),
+      pHostPointer(nullptr),
+      memoryRowLength(),
+      memoryImageHeight(),
+      imageSubresource(),
+      imageOffset(),
+      imageExtent() {}
+
+safe_VkImageToMemoryCopyEXT::safe_VkImageToMemoryCopyEXT(const safe_VkImageToMemoryCopyEXT& copy_src) {
+    sType = copy_src.sType;
+    pHostPointer = copy_src.pHostPointer;
+    memoryRowLength = copy_src.memoryRowLength;
+    memoryImageHeight = copy_src.memoryImageHeight;
+    imageSubresource = copy_src.imageSubresource;
+    imageOffset = copy_src.imageOffset;
+    imageExtent = copy_src.imageExtent;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImageToMemoryCopyEXT& safe_VkImageToMemoryCopyEXT::operator=(const safe_VkImageToMemoryCopyEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pHostPointer = copy_src.pHostPointer;
+    memoryRowLength = copy_src.memoryRowLength;
+    memoryImageHeight = copy_src.memoryImageHeight;
+    imageSubresource = copy_src.imageSubresource;
+    imageOffset = copy_src.imageOffset;
+    imageExtent = copy_src.imageExtent;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImageToMemoryCopyEXT::~safe_VkImageToMemoryCopyEXT() { FreePnextChain(pNext); }
+
+void safe_VkImageToMemoryCopyEXT::initialize(const VkImageToMemoryCopyEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pHostPointer = in_struct->pHostPointer;
+    memoryRowLength = in_struct->memoryRowLength;
+    memoryImageHeight = in_struct->memoryImageHeight;
+    imageSubresource = in_struct->imageSubresource;
+    imageOffset = in_struct->imageOffset;
+    imageExtent = in_struct->imageExtent;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImageToMemoryCopyEXT::initialize(const safe_VkImageToMemoryCopyEXT* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pHostPointer = copy_src->pHostPointer;
+    memoryRowLength = copy_src->memoryRowLength;
+    memoryImageHeight = copy_src->memoryImageHeight;
+    imageSubresource = copy_src->imageSubresource;
+    imageOffset = copy_src->imageOffset;
+    imageExtent = copy_src->imageExtent;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkCopyMemoryToImageInfoEXT::safe_VkCopyMemoryToImageInfoEXT(const VkCopyMemoryToImageInfoEXT* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      dstImage(in_struct->dstImage),
+      dstImageLayout(in_struct->dstImageLayout),
+      regionCount(in_struct->regionCount),
+      pRegions(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (regionCount && in_struct->pRegions) {
+        pRegions = new safe_VkMemoryToImageCopyEXT[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+safe_VkCopyMemoryToImageInfoEXT::safe_VkCopyMemoryToImageInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT),
+      pNext(nullptr),
+      flags(),
+      dstImage(),
+      dstImageLayout(),
+      regionCount(),
+      pRegions(nullptr) {}
+
+safe_VkCopyMemoryToImageInfoEXT::safe_VkCopyMemoryToImageInfoEXT(const safe_VkCopyMemoryToImageInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    dstImage = copy_src.dstImage;
+    dstImageLayout = copy_src.dstImageLayout;
+    regionCount = copy_src.regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (regionCount && copy_src.pRegions) {
+        pRegions = new safe_VkMemoryToImageCopyEXT[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+}
+
+safe_VkCopyMemoryToImageInfoEXT& safe_VkCopyMemoryToImageInfoEXT::operator=(const safe_VkCopyMemoryToImageInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    dstImage = copy_src.dstImage;
+    dstImageLayout = copy_src.dstImageLayout;
+    regionCount = copy_src.regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (regionCount && copy_src.pRegions) {
+        pRegions = new safe_VkMemoryToImageCopyEXT[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkCopyMemoryToImageInfoEXT::~safe_VkCopyMemoryToImageInfoEXT() {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+}
+
+void safe_VkCopyMemoryToImageInfoEXT::initialize(const VkCopyMemoryToImageInfoEXT* in_struct,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    dstImage = in_struct->dstImage;
+    dstImageLayout = in_struct->dstImageLayout;
+    regionCount = in_struct->regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (regionCount && in_struct->pRegions) {
+        pRegions = new safe_VkMemoryToImageCopyEXT[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+void safe_VkCopyMemoryToImageInfoEXT::initialize(const safe_VkCopyMemoryToImageInfoEXT* copy_src,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    dstImage = copy_src->dstImage;
+    dstImageLayout = copy_src->dstImageLayout;
+    regionCount = copy_src->regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (regionCount && copy_src->pRegions) {
+        pRegions = new safe_VkMemoryToImageCopyEXT[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src->pRegions[i]);
+        }
+    }
+}
+
+safe_VkCopyImageToMemoryInfoEXT::safe_VkCopyImageToMemoryInfoEXT(const VkCopyImageToMemoryInfoEXT* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      srcImage(in_struct->srcImage),
+      srcImageLayout(in_struct->srcImageLayout),
+      regionCount(in_struct->regionCount),
+      pRegions(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (regionCount && in_struct->pRegions) {
+        pRegions = new safe_VkImageToMemoryCopyEXT[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+safe_VkCopyImageToMemoryInfoEXT::safe_VkCopyImageToMemoryInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT),
+      pNext(nullptr),
+      flags(),
+      srcImage(),
+      srcImageLayout(),
+      regionCount(),
+      pRegions(nullptr) {}
+
+safe_VkCopyImageToMemoryInfoEXT::safe_VkCopyImageToMemoryInfoEXT(const safe_VkCopyImageToMemoryInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    srcImage = copy_src.srcImage;
+    srcImageLayout = copy_src.srcImageLayout;
+    regionCount = copy_src.regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (regionCount && copy_src.pRegions) {
+        pRegions = new safe_VkImageToMemoryCopyEXT[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+}
+
+safe_VkCopyImageToMemoryInfoEXT& safe_VkCopyImageToMemoryInfoEXT::operator=(const safe_VkCopyImageToMemoryInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    srcImage = copy_src.srcImage;
+    srcImageLayout = copy_src.srcImageLayout;
+    regionCount = copy_src.regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (regionCount && copy_src.pRegions) {
+        pRegions = new safe_VkImageToMemoryCopyEXT[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkCopyImageToMemoryInfoEXT::~safe_VkCopyImageToMemoryInfoEXT() {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+}
+
+void safe_VkCopyImageToMemoryInfoEXT::initialize(const VkCopyImageToMemoryInfoEXT* in_struct,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    srcImage = in_struct->srcImage;
+    srcImageLayout = in_struct->srcImageLayout;
+    regionCount = in_struct->regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (regionCount && in_struct->pRegions) {
+        pRegions = new safe_VkImageToMemoryCopyEXT[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+void safe_VkCopyImageToMemoryInfoEXT::initialize(const safe_VkCopyImageToMemoryInfoEXT* copy_src,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    srcImage = copy_src->srcImage;
+    srcImageLayout = copy_src->srcImageLayout;
+    regionCount = copy_src->regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (regionCount && copy_src->pRegions) {
+        pRegions = new safe_VkImageToMemoryCopyEXT[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src->pRegions[i]);
+        }
+    }
+}
+
+safe_VkCopyImageToImageInfoEXT::safe_VkCopyImageToImageInfoEXT(const VkCopyImageToImageInfoEXT* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      srcImage(in_struct->srcImage),
+      srcImageLayout(in_struct->srcImageLayout),
+      dstImage(in_struct->dstImage),
+      dstImageLayout(in_struct->dstImageLayout),
+      regionCount(in_struct->regionCount),
+      pRegions(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (regionCount && in_struct->pRegions) {
+        pRegions = new safe_VkImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+safe_VkCopyImageToImageInfoEXT::safe_VkCopyImageToImageInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT),
+      pNext(nullptr),
+      flags(),
+      srcImage(),
+      srcImageLayout(),
+      dstImage(),
+      dstImageLayout(),
+      regionCount(),
+      pRegions(nullptr) {}
+
+safe_VkCopyImageToImageInfoEXT::safe_VkCopyImageToImageInfoEXT(const safe_VkCopyImageToImageInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    srcImage = copy_src.srcImage;
+    srcImageLayout = copy_src.srcImageLayout;
+    dstImage = copy_src.dstImage;
+    dstImageLayout = copy_src.dstImageLayout;
+    regionCount = copy_src.regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (regionCount && copy_src.pRegions) {
+        pRegions = new safe_VkImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+}
+
+safe_VkCopyImageToImageInfoEXT& safe_VkCopyImageToImageInfoEXT::operator=(const safe_VkCopyImageToImageInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    srcImage = copy_src.srcImage;
+    srcImageLayout = copy_src.srcImageLayout;
+    dstImage = copy_src.dstImage;
+    dstImageLayout = copy_src.dstImageLayout;
+    regionCount = copy_src.regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (regionCount && copy_src.pRegions) {
+        pRegions = new safe_VkImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkCopyImageToImageInfoEXT::~safe_VkCopyImageToImageInfoEXT() {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+}
+
+void safe_VkCopyImageToImageInfoEXT::initialize(const VkCopyImageToImageInfoEXT* in_struct,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    srcImage = in_struct->srcImage;
+    srcImageLayout = in_struct->srcImageLayout;
+    dstImage = in_struct->dstImage;
+    dstImageLayout = in_struct->dstImageLayout;
+    regionCount = in_struct->regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (regionCount && in_struct->pRegions) {
+        pRegions = new safe_VkImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+void safe_VkCopyImageToImageInfoEXT::initialize(const safe_VkCopyImageToImageInfoEXT* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    srcImage = copy_src->srcImage;
+    srcImageLayout = copy_src->srcImageLayout;
+    dstImage = copy_src->dstImage;
+    dstImageLayout = copy_src->dstImageLayout;
+    regionCount = copy_src->regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (regionCount && copy_src->pRegions) {
+        pRegions = new safe_VkImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src->pRegions[i]);
+        }
+    }
+}
+
+safe_VkHostImageLayoutTransitionInfoEXT::safe_VkHostImageLayoutTransitionInfoEXT(
+    const VkHostImageLayoutTransitionInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      image(in_struct->image),
+      oldLayout(in_struct->oldLayout),
+      newLayout(in_struct->newLayout),
+      subresourceRange(in_struct->subresourceRange) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkHostImageLayoutTransitionInfoEXT::safe_VkHostImageLayoutTransitionInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT),
+      pNext(nullptr),
+      image(),
+      oldLayout(),
+      newLayout(),
+      subresourceRange() {}
+
+safe_VkHostImageLayoutTransitionInfoEXT::safe_VkHostImageLayoutTransitionInfoEXT(
+    const safe_VkHostImageLayoutTransitionInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    image = copy_src.image;
+    oldLayout = copy_src.oldLayout;
+    newLayout = copy_src.newLayout;
+    subresourceRange = copy_src.subresourceRange;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkHostImageLayoutTransitionInfoEXT& safe_VkHostImageLayoutTransitionInfoEXT::operator=(
+    const safe_VkHostImageLayoutTransitionInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    image = copy_src.image;
+    oldLayout = copy_src.oldLayout;
+    newLayout = copy_src.newLayout;
+    subresourceRange = copy_src.subresourceRange;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkHostImageLayoutTransitionInfoEXT::~safe_VkHostImageLayoutTransitionInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkHostImageLayoutTransitionInfoEXT::initialize(const VkHostImageLayoutTransitionInfoEXT* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    image = in_struct->image;
+    oldLayout = in_struct->oldLayout;
+    newLayout = in_struct->newLayout;
+    subresourceRange = in_struct->subresourceRange;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkHostImageLayoutTransitionInfoEXT::initialize(const safe_VkHostImageLayoutTransitionInfoEXT* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    image = copy_src->image;
+    oldLayout = copy_src->oldLayout;
+    newLayout = copy_src->newLayout;
+    subresourceRange = copy_src->subresourceRange;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSubresourceHostMemcpySizeEXT::safe_VkSubresourceHostMemcpySizeEXT(const VkSubresourceHostMemcpySizeEXT* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType), size(in_struct->size) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSubresourceHostMemcpySizeEXT::safe_VkSubresourceHostMemcpySizeEXT()
+    : sType(VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT), pNext(nullptr), size() {}
+
+safe_VkSubresourceHostMemcpySizeEXT::safe_VkSubresourceHostMemcpySizeEXT(const safe_VkSubresourceHostMemcpySizeEXT& copy_src) {
+    sType = copy_src.sType;
+    size = copy_src.size;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSubresourceHostMemcpySizeEXT& safe_VkSubresourceHostMemcpySizeEXT::operator=(
+    const safe_VkSubresourceHostMemcpySizeEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    size = copy_src.size;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSubresourceHostMemcpySizeEXT::~safe_VkSubresourceHostMemcpySizeEXT() { FreePnextChain(pNext); }
+
+void safe_VkSubresourceHostMemcpySizeEXT::initialize(const VkSubresourceHostMemcpySizeEXT* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    size = in_struct->size;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSubresourceHostMemcpySizeEXT::initialize(const safe_VkSubresourceHostMemcpySizeEXT* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    size = copy_src->size;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkHostImageCopyDevicePerformanceQueryEXT::safe_VkHostImageCopyDevicePerformanceQueryEXT(
+    const VkHostImageCopyDevicePerformanceQueryEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      optimalDeviceAccess(in_struct->optimalDeviceAccess),
+      identicalMemoryLayout(in_struct->identicalMemoryLayout) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkHostImageCopyDevicePerformanceQueryEXT::safe_VkHostImageCopyDevicePerformanceQueryEXT()
+    : sType(VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT),
+      pNext(nullptr),
+      optimalDeviceAccess(),
+      identicalMemoryLayout() {}
+
+safe_VkHostImageCopyDevicePerformanceQueryEXT::safe_VkHostImageCopyDevicePerformanceQueryEXT(
+    const safe_VkHostImageCopyDevicePerformanceQueryEXT& copy_src) {
+    sType = copy_src.sType;
+    optimalDeviceAccess = copy_src.optimalDeviceAccess;
+    identicalMemoryLayout = copy_src.identicalMemoryLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkHostImageCopyDevicePerformanceQueryEXT& safe_VkHostImageCopyDevicePerformanceQueryEXT::operator=(
+    const safe_VkHostImageCopyDevicePerformanceQueryEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    optimalDeviceAccess = copy_src.optimalDeviceAccess;
+    identicalMemoryLayout = copy_src.identicalMemoryLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkHostImageCopyDevicePerformanceQueryEXT::~safe_VkHostImageCopyDevicePerformanceQueryEXT() { FreePnextChain(pNext); }
+
+void safe_VkHostImageCopyDevicePerformanceQueryEXT::initialize(const VkHostImageCopyDevicePerformanceQueryEXT* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    optimalDeviceAccess = in_struct->optimalDeviceAccess;
+    identicalMemoryLayout = in_struct->identicalMemoryLayout;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkHostImageCopyDevicePerformanceQueryEXT::initialize(const safe_VkHostImageCopyDevicePerformanceQueryEXT* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    optimalDeviceAccess = copy_src->optimalDeviceAccess;
+    identicalMemoryLayout = copy_src->identicalMemoryLayout;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT::safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT(
+    const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      memoryMapPlaced(in_struct->memoryMapPlaced),
+      memoryMapRangePlaced(in_struct->memoryMapRangePlaced),
+      memoryUnmapReserve(in_struct->memoryUnmapReserve) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT::safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT),
+      pNext(nullptr),
+      memoryMapPlaced(),
+      memoryMapRangePlaced(),
+      memoryUnmapReserve() {}
+
+safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT::safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT(
+    const safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    memoryMapPlaced = copy_src.memoryMapPlaced;
+    memoryMapRangePlaced = copy_src.memoryMapRangePlaced;
+    memoryUnmapReserve = copy_src.memoryUnmapReserve;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT& safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    memoryMapPlaced = copy_src.memoryMapPlaced;
+    memoryMapRangePlaced = copy_src.memoryMapRangePlaced;
+    memoryUnmapReserve = copy_src.memoryUnmapReserve;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT::~safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT::initialize(const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    memoryMapPlaced = in_struct->memoryMapPlaced;
+    memoryMapRangePlaced = in_struct->memoryMapRangePlaced;
+    memoryUnmapReserve = in_struct->memoryUnmapReserve;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT::initialize(const safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memoryMapPlaced = copy_src->memoryMapPlaced;
+    memoryMapRangePlaced = copy_src->memoryMapRangePlaced;
+    memoryUnmapReserve = copy_src->memoryUnmapReserve;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT::safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT(
+    const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), minPlacedMemoryMapAlignment(in_struct->minPlacedMemoryMapAlignment) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT::safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT), pNext(nullptr), minPlacedMemoryMapAlignment() {}
+
+safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT::safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT(
+    const safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    minPlacedMemoryMapAlignment = copy_src.minPlacedMemoryMapAlignment;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT& safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT::operator=(
+    const safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    minPlacedMemoryMapAlignment = copy_src.minPlacedMemoryMapAlignment;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT::~safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT::initialize(const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    minPlacedMemoryMapAlignment = in_struct->minPlacedMemoryMapAlignment;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT::initialize(
+    const safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    minPlacedMemoryMapAlignment = copy_src->minPlacedMemoryMapAlignment;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkMemoryMapPlacedInfoEXT::safe_VkMemoryMapPlacedInfoEXT(const VkMemoryMapPlacedInfoEXT* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), pPlacedAddress(in_struct->pPlacedAddress) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMemoryMapPlacedInfoEXT::safe_VkMemoryMapPlacedInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT), pNext(nullptr), pPlacedAddress(nullptr) {}
+
+safe_VkMemoryMapPlacedInfoEXT::safe_VkMemoryMapPlacedInfoEXT(const safe_VkMemoryMapPlacedInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    pPlacedAddress = copy_src.pPlacedAddress;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMemoryMapPlacedInfoEXT& safe_VkMemoryMapPlacedInfoEXT::operator=(const safe_VkMemoryMapPlacedInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pPlacedAddress = copy_src.pPlacedAddress;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMemoryMapPlacedInfoEXT::~safe_VkMemoryMapPlacedInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkMemoryMapPlacedInfoEXT::initialize(const VkMemoryMapPlacedInfoEXT* in_struct,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pPlacedAddress = in_struct->pPlacedAddress;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMemoryMapPlacedInfoEXT::initialize(const safe_VkMemoryMapPlacedInfoEXT* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pPlacedAddress = copy_src->pPlacedAddress;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT::safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
+    const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      shaderBufferFloat16Atomics(in_struct->shaderBufferFloat16Atomics),
+      shaderBufferFloat16AtomicAdd(in_struct->shaderBufferFloat16AtomicAdd),
+      shaderBufferFloat16AtomicMinMax(in_struct->shaderBufferFloat16AtomicMinMax),
+      shaderBufferFloat32AtomicMinMax(in_struct->shaderBufferFloat32AtomicMinMax),
+      shaderBufferFloat64AtomicMinMax(in_struct->shaderBufferFloat64AtomicMinMax),
+      shaderSharedFloat16Atomics(in_struct->shaderSharedFloat16Atomics),
+      shaderSharedFloat16AtomicAdd(in_struct->shaderSharedFloat16AtomicAdd),
+      shaderSharedFloat16AtomicMinMax(in_struct->shaderSharedFloat16AtomicMinMax),
+      shaderSharedFloat32AtomicMinMax(in_struct->shaderSharedFloat32AtomicMinMax),
+      shaderSharedFloat64AtomicMinMax(in_struct->shaderSharedFloat64AtomicMinMax),
+      shaderImageFloat32AtomicMinMax(in_struct->shaderImageFloat32AtomicMinMax),
+      sparseImageFloat32AtomicMinMax(in_struct->sparseImageFloat32AtomicMinMax) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT::safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT),
+      pNext(nullptr),
+      shaderBufferFloat16Atomics(),
+      shaderBufferFloat16AtomicAdd(),
+      shaderBufferFloat16AtomicMinMax(),
+      shaderBufferFloat32AtomicMinMax(),
+      shaderBufferFloat64AtomicMinMax(),
+      shaderSharedFloat16Atomics(),
+      shaderSharedFloat16AtomicAdd(),
+      shaderSharedFloat16AtomicMinMax(),
+      shaderSharedFloat32AtomicMinMax(),
+      shaderSharedFloat64AtomicMinMax(),
+      shaderImageFloat32AtomicMinMax(),
+      sparseImageFloat32AtomicMinMax() {}
+
+safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT::safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
+    const safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    shaderBufferFloat16Atomics = copy_src.shaderBufferFloat16Atomics;
+    shaderBufferFloat16AtomicAdd = copy_src.shaderBufferFloat16AtomicAdd;
+    shaderBufferFloat16AtomicMinMax = copy_src.shaderBufferFloat16AtomicMinMax;
+    shaderBufferFloat32AtomicMinMax = copy_src.shaderBufferFloat32AtomicMinMax;
+    shaderBufferFloat64AtomicMinMax = copy_src.shaderBufferFloat64AtomicMinMax;
+    shaderSharedFloat16Atomics = copy_src.shaderSharedFloat16Atomics;
+    shaderSharedFloat16AtomicAdd = copy_src.shaderSharedFloat16AtomicAdd;
+    shaderSharedFloat16AtomicMinMax = copy_src.shaderSharedFloat16AtomicMinMax;
+    shaderSharedFloat32AtomicMinMax = copy_src.shaderSharedFloat32AtomicMinMax;
+    shaderSharedFloat64AtomicMinMax = copy_src.shaderSharedFloat64AtomicMinMax;
+    shaderImageFloat32AtomicMinMax = copy_src.shaderImageFloat32AtomicMinMax;
+    sparseImageFloat32AtomicMinMax = copy_src.sparseImageFloat32AtomicMinMax;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT& safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderBufferFloat16Atomics = copy_src.shaderBufferFloat16Atomics;
+    shaderBufferFloat16AtomicAdd = copy_src.shaderBufferFloat16AtomicAdd;
+    shaderBufferFloat16AtomicMinMax = copy_src.shaderBufferFloat16AtomicMinMax;
+    shaderBufferFloat32AtomicMinMax = copy_src.shaderBufferFloat32AtomicMinMax;
+    shaderBufferFloat64AtomicMinMax = copy_src.shaderBufferFloat64AtomicMinMax;
+    shaderSharedFloat16Atomics = copy_src.shaderSharedFloat16Atomics;
+    shaderSharedFloat16AtomicAdd = copy_src.shaderSharedFloat16AtomicAdd;
+    shaderSharedFloat16AtomicMinMax = copy_src.shaderSharedFloat16AtomicMinMax;
+    shaderSharedFloat32AtomicMinMax = copy_src.shaderSharedFloat32AtomicMinMax;
+    shaderSharedFloat64AtomicMinMax = copy_src.shaderSharedFloat64AtomicMinMax;
+    shaderImageFloat32AtomicMinMax = copy_src.shaderImageFloat32AtomicMinMax;
+    sparseImageFloat32AtomicMinMax = copy_src.sparseImageFloat32AtomicMinMax;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT::~safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT::initialize(const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderBufferFloat16Atomics = in_struct->shaderBufferFloat16Atomics;
+    shaderBufferFloat16AtomicAdd = in_struct->shaderBufferFloat16AtomicAdd;
+    shaderBufferFloat16AtomicMinMax = in_struct->shaderBufferFloat16AtomicMinMax;
+    shaderBufferFloat32AtomicMinMax = in_struct->shaderBufferFloat32AtomicMinMax;
+    shaderBufferFloat64AtomicMinMax = in_struct->shaderBufferFloat64AtomicMinMax;
+    shaderSharedFloat16Atomics = in_struct->shaderSharedFloat16Atomics;
+    shaderSharedFloat16AtomicAdd = in_struct->shaderSharedFloat16AtomicAdd;
+    shaderSharedFloat16AtomicMinMax = in_struct->shaderSharedFloat16AtomicMinMax;
+    shaderSharedFloat32AtomicMinMax = in_struct->shaderSharedFloat32AtomicMinMax;
+    shaderSharedFloat64AtomicMinMax = in_struct->shaderSharedFloat64AtomicMinMax;
+    shaderImageFloat32AtomicMinMax = in_struct->shaderImageFloat32AtomicMinMax;
+    sparseImageFloat32AtomicMinMax = in_struct->sparseImageFloat32AtomicMinMax;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderBufferFloat16Atomics = copy_src->shaderBufferFloat16Atomics;
+    shaderBufferFloat16AtomicAdd = copy_src->shaderBufferFloat16AtomicAdd;
+    shaderBufferFloat16AtomicMinMax = copy_src->shaderBufferFloat16AtomicMinMax;
+    shaderBufferFloat32AtomicMinMax = copy_src->shaderBufferFloat32AtomicMinMax;
+    shaderBufferFloat64AtomicMinMax = copy_src->shaderBufferFloat64AtomicMinMax;
+    shaderSharedFloat16Atomics = copy_src->shaderSharedFloat16Atomics;
+    shaderSharedFloat16AtomicAdd = copy_src->shaderSharedFloat16AtomicAdd;
+    shaderSharedFloat16AtomicMinMax = copy_src->shaderSharedFloat16AtomicMinMax;
+    shaderSharedFloat32AtomicMinMax = copy_src->shaderSharedFloat32AtomicMinMax;
+    shaderSharedFloat64AtomicMinMax = copy_src->shaderSharedFloat64AtomicMinMax;
+    shaderImageFloat32AtomicMinMax = copy_src->shaderImageFloat32AtomicMinMax;
+    sparseImageFloat32AtomicMinMax = copy_src->sparseImageFloat32AtomicMinMax;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSurfacePresentModeEXT::safe_VkSurfacePresentModeEXT(const VkSurfacePresentModeEXT* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), presentMode(in_struct->presentMode) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSurfacePresentModeEXT::safe_VkSurfacePresentModeEXT()
+    : sType(VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT), pNext(nullptr), presentMode() {}
+
+safe_VkSurfacePresentModeEXT::safe_VkSurfacePresentModeEXT(const safe_VkSurfacePresentModeEXT& copy_src) {
+    sType = copy_src.sType;
+    presentMode = copy_src.presentMode;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSurfacePresentModeEXT& safe_VkSurfacePresentModeEXT::operator=(const safe_VkSurfacePresentModeEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    presentMode = copy_src.presentMode;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSurfacePresentModeEXT::~safe_VkSurfacePresentModeEXT() { FreePnextChain(pNext); }
+
+void safe_VkSurfacePresentModeEXT::initialize(const VkSurfacePresentModeEXT* in_struct,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    presentMode = in_struct->presentMode;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSurfacePresentModeEXT::initialize(const safe_VkSurfacePresentModeEXT* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    presentMode = copy_src->presentMode;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSurfacePresentScalingCapabilitiesEXT::safe_VkSurfacePresentScalingCapabilitiesEXT(
+    const VkSurfacePresentScalingCapabilitiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      supportedPresentScaling(in_struct->supportedPresentScaling),
+      supportedPresentGravityX(in_struct->supportedPresentGravityX),
+      supportedPresentGravityY(in_struct->supportedPresentGravityY),
+      minScaledImageExtent(in_struct->minScaledImageExtent),
+      maxScaledImageExtent(in_struct->maxScaledImageExtent) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSurfacePresentScalingCapabilitiesEXT::safe_VkSurfacePresentScalingCapabilitiesEXT()
+    : sType(VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT),
+      pNext(nullptr),
+      supportedPresentScaling(),
+      supportedPresentGravityX(),
+      supportedPresentGravityY(),
+      minScaledImageExtent(),
+      maxScaledImageExtent() {}
+
+safe_VkSurfacePresentScalingCapabilitiesEXT::safe_VkSurfacePresentScalingCapabilitiesEXT(
+    const safe_VkSurfacePresentScalingCapabilitiesEXT& copy_src) {
+    sType = copy_src.sType;
+    supportedPresentScaling = copy_src.supportedPresentScaling;
+    supportedPresentGravityX = copy_src.supportedPresentGravityX;
+    supportedPresentGravityY = copy_src.supportedPresentGravityY;
+    minScaledImageExtent = copy_src.minScaledImageExtent;
+    maxScaledImageExtent = copy_src.maxScaledImageExtent;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSurfacePresentScalingCapabilitiesEXT& safe_VkSurfacePresentScalingCapabilitiesEXT::operator=(
+    const safe_VkSurfacePresentScalingCapabilitiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    supportedPresentScaling = copy_src.supportedPresentScaling;
+    supportedPresentGravityX = copy_src.supportedPresentGravityX;
+    supportedPresentGravityY = copy_src.supportedPresentGravityY;
+    minScaledImageExtent = copy_src.minScaledImageExtent;
+    maxScaledImageExtent = copy_src.maxScaledImageExtent;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSurfacePresentScalingCapabilitiesEXT::~safe_VkSurfacePresentScalingCapabilitiesEXT() { FreePnextChain(pNext); }
+
+void safe_VkSurfacePresentScalingCapabilitiesEXT::initialize(const VkSurfacePresentScalingCapabilitiesEXT* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    supportedPresentScaling = in_struct->supportedPresentScaling;
+    supportedPresentGravityX = in_struct->supportedPresentGravityX;
+    supportedPresentGravityY = in_struct->supportedPresentGravityY;
+    minScaledImageExtent = in_struct->minScaledImageExtent;
+    maxScaledImageExtent = in_struct->maxScaledImageExtent;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSurfacePresentScalingCapabilitiesEXT::initialize(const safe_VkSurfacePresentScalingCapabilitiesEXT* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    supportedPresentScaling = copy_src->supportedPresentScaling;
+    supportedPresentGravityX = copy_src->supportedPresentGravityX;
+    supportedPresentGravityY = copy_src->supportedPresentGravityY;
+    minScaledImageExtent = copy_src->minScaledImageExtent;
+    maxScaledImageExtent = copy_src->maxScaledImageExtent;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSurfacePresentModeCompatibilityEXT::safe_VkSurfacePresentModeCompatibilityEXT(
+    const VkSurfacePresentModeCompatibilityEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), presentModeCount(in_struct->presentModeCount), pPresentModes(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pPresentModes) {
+        pPresentModes = new VkPresentModeKHR[in_struct->presentModeCount];
+        memcpy((void*)pPresentModes, (void*)in_struct->pPresentModes, sizeof(VkPresentModeKHR) * in_struct->presentModeCount);
+    }
+}
+
+safe_VkSurfacePresentModeCompatibilityEXT::safe_VkSurfacePresentModeCompatibilityEXT()
+    : sType(VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT), pNext(nullptr), presentModeCount(), pPresentModes(nullptr) {}
+
+safe_VkSurfacePresentModeCompatibilityEXT::safe_VkSurfacePresentModeCompatibilityEXT(
+    const safe_VkSurfacePresentModeCompatibilityEXT& copy_src) {
+    sType = copy_src.sType;
+    presentModeCount = copy_src.presentModeCount;
+    pPresentModes = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pPresentModes) {
+        pPresentModes = new VkPresentModeKHR[copy_src.presentModeCount];
+        memcpy((void*)pPresentModes, (void*)copy_src.pPresentModes, sizeof(VkPresentModeKHR) * copy_src.presentModeCount);
+    }
+}
+
+safe_VkSurfacePresentModeCompatibilityEXT& safe_VkSurfacePresentModeCompatibilityEXT::operator=(
+    const safe_VkSurfacePresentModeCompatibilityEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pPresentModes) delete[] pPresentModes;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    presentModeCount = copy_src.presentModeCount;
+    pPresentModes = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pPresentModes) {
+        pPresentModes = new VkPresentModeKHR[copy_src.presentModeCount];
+        memcpy((void*)pPresentModes, (void*)copy_src.pPresentModes, sizeof(VkPresentModeKHR) * copy_src.presentModeCount);
+    }
+
+    return *this;
+}
+
+safe_VkSurfacePresentModeCompatibilityEXT::~safe_VkSurfacePresentModeCompatibilityEXT() {
+    if (pPresentModes) delete[] pPresentModes;
+    FreePnextChain(pNext);
+}
+
+void safe_VkSurfacePresentModeCompatibilityEXT::initialize(const VkSurfacePresentModeCompatibilityEXT* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pPresentModes) delete[] pPresentModes;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    presentModeCount = in_struct->presentModeCount;
+    pPresentModes = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pPresentModes) {
+        pPresentModes = new VkPresentModeKHR[in_struct->presentModeCount];
+        memcpy((void*)pPresentModes, (void*)in_struct->pPresentModes, sizeof(VkPresentModeKHR) * in_struct->presentModeCount);
+    }
+}
+
+void safe_VkSurfacePresentModeCompatibilityEXT::initialize(const safe_VkSurfacePresentModeCompatibilityEXT* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    presentModeCount = copy_src->presentModeCount;
+    pPresentModes = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pPresentModes) {
+        pPresentModes = new VkPresentModeKHR[copy_src->presentModeCount];
+        memcpy((void*)pPresentModes, (void*)copy_src->pPresentModes, sizeof(VkPresentModeKHR) * copy_src->presentModeCount);
+    }
+}
+
+safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT::safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
+    const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), swapchainMaintenance1(in_struct->swapchainMaintenance1) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT::safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT), pNext(nullptr), swapchainMaintenance1() {}
+
+safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT::safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
+    const safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    swapchainMaintenance1 = copy_src.swapchainMaintenance1;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT& safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    swapchainMaintenance1 = copy_src.swapchainMaintenance1;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT::~safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT::initialize(
+    const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    swapchainMaintenance1 = in_struct->swapchainMaintenance1;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    swapchainMaintenance1 = copy_src->swapchainMaintenance1;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSwapchainPresentFenceInfoEXT::safe_VkSwapchainPresentFenceInfoEXT(const VkSwapchainPresentFenceInfoEXT* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType), swapchainCount(in_struct->swapchainCount), pFences(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (swapchainCount && in_struct->pFences) {
+        pFences = new VkFence[swapchainCount];
+        for (uint32_t i = 0; i < swapchainCount; ++i) {
+            pFences[i] = in_struct->pFences[i];
+        }
+    }
+}
+
+safe_VkSwapchainPresentFenceInfoEXT::safe_VkSwapchainPresentFenceInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT), pNext(nullptr), swapchainCount(), pFences(nullptr) {}
+
+safe_VkSwapchainPresentFenceInfoEXT::safe_VkSwapchainPresentFenceInfoEXT(const safe_VkSwapchainPresentFenceInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    swapchainCount = copy_src.swapchainCount;
+    pFences = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (swapchainCount && copy_src.pFences) {
+        pFences = new VkFence[swapchainCount];
+        for (uint32_t i = 0; i < swapchainCount; ++i) {
+            pFences[i] = copy_src.pFences[i];
+        }
+    }
+}
+
+safe_VkSwapchainPresentFenceInfoEXT& safe_VkSwapchainPresentFenceInfoEXT::operator=(
+    const safe_VkSwapchainPresentFenceInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pFences) delete[] pFences;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    swapchainCount = copy_src.swapchainCount;
+    pFences = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (swapchainCount && copy_src.pFences) {
+        pFences = new VkFence[swapchainCount];
+        for (uint32_t i = 0; i < swapchainCount; ++i) {
+            pFences[i] = copy_src.pFences[i];
+        }
+    }
+
+    return *this;
+}
+
+safe_VkSwapchainPresentFenceInfoEXT::~safe_VkSwapchainPresentFenceInfoEXT() {
+    if (pFences) delete[] pFences;
+    FreePnextChain(pNext);
+}
+
+void safe_VkSwapchainPresentFenceInfoEXT::initialize(const VkSwapchainPresentFenceInfoEXT* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pFences) delete[] pFences;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    swapchainCount = in_struct->swapchainCount;
+    pFences = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (swapchainCount && in_struct->pFences) {
+        pFences = new VkFence[swapchainCount];
+        for (uint32_t i = 0; i < swapchainCount; ++i) {
+            pFences[i] = in_struct->pFences[i];
+        }
+    }
+}
+
+void safe_VkSwapchainPresentFenceInfoEXT::initialize(const safe_VkSwapchainPresentFenceInfoEXT* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    swapchainCount = copy_src->swapchainCount;
+    pFences = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (swapchainCount && copy_src->pFences) {
+        pFences = new VkFence[swapchainCount];
+        for (uint32_t i = 0; i < swapchainCount; ++i) {
+            pFences[i] = copy_src->pFences[i];
+        }
+    }
+}
+
+safe_VkSwapchainPresentModesCreateInfoEXT::safe_VkSwapchainPresentModesCreateInfoEXT(
+    const VkSwapchainPresentModesCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), presentModeCount(in_struct->presentModeCount), pPresentModes(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pPresentModes) {
+        pPresentModes = new VkPresentModeKHR[in_struct->presentModeCount];
+        memcpy((void*)pPresentModes, (void*)in_struct->pPresentModes, sizeof(VkPresentModeKHR) * in_struct->presentModeCount);
+    }
+}
+
+safe_VkSwapchainPresentModesCreateInfoEXT::safe_VkSwapchainPresentModesCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT),
+      pNext(nullptr),
+      presentModeCount(),
+      pPresentModes(nullptr) {}
+
+safe_VkSwapchainPresentModesCreateInfoEXT::safe_VkSwapchainPresentModesCreateInfoEXT(
+    const safe_VkSwapchainPresentModesCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    presentModeCount = copy_src.presentModeCount;
+    pPresentModes = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pPresentModes) {
+        pPresentModes = new VkPresentModeKHR[copy_src.presentModeCount];
+        memcpy((void*)pPresentModes, (void*)copy_src.pPresentModes, sizeof(VkPresentModeKHR) * copy_src.presentModeCount);
+    }
+}
+
+safe_VkSwapchainPresentModesCreateInfoEXT& safe_VkSwapchainPresentModesCreateInfoEXT::operator=(
+    const safe_VkSwapchainPresentModesCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pPresentModes) delete[] pPresentModes;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    presentModeCount = copy_src.presentModeCount;
+    pPresentModes = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pPresentModes) {
+        pPresentModes = new VkPresentModeKHR[copy_src.presentModeCount];
+        memcpy((void*)pPresentModes, (void*)copy_src.pPresentModes, sizeof(VkPresentModeKHR) * copy_src.presentModeCount);
+    }
+
+    return *this;
+}
+
+safe_VkSwapchainPresentModesCreateInfoEXT::~safe_VkSwapchainPresentModesCreateInfoEXT() {
+    if (pPresentModes) delete[] pPresentModes;
+    FreePnextChain(pNext);
+}
+
+void safe_VkSwapchainPresentModesCreateInfoEXT::initialize(const VkSwapchainPresentModesCreateInfoEXT* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pPresentModes) delete[] pPresentModes;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    presentModeCount = in_struct->presentModeCount;
+    pPresentModes = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pPresentModes) {
+        pPresentModes = new VkPresentModeKHR[in_struct->presentModeCount];
+        memcpy((void*)pPresentModes, (void*)in_struct->pPresentModes, sizeof(VkPresentModeKHR) * in_struct->presentModeCount);
+    }
+}
+
+void safe_VkSwapchainPresentModesCreateInfoEXT::initialize(const safe_VkSwapchainPresentModesCreateInfoEXT* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    presentModeCount = copy_src->presentModeCount;
+    pPresentModes = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pPresentModes) {
+        pPresentModes = new VkPresentModeKHR[copy_src->presentModeCount];
+        memcpy((void*)pPresentModes, (void*)copy_src->pPresentModes, sizeof(VkPresentModeKHR) * copy_src->presentModeCount);
+    }
+}
+
+safe_VkSwapchainPresentModeInfoEXT::safe_VkSwapchainPresentModeInfoEXT(const VkSwapchainPresentModeInfoEXT* in_struct,
+                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), swapchainCount(in_struct->swapchainCount), pPresentModes(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pPresentModes) {
+        pPresentModes = new VkPresentModeKHR[in_struct->swapchainCount];
+        memcpy((void*)pPresentModes, (void*)in_struct->pPresentModes, sizeof(VkPresentModeKHR) * in_struct->swapchainCount);
+    }
+}
+
+safe_VkSwapchainPresentModeInfoEXT::safe_VkSwapchainPresentModeInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT), pNext(nullptr), swapchainCount(), pPresentModes(nullptr) {}
+
+safe_VkSwapchainPresentModeInfoEXT::safe_VkSwapchainPresentModeInfoEXT(const safe_VkSwapchainPresentModeInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    swapchainCount = copy_src.swapchainCount;
+    pPresentModes = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pPresentModes) {
+        pPresentModes = new VkPresentModeKHR[copy_src.swapchainCount];
+        memcpy((void*)pPresentModes, (void*)copy_src.pPresentModes, sizeof(VkPresentModeKHR) * copy_src.swapchainCount);
+    }
+}
+
+safe_VkSwapchainPresentModeInfoEXT& safe_VkSwapchainPresentModeInfoEXT::operator=(
+    const safe_VkSwapchainPresentModeInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pPresentModes) delete[] pPresentModes;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    swapchainCount = copy_src.swapchainCount;
+    pPresentModes = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pPresentModes) {
+        pPresentModes = new VkPresentModeKHR[copy_src.swapchainCount];
+        memcpy((void*)pPresentModes, (void*)copy_src.pPresentModes, sizeof(VkPresentModeKHR) * copy_src.swapchainCount);
+    }
+
+    return *this;
+}
+
+safe_VkSwapchainPresentModeInfoEXT::~safe_VkSwapchainPresentModeInfoEXT() {
+    if (pPresentModes) delete[] pPresentModes;
+    FreePnextChain(pNext);
+}
+
+void safe_VkSwapchainPresentModeInfoEXT::initialize(const VkSwapchainPresentModeInfoEXT* in_struct,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pPresentModes) delete[] pPresentModes;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    swapchainCount = in_struct->swapchainCount;
+    pPresentModes = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pPresentModes) {
+        pPresentModes = new VkPresentModeKHR[in_struct->swapchainCount];
+        memcpy((void*)pPresentModes, (void*)in_struct->pPresentModes, sizeof(VkPresentModeKHR) * in_struct->swapchainCount);
+    }
+}
+
+void safe_VkSwapchainPresentModeInfoEXT::initialize(const safe_VkSwapchainPresentModeInfoEXT* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    swapchainCount = copy_src->swapchainCount;
+    pPresentModes = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pPresentModes) {
+        pPresentModes = new VkPresentModeKHR[copy_src->swapchainCount];
+        memcpy((void*)pPresentModes, (void*)copy_src->pPresentModes, sizeof(VkPresentModeKHR) * copy_src->swapchainCount);
+    }
+}
+
+safe_VkSwapchainPresentScalingCreateInfoEXT::safe_VkSwapchainPresentScalingCreateInfoEXT(
+    const VkSwapchainPresentScalingCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      scalingBehavior(in_struct->scalingBehavior),
+      presentGravityX(in_struct->presentGravityX),
+      presentGravityY(in_struct->presentGravityY) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSwapchainPresentScalingCreateInfoEXT::safe_VkSwapchainPresentScalingCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT),
+      pNext(nullptr),
+      scalingBehavior(),
+      presentGravityX(),
+      presentGravityY() {}
+
+safe_VkSwapchainPresentScalingCreateInfoEXT::safe_VkSwapchainPresentScalingCreateInfoEXT(
+    const safe_VkSwapchainPresentScalingCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    scalingBehavior = copy_src.scalingBehavior;
+    presentGravityX = copy_src.presentGravityX;
+    presentGravityY = copy_src.presentGravityY;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSwapchainPresentScalingCreateInfoEXT& safe_VkSwapchainPresentScalingCreateInfoEXT::operator=(
+    const safe_VkSwapchainPresentScalingCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    scalingBehavior = copy_src.scalingBehavior;
+    presentGravityX = copy_src.presentGravityX;
+    presentGravityY = copy_src.presentGravityY;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSwapchainPresentScalingCreateInfoEXT::~safe_VkSwapchainPresentScalingCreateInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkSwapchainPresentScalingCreateInfoEXT::initialize(const VkSwapchainPresentScalingCreateInfoEXT* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    scalingBehavior = in_struct->scalingBehavior;
+    presentGravityX = in_struct->presentGravityX;
+    presentGravityY = in_struct->presentGravityY;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSwapchainPresentScalingCreateInfoEXT::initialize(const safe_VkSwapchainPresentScalingCreateInfoEXT* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    scalingBehavior = copy_src->scalingBehavior;
+    presentGravityX = copy_src->presentGravityX;
+    presentGravityY = copy_src->presentGravityY;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkReleaseSwapchainImagesInfoEXT::safe_VkReleaseSwapchainImagesInfoEXT(const VkReleaseSwapchainImagesInfoEXT* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType),
+      swapchain(in_struct->swapchain),
+      imageIndexCount(in_struct->imageIndexCount),
+      pImageIndices(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pImageIndices) {
+        pImageIndices = new uint32_t[in_struct->imageIndexCount];
+        memcpy((void*)pImageIndices, (void*)in_struct->pImageIndices, sizeof(uint32_t) * in_struct->imageIndexCount);
+    }
+}
+
+safe_VkReleaseSwapchainImagesInfoEXT::safe_VkReleaseSwapchainImagesInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT),
+      pNext(nullptr),
+      swapchain(),
+      imageIndexCount(),
+      pImageIndices(nullptr) {}
+
+safe_VkReleaseSwapchainImagesInfoEXT::safe_VkReleaseSwapchainImagesInfoEXT(const safe_VkReleaseSwapchainImagesInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    swapchain = copy_src.swapchain;
+    imageIndexCount = copy_src.imageIndexCount;
+    pImageIndices = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pImageIndices) {
+        pImageIndices = new uint32_t[copy_src.imageIndexCount];
+        memcpy((void*)pImageIndices, (void*)copy_src.pImageIndices, sizeof(uint32_t) * copy_src.imageIndexCount);
+    }
+}
+
+safe_VkReleaseSwapchainImagesInfoEXT& safe_VkReleaseSwapchainImagesInfoEXT::operator=(
+    const safe_VkReleaseSwapchainImagesInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pImageIndices) delete[] pImageIndices;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    swapchain = copy_src.swapchain;
+    imageIndexCount = copy_src.imageIndexCount;
+    pImageIndices = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pImageIndices) {
+        pImageIndices = new uint32_t[copy_src.imageIndexCount];
+        memcpy((void*)pImageIndices, (void*)copy_src.pImageIndices, sizeof(uint32_t) * copy_src.imageIndexCount);
+    }
+
+    return *this;
+}
+
+safe_VkReleaseSwapchainImagesInfoEXT::~safe_VkReleaseSwapchainImagesInfoEXT() {
+    if (pImageIndices) delete[] pImageIndices;
+    FreePnextChain(pNext);
+}
+
+void safe_VkReleaseSwapchainImagesInfoEXT::initialize(const VkReleaseSwapchainImagesInfoEXT* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pImageIndices) delete[] pImageIndices;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    swapchain = in_struct->swapchain;
+    imageIndexCount = in_struct->imageIndexCount;
+    pImageIndices = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pImageIndices) {
+        pImageIndices = new uint32_t[in_struct->imageIndexCount];
+        memcpy((void*)pImageIndices, (void*)in_struct->pImageIndices, sizeof(uint32_t) * in_struct->imageIndexCount);
+    }
+}
+
+void safe_VkReleaseSwapchainImagesInfoEXT::initialize(const safe_VkReleaseSwapchainImagesInfoEXT* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    swapchain = copy_src->swapchain;
+    imageIndexCount = copy_src->imageIndexCount;
+    pImageIndices = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pImageIndices) {
+        pImageIndices = new uint32_t[copy_src->imageIndexCount];
+        memcpy((void*)pImageIndices, (void*)copy_src->pImageIndices, sizeof(uint32_t) * copy_src->imageIndexCount);
+    }
+}
+
+safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
+    const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), texelBufferAlignment(in_struct->texelBufferAlignment) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT), pNext(nullptr), texelBufferAlignment() {}
+
+safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
+    const safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    texelBufferAlignment = copy_src.texelBufferAlignment;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    texelBufferAlignment = copy_src.texelBufferAlignment;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::~safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::initialize(
+    const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    texelBufferAlignment = in_struct->texelBufferAlignment;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    texelBufferAlignment = copy_src->texelBufferAlignment;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT::safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT(
+    const VkPhysicalDeviceDepthBiasControlFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      depthBiasControl(in_struct->depthBiasControl),
+      leastRepresentableValueForceUnormRepresentation(in_struct->leastRepresentableValueForceUnormRepresentation),
+      floatRepresentation(in_struct->floatRepresentation),
+      depthBiasExact(in_struct->depthBiasExact) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT::safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT),
+      pNext(nullptr),
+      depthBiasControl(),
+      leastRepresentableValueForceUnormRepresentation(),
+      floatRepresentation(),
+      depthBiasExact() {}
+
+safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT::safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT(
+    const safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    depthBiasControl = copy_src.depthBiasControl;
+    leastRepresentableValueForceUnormRepresentation = copy_src.leastRepresentableValueForceUnormRepresentation;
+    floatRepresentation = copy_src.floatRepresentation;
+    depthBiasExact = copy_src.depthBiasExact;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT& safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    depthBiasControl = copy_src.depthBiasControl;
+    leastRepresentableValueForceUnormRepresentation = copy_src.leastRepresentableValueForceUnormRepresentation;
+    floatRepresentation = copy_src.floatRepresentation;
+    depthBiasExact = copy_src.depthBiasExact;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT::~safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT::initialize(const VkPhysicalDeviceDepthBiasControlFeaturesEXT* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    depthBiasControl = in_struct->depthBiasControl;
+    leastRepresentableValueForceUnormRepresentation = in_struct->leastRepresentableValueForceUnormRepresentation;
+    floatRepresentation = in_struct->floatRepresentation;
+    depthBiasExact = in_struct->depthBiasExact;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT::initialize(const safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    depthBiasControl = copy_src->depthBiasControl;
+    leastRepresentableValueForceUnormRepresentation = copy_src->leastRepresentableValueForceUnormRepresentation;
+    floatRepresentation = copy_src->floatRepresentation;
+    depthBiasExact = copy_src->depthBiasExact;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDepthBiasInfoEXT::safe_VkDepthBiasInfoEXT(const VkDepthBiasInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                                 bool copy_pnext)
+    : sType(in_struct->sType),
+      depthBiasConstantFactor(in_struct->depthBiasConstantFactor),
+      depthBiasClamp(in_struct->depthBiasClamp),
+      depthBiasSlopeFactor(in_struct->depthBiasSlopeFactor) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDepthBiasInfoEXT::safe_VkDepthBiasInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT),
+      pNext(nullptr),
+      depthBiasConstantFactor(),
+      depthBiasClamp(),
+      depthBiasSlopeFactor() {}
+
+safe_VkDepthBiasInfoEXT::safe_VkDepthBiasInfoEXT(const safe_VkDepthBiasInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    depthBiasConstantFactor = copy_src.depthBiasConstantFactor;
+    depthBiasClamp = copy_src.depthBiasClamp;
+    depthBiasSlopeFactor = copy_src.depthBiasSlopeFactor;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDepthBiasInfoEXT& safe_VkDepthBiasInfoEXT::operator=(const safe_VkDepthBiasInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    depthBiasConstantFactor = copy_src.depthBiasConstantFactor;
+    depthBiasClamp = copy_src.depthBiasClamp;
+    depthBiasSlopeFactor = copy_src.depthBiasSlopeFactor;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDepthBiasInfoEXT::~safe_VkDepthBiasInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkDepthBiasInfoEXT::initialize(const VkDepthBiasInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    depthBiasConstantFactor = in_struct->depthBiasConstantFactor;
+    depthBiasClamp = in_struct->depthBiasClamp;
+    depthBiasSlopeFactor = in_struct->depthBiasSlopeFactor;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDepthBiasInfoEXT::initialize(const safe_VkDepthBiasInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    depthBiasConstantFactor = copy_src->depthBiasConstantFactor;
+    depthBiasClamp = copy_src->depthBiasClamp;
+    depthBiasSlopeFactor = copy_src->depthBiasSlopeFactor;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDepthBiasRepresentationInfoEXT::safe_VkDepthBiasRepresentationInfoEXT(const VkDepthBiasRepresentationInfoEXT* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType),
+      depthBiasRepresentation(in_struct->depthBiasRepresentation),
+      depthBiasExact(in_struct->depthBiasExact) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDepthBiasRepresentationInfoEXT::safe_VkDepthBiasRepresentationInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT), pNext(nullptr), depthBiasRepresentation(), depthBiasExact() {}
+
+safe_VkDepthBiasRepresentationInfoEXT::safe_VkDepthBiasRepresentationInfoEXT(
+    const safe_VkDepthBiasRepresentationInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    depthBiasRepresentation = copy_src.depthBiasRepresentation;
+    depthBiasExact = copy_src.depthBiasExact;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDepthBiasRepresentationInfoEXT& safe_VkDepthBiasRepresentationInfoEXT::operator=(
+    const safe_VkDepthBiasRepresentationInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    depthBiasRepresentation = copy_src.depthBiasRepresentation;
+    depthBiasExact = copy_src.depthBiasExact;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDepthBiasRepresentationInfoEXT::~safe_VkDepthBiasRepresentationInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkDepthBiasRepresentationInfoEXT::initialize(const VkDepthBiasRepresentationInfoEXT* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    depthBiasRepresentation = in_struct->depthBiasRepresentation;
+    depthBiasExact = in_struct->depthBiasExact;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDepthBiasRepresentationInfoEXT::initialize(const safe_VkDepthBiasRepresentationInfoEXT* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    depthBiasRepresentation = copy_src->depthBiasRepresentation;
+    depthBiasExact = copy_src->depthBiasExact;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT::safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
+    const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), deviceMemoryReport(in_struct->deviceMemoryReport) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT::safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT), pNext(nullptr), deviceMemoryReport() {}
+
+safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT::safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
+    const safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    deviceMemoryReport = copy_src.deviceMemoryReport;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT& safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    deviceMemoryReport = copy_src.deviceMemoryReport;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT::~safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT::initialize(const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    deviceMemoryReport = in_struct->deviceMemoryReport;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    deviceMemoryReport = copy_src->deviceMemoryReport;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDeviceMemoryReportCallbackDataEXT::safe_VkDeviceMemoryReportCallbackDataEXT(
+    const VkDeviceMemoryReportCallbackDataEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      type(in_struct->type),
+      memoryObjectId(in_struct->memoryObjectId),
+      size(in_struct->size),
+      objectType(in_struct->objectType),
+      objectHandle(in_struct->objectHandle),
+      heapIndex(in_struct->heapIndex) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDeviceMemoryReportCallbackDataEXT::safe_VkDeviceMemoryReportCallbackDataEXT()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT),
+      pNext(nullptr),
+      flags(),
+      type(),
+      memoryObjectId(),
+      size(),
+      objectType(),
+      objectHandle(),
+      heapIndex() {}
+
+safe_VkDeviceMemoryReportCallbackDataEXT::safe_VkDeviceMemoryReportCallbackDataEXT(
+    const safe_VkDeviceMemoryReportCallbackDataEXT& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    type = copy_src.type;
+    memoryObjectId = copy_src.memoryObjectId;
+    size = copy_src.size;
+    objectType = copy_src.objectType;
+    objectHandle = copy_src.objectHandle;
+    heapIndex = copy_src.heapIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDeviceMemoryReportCallbackDataEXT& safe_VkDeviceMemoryReportCallbackDataEXT::operator=(
+    const safe_VkDeviceMemoryReportCallbackDataEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    type = copy_src.type;
+    memoryObjectId = copy_src.memoryObjectId;
+    size = copy_src.size;
+    objectType = copy_src.objectType;
+    objectHandle = copy_src.objectHandle;
+    heapIndex = copy_src.heapIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDeviceMemoryReportCallbackDataEXT::~safe_VkDeviceMemoryReportCallbackDataEXT() { FreePnextChain(pNext); }
+
+void safe_VkDeviceMemoryReportCallbackDataEXT::initialize(const VkDeviceMemoryReportCallbackDataEXT* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    type = in_struct->type;
+    memoryObjectId = in_struct->memoryObjectId;
+    size = in_struct->size;
+    objectType = in_struct->objectType;
+    objectHandle = in_struct->objectHandle;
+    heapIndex = in_struct->heapIndex;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDeviceMemoryReportCallbackDataEXT::initialize(const safe_VkDeviceMemoryReportCallbackDataEXT* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    type = copy_src->type;
+    memoryObjectId = copy_src->memoryObjectId;
+    size = copy_src->size;
+    objectType = copy_src->objectType;
+    objectHandle = copy_src->objectHandle;
+    heapIndex = copy_src->heapIndex;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDeviceDeviceMemoryReportCreateInfoEXT::safe_VkDeviceDeviceMemoryReportCreateInfoEXT(
+    const VkDeviceDeviceMemoryReportCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      pfnUserCallback(in_struct->pfnUserCallback),
+      pUserData(in_struct->pUserData) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDeviceDeviceMemoryReportCreateInfoEXT::safe_VkDeviceDeviceMemoryReportCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT),
+      pNext(nullptr),
+      flags(),
+      pfnUserCallback(),
+      pUserData(nullptr) {}
+
+safe_VkDeviceDeviceMemoryReportCreateInfoEXT::safe_VkDeviceDeviceMemoryReportCreateInfoEXT(
+    const safe_VkDeviceDeviceMemoryReportCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pfnUserCallback = copy_src.pfnUserCallback;
+    pUserData = copy_src.pUserData;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDeviceDeviceMemoryReportCreateInfoEXT& safe_VkDeviceDeviceMemoryReportCreateInfoEXT::operator=(
+    const safe_VkDeviceDeviceMemoryReportCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pfnUserCallback = copy_src.pfnUserCallback;
+    pUserData = copy_src.pUserData;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDeviceDeviceMemoryReportCreateInfoEXT::~safe_VkDeviceDeviceMemoryReportCreateInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkDeviceDeviceMemoryReportCreateInfoEXT::initialize(const VkDeviceDeviceMemoryReportCreateInfoEXT* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    pfnUserCallback = in_struct->pfnUserCallback;
+    pUserData = in_struct->pUserData;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDeviceDeviceMemoryReportCreateInfoEXT::initialize(const safe_VkDeviceDeviceMemoryReportCreateInfoEXT* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pfnUserCallback = copy_src->pfnUserCallback;
+    pUserData = copy_src->pUserData;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceRobustness2FeaturesEXT::safe_VkPhysicalDeviceRobustness2FeaturesEXT(
+    const VkPhysicalDeviceRobustness2FeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      robustBufferAccess2(in_struct->robustBufferAccess2),
+      robustImageAccess2(in_struct->robustImageAccess2),
+      nullDescriptor(in_struct->nullDescriptor) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceRobustness2FeaturesEXT::safe_VkPhysicalDeviceRobustness2FeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT),
+      pNext(nullptr),
+      robustBufferAccess2(),
+      robustImageAccess2(),
+      nullDescriptor() {}
+
+safe_VkPhysicalDeviceRobustness2FeaturesEXT::safe_VkPhysicalDeviceRobustness2FeaturesEXT(
+    const safe_VkPhysicalDeviceRobustness2FeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    robustBufferAccess2 = copy_src.robustBufferAccess2;
+    robustImageAccess2 = copy_src.robustImageAccess2;
+    nullDescriptor = copy_src.nullDescriptor;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceRobustness2FeaturesEXT& safe_VkPhysicalDeviceRobustness2FeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceRobustness2FeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    robustBufferAccess2 = copy_src.robustBufferAccess2;
+    robustImageAccess2 = copy_src.robustImageAccess2;
+    nullDescriptor = copy_src.nullDescriptor;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceRobustness2FeaturesEXT::~safe_VkPhysicalDeviceRobustness2FeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceRobustness2FeaturesEXT::initialize(const VkPhysicalDeviceRobustness2FeaturesEXT* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    robustBufferAccess2 = in_struct->robustBufferAccess2;
+    robustImageAccess2 = in_struct->robustImageAccess2;
+    nullDescriptor = in_struct->nullDescriptor;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceRobustness2FeaturesEXT::initialize(const safe_VkPhysicalDeviceRobustness2FeaturesEXT* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    robustBufferAccess2 = copy_src->robustBufferAccess2;
+    robustImageAccess2 = copy_src->robustImageAccess2;
+    nullDescriptor = copy_src->nullDescriptor;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceRobustness2PropertiesEXT::safe_VkPhysicalDeviceRobustness2PropertiesEXT(
+    const VkPhysicalDeviceRobustness2PropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      robustStorageBufferAccessSizeAlignment(in_struct->robustStorageBufferAccessSizeAlignment),
+      robustUniformBufferAccessSizeAlignment(in_struct->robustUniformBufferAccessSizeAlignment) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceRobustness2PropertiesEXT::safe_VkPhysicalDeviceRobustness2PropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT),
+      pNext(nullptr),
+      robustStorageBufferAccessSizeAlignment(),
+      robustUniformBufferAccessSizeAlignment() {}
+
+safe_VkPhysicalDeviceRobustness2PropertiesEXT::safe_VkPhysicalDeviceRobustness2PropertiesEXT(
+    const safe_VkPhysicalDeviceRobustness2PropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    robustStorageBufferAccessSizeAlignment = copy_src.robustStorageBufferAccessSizeAlignment;
+    robustUniformBufferAccessSizeAlignment = copy_src.robustUniformBufferAccessSizeAlignment;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceRobustness2PropertiesEXT& safe_VkPhysicalDeviceRobustness2PropertiesEXT::operator=(
+    const safe_VkPhysicalDeviceRobustness2PropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    robustStorageBufferAccessSizeAlignment = copy_src.robustStorageBufferAccessSizeAlignment;
+    robustUniformBufferAccessSizeAlignment = copy_src.robustUniformBufferAccessSizeAlignment;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceRobustness2PropertiesEXT::~safe_VkPhysicalDeviceRobustness2PropertiesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceRobustness2PropertiesEXT::initialize(const VkPhysicalDeviceRobustness2PropertiesEXT* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    robustStorageBufferAccessSizeAlignment = in_struct->robustStorageBufferAccessSizeAlignment;
+    robustUniformBufferAccessSizeAlignment = in_struct->robustUniformBufferAccessSizeAlignment;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceRobustness2PropertiesEXT::initialize(const safe_VkPhysicalDeviceRobustness2PropertiesEXT* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    robustStorageBufferAccessSizeAlignment = copy_src->robustStorageBufferAccessSizeAlignment;
+    robustUniformBufferAccessSizeAlignment = copy_src->robustUniformBufferAccessSizeAlignment;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSamplerCustomBorderColorCreateInfoEXT::safe_VkSamplerCustomBorderColorCreateInfoEXT(
+    const VkSamplerCustomBorderColorCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), customBorderColor(in_struct->customBorderColor), format(in_struct->format) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSamplerCustomBorderColorCreateInfoEXT::safe_VkSamplerCustomBorderColorCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT), pNext(nullptr), customBorderColor(), format() {}
+
+safe_VkSamplerCustomBorderColorCreateInfoEXT::safe_VkSamplerCustomBorderColorCreateInfoEXT(
+    const safe_VkSamplerCustomBorderColorCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    customBorderColor = copy_src.customBorderColor;
+    format = copy_src.format;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSamplerCustomBorderColorCreateInfoEXT& safe_VkSamplerCustomBorderColorCreateInfoEXT::operator=(
+    const safe_VkSamplerCustomBorderColorCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    customBorderColor = copy_src.customBorderColor;
+    format = copy_src.format;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSamplerCustomBorderColorCreateInfoEXT::~safe_VkSamplerCustomBorderColorCreateInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkSamplerCustomBorderColorCreateInfoEXT::initialize(const VkSamplerCustomBorderColorCreateInfoEXT* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    customBorderColor = in_struct->customBorderColor;
+    format = in_struct->format;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSamplerCustomBorderColorCreateInfoEXT::initialize(const safe_VkSamplerCustomBorderColorCreateInfoEXT* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    customBorderColor = copy_src->customBorderColor;
+    format = copy_src->format;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT::safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
+    const VkPhysicalDeviceCustomBorderColorPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), maxCustomBorderColorSamplers(in_struct->maxCustomBorderColorSamplers) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT::safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT), pNext(nullptr), maxCustomBorderColorSamplers() {}
+
+safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT::safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
+    const safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    maxCustomBorderColorSamplers = copy_src.maxCustomBorderColorSamplers;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT& safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT::operator=(
+    const safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxCustomBorderColorSamplers = copy_src.maxCustomBorderColorSamplers;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT::~safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT::initialize(
+    const VkPhysicalDeviceCustomBorderColorPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxCustomBorderColorSamplers = in_struct->maxCustomBorderColorSamplers;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT::initialize(
+    const safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxCustomBorderColorSamplers = copy_src->maxCustomBorderColorSamplers;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT::safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
+    const VkPhysicalDeviceCustomBorderColorFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      customBorderColors(in_struct->customBorderColors),
+      customBorderColorWithoutFormat(in_struct->customBorderColorWithoutFormat) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT::safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT),
+      pNext(nullptr),
+      customBorderColors(),
+      customBorderColorWithoutFormat() {}
+
+safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT::safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
+    const safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    customBorderColors = copy_src.customBorderColors;
+    customBorderColorWithoutFormat = copy_src.customBorderColorWithoutFormat;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT& safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    customBorderColors = copy_src.customBorderColors;
+    customBorderColorWithoutFormat = copy_src.customBorderColorWithoutFormat;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT::~safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT::initialize(const VkPhysicalDeviceCustomBorderColorFeaturesEXT* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    customBorderColors = in_struct->customBorderColors;
+    customBorderColorWithoutFormat = in_struct->customBorderColorWithoutFormat;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    customBorderColors = copy_src->customBorderColors;
+    customBorderColorWithoutFormat = copy_src->customBorderColorWithoutFormat;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+#ifdef VK_USE_PLATFORM_METAL_EXT
+
+safe_VkExportMetalObjectCreateInfoEXT::safe_VkExportMetalObjectCreateInfoEXT(const VkExportMetalObjectCreateInfoEXT* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType), exportObjectType(in_struct->exportObjectType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkExportMetalObjectCreateInfoEXT::safe_VkExportMetalObjectCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT), pNext(nullptr), exportObjectType() {}
+
+safe_VkExportMetalObjectCreateInfoEXT::safe_VkExportMetalObjectCreateInfoEXT(
+    const safe_VkExportMetalObjectCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    exportObjectType = copy_src.exportObjectType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkExportMetalObjectCreateInfoEXT& safe_VkExportMetalObjectCreateInfoEXT::operator=(
+    const safe_VkExportMetalObjectCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    exportObjectType = copy_src.exportObjectType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkExportMetalObjectCreateInfoEXT::~safe_VkExportMetalObjectCreateInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkExportMetalObjectCreateInfoEXT::initialize(const VkExportMetalObjectCreateInfoEXT* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    exportObjectType = in_struct->exportObjectType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkExportMetalObjectCreateInfoEXT::initialize(const safe_VkExportMetalObjectCreateInfoEXT* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    exportObjectType = copy_src->exportObjectType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkExportMetalObjectsInfoEXT::safe_VkExportMetalObjectsInfoEXT(const VkExportMetalObjectsInfoEXT* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkExportMetalObjectsInfoEXT::safe_VkExportMetalObjectsInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT), pNext(nullptr) {}
+
+safe_VkExportMetalObjectsInfoEXT::safe_VkExportMetalObjectsInfoEXT(const safe_VkExportMetalObjectsInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkExportMetalObjectsInfoEXT& safe_VkExportMetalObjectsInfoEXT::operator=(const safe_VkExportMetalObjectsInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkExportMetalObjectsInfoEXT::~safe_VkExportMetalObjectsInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkExportMetalObjectsInfoEXT::initialize(const VkExportMetalObjectsInfoEXT* in_struct,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkExportMetalObjectsInfoEXT::initialize(const safe_VkExportMetalObjectsInfoEXT* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkExportMetalDeviceInfoEXT::safe_VkExportMetalDeviceInfoEXT(const VkExportMetalDeviceInfoEXT* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), mtlDevice(in_struct->mtlDevice) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkExportMetalDeviceInfoEXT::safe_VkExportMetalDeviceInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT), pNext(nullptr), mtlDevice() {}
+
+safe_VkExportMetalDeviceInfoEXT::safe_VkExportMetalDeviceInfoEXT(const safe_VkExportMetalDeviceInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    mtlDevice = copy_src.mtlDevice;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkExportMetalDeviceInfoEXT& safe_VkExportMetalDeviceInfoEXT::operator=(const safe_VkExportMetalDeviceInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    mtlDevice = copy_src.mtlDevice;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkExportMetalDeviceInfoEXT::~safe_VkExportMetalDeviceInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkExportMetalDeviceInfoEXT::initialize(const VkExportMetalDeviceInfoEXT* in_struct,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    mtlDevice = in_struct->mtlDevice;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkExportMetalDeviceInfoEXT::initialize(const safe_VkExportMetalDeviceInfoEXT* copy_src,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    mtlDevice = copy_src->mtlDevice;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkExportMetalCommandQueueInfoEXT::safe_VkExportMetalCommandQueueInfoEXT(const VkExportMetalCommandQueueInfoEXT* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType), queue(in_struct->queue), mtlCommandQueue(in_struct->mtlCommandQueue) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkExportMetalCommandQueueInfoEXT::safe_VkExportMetalCommandQueueInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT), pNext(nullptr), queue(), mtlCommandQueue() {}
+
+safe_VkExportMetalCommandQueueInfoEXT::safe_VkExportMetalCommandQueueInfoEXT(
+    const safe_VkExportMetalCommandQueueInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    queue = copy_src.queue;
+    mtlCommandQueue = copy_src.mtlCommandQueue;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkExportMetalCommandQueueInfoEXT& safe_VkExportMetalCommandQueueInfoEXT::operator=(
+    const safe_VkExportMetalCommandQueueInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    queue = copy_src.queue;
+    mtlCommandQueue = copy_src.mtlCommandQueue;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkExportMetalCommandQueueInfoEXT::~safe_VkExportMetalCommandQueueInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkExportMetalCommandQueueInfoEXT::initialize(const VkExportMetalCommandQueueInfoEXT* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    queue = in_struct->queue;
+    mtlCommandQueue = in_struct->mtlCommandQueue;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkExportMetalCommandQueueInfoEXT::initialize(const safe_VkExportMetalCommandQueueInfoEXT* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    queue = copy_src->queue;
+    mtlCommandQueue = copy_src->mtlCommandQueue;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkExportMetalBufferInfoEXT::safe_VkExportMetalBufferInfoEXT(const VkExportMetalBufferInfoEXT* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), memory(in_struct->memory), mtlBuffer(in_struct->mtlBuffer) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkExportMetalBufferInfoEXT::safe_VkExportMetalBufferInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT), pNext(nullptr), memory(), mtlBuffer() {}
+
+safe_VkExportMetalBufferInfoEXT::safe_VkExportMetalBufferInfoEXT(const safe_VkExportMetalBufferInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    memory = copy_src.memory;
+    mtlBuffer = copy_src.mtlBuffer;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkExportMetalBufferInfoEXT& safe_VkExportMetalBufferInfoEXT::operator=(const safe_VkExportMetalBufferInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    memory = copy_src.memory;
+    mtlBuffer = copy_src.mtlBuffer;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkExportMetalBufferInfoEXT::~safe_VkExportMetalBufferInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkExportMetalBufferInfoEXT::initialize(const VkExportMetalBufferInfoEXT* in_struct,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    memory = in_struct->memory;
+    mtlBuffer = in_struct->mtlBuffer;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkExportMetalBufferInfoEXT::initialize(const safe_VkExportMetalBufferInfoEXT* copy_src,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memory = copy_src->memory;
+    mtlBuffer = copy_src->mtlBuffer;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkImportMetalBufferInfoEXT::safe_VkImportMetalBufferInfoEXT(const VkImportMetalBufferInfoEXT* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), mtlBuffer(in_struct->mtlBuffer) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImportMetalBufferInfoEXT::safe_VkImportMetalBufferInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT), pNext(nullptr), mtlBuffer() {}
+
+safe_VkImportMetalBufferInfoEXT::safe_VkImportMetalBufferInfoEXT(const safe_VkImportMetalBufferInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    mtlBuffer = copy_src.mtlBuffer;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImportMetalBufferInfoEXT& safe_VkImportMetalBufferInfoEXT::operator=(const safe_VkImportMetalBufferInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    mtlBuffer = copy_src.mtlBuffer;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImportMetalBufferInfoEXT::~safe_VkImportMetalBufferInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkImportMetalBufferInfoEXT::initialize(const VkImportMetalBufferInfoEXT* in_struct,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    mtlBuffer = in_struct->mtlBuffer;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImportMetalBufferInfoEXT::initialize(const safe_VkImportMetalBufferInfoEXT* copy_src,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    mtlBuffer = copy_src->mtlBuffer;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkExportMetalTextureInfoEXT::safe_VkExportMetalTextureInfoEXT(const VkExportMetalTextureInfoEXT* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      image(in_struct->image),
+      imageView(in_struct->imageView),
+      bufferView(in_struct->bufferView),
+      plane(in_struct->plane),
+      mtlTexture(in_struct->mtlTexture) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkExportMetalTextureInfoEXT::safe_VkExportMetalTextureInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT),
+      pNext(nullptr),
+      image(),
+      imageView(),
+      bufferView(),
+      plane(),
+      mtlTexture() {}
+
+safe_VkExportMetalTextureInfoEXT::safe_VkExportMetalTextureInfoEXT(const safe_VkExportMetalTextureInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    image = copy_src.image;
+    imageView = copy_src.imageView;
+    bufferView = copy_src.bufferView;
+    plane = copy_src.plane;
+    mtlTexture = copy_src.mtlTexture;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkExportMetalTextureInfoEXT& safe_VkExportMetalTextureInfoEXT::operator=(const safe_VkExportMetalTextureInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    image = copy_src.image;
+    imageView = copy_src.imageView;
+    bufferView = copy_src.bufferView;
+    plane = copy_src.plane;
+    mtlTexture = copy_src.mtlTexture;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkExportMetalTextureInfoEXT::~safe_VkExportMetalTextureInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkExportMetalTextureInfoEXT::initialize(const VkExportMetalTextureInfoEXT* in_struct,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    image = in_struct->image;
+    imageView = in_struct->imageView;
+    bufferView = in_struct->bufferView;
+    plane = in_struct->plane;
+    mtlTexture = in_struct->mtlTexture;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkExportMetalTextureInfoEXT::initialize(const safe_VkExportMetalTextureInfoEXT* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    image = copy_src->image;
+    imageView = copy_src->imageView;
+    bufferView = copy_src->bufferView;
+    plane = copy_src->plane;
+    mtlTexture = copy_src->mtlTexture;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkImportMetalTextureInfoEXT::safe_VkImportMetalTextureInfoEXT(const VkImportMetalTextureInfoEXT* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), plane(in_struct->plane), mtlTexture(in_struct->mtlTexture) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImportMetalTextureInfoEXT::safe_VkImportMetalTextureInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT), pNext(nullptr), plane(), mtlTexture() {}
+
+safe_VkImportMetalTextureInfoEXT::safe_VkImportMetalTextureInfoEXT(const safe_VkImportMetalTextureInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    plane = copy_src.plane;
+    mtlTexture = copy_src.mtlTexture;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImportMetalTextureInfoEXT& safe_VkImportMetalTextureInfoEXT::operator=(const safe_VkImportMetalTextureInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    plane = copy_src.plane;
+    mtlTexture = copy_src.mtlTexture;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImportMetalTextureInfoEXT::~safe_VkImportMetalTextureInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkImportMetalTextureInfoEXT::initialize(const VkImportMetalTextureInfoEXT* in_struct,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    plane = in_struct->plane;
+    mtlTexture = in_struct->mtlTexture;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImportMetalTextureInfoEXT::initialize(const safe_VkImportMetalTextureInfoEXT* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    plane = copy_src->plane;
+    mtlTexture = copy_src->mtlTexture;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkExportMetalIOSurfaceInfoEXT::safe_VkExportMetalIOSurfaceInfoEXT(const VkExportMetalIOSurfaceInfoEXT* in_struct,
+                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), image(in_struct->image), ioSurface(in_struct->ioSurface) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkExportMetalIOSurfaceInfoEXT::safe_VkExportMetalIOSurfaceInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT), pNext(nullptr), image(), ioSurface() {}
+
+safe_VkExportMetalIOSurfaceInfoEXT::safe_VkExportMetalIOSurfaceInfoEXT(const safe_VkExportMetalIOSurfaceInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    image = copy_src.image;
+    ioSurface = copy_src.ioSurface;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkExportMetalIOSurfaceInfoEXT& safe_VkExportMetalIOSurfaceInfoEXT::operator=(
+    const safe_VkExportMetalIOSurfaceInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    image = copy_src.image;
+    ioSurface = copy_src.ioSurface;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkExportMetalIOSurfaceInfoEXT::~safe_VkExportMetalIOSurfaceInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkExportMetalIOSurfaceInfoEXT::initialize(const VkExportMetalIOSurfaceInfoEXT* in_struct,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    image = in_struct->image;
+    ioSurface = in_struct->ioSurface;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkExportMetalIOSurfaceInfoEXT::initialize(const safe_VkExportMetalIOSurfaceInfoEXT* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    image = copy_src->image;
+    ioSurface = copy_src->ioSurface;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkImportMetalIOSurfaceInfoEXT::safe_VkImportMetalIOSurfaceInfoEXT(const VkImportMetalIOSurfaceInfoEXT* in_struct,
+                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), ioSurface(in_struct->ioSurface) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImportMetalIOSurfaceInfoEXT::safe_VkImportMetalIOSurfaceInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT), pNext(nullptr), ioSurface() {}
+
+safe_VkImportMetalIOSurfaceInfoEXT::safe_VkImportMetalIOSurfaceInfoEXT(const safe_VkImportMetalIOSurfaceInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    ioSurface = copy_src.ioSurface;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImportMetalIOSurfaceInfoEXT& safe_VkImportMetalIOSurfaceInfoEXT::operator=(
+    const safe_VkImportMetalIOSurfaceInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    ioSurface = copy_src.ioSurface;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImportMetalIOSurfaceInfoEXT::~safe_VkImportMetalIOSurfaceInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkImportMetalIOSurfaceInfoEXT::initialize(const VkImportMetalIOSurfaceInfoEXT* in_struct,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    ioSurface = in_struct->ioSurface;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImportMetalIOSurfaceInfoEXT::initialize(const safe_VkImportMetalIOSurfaceInfoEXT* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    ioSurface = copy_src->ioSurface;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkExportMetalSharedEventInfoEXT::safe_VkExportMetalSharedEventInfoEXT(const VkExportMetalSharedEventInfoEXT* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), semaphore(in_struct->semaphore), event(in_struct->event), mtlSharedEvent(in_struct->mtlSharedEvent) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkExportMetalSharedEventInfoEXT::safe_VkExportMetalSharedEventInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT), pNext(nullptr), semaphore(), event(), mtlSharedEvent() {}
+
+safe_VkExportMetalSharedEventInfoEXT::safe_VkExportMetalSharedEventInfoEXT(const safe_VkExportMetalSharedEventInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    semaphore = copy_src.semaphore;
+    event = copy_src.event;
+    mtlSharedEvent = copy_src.mtlSharedEvent;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkExportMetalSharedEventInfoEXT& safe_VkExportMetalSharedEventInfoEXT::operator=(
+    const safe_VkExportMetalSharedEventInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    semaphore = copy_src.semaphore;
+    event = copy_src.event;
+    mtlSharedEvent = copy_src.mtlSharedEvent;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkExportMetalSharedEventInfoEXT::~safe_VkExportMetalSharedEventInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkExportMetalSharedEventInfoEXT::initialize(const VkExportMetalSharedEventInfoEXT* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    semaphore = in_struct->semaphore;
+    event = in_struct->event;
+    mtlSharedEvent = in_struct->mtlSharedEvent;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkExportMetalSharedEventInfoEXT::initialize(const safe_VkExportMetalSharedEventInfoEXT* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    semaphore = copy_src->semaphore;
+    event = copy_src->event;
+    mtlSharedEvent = copy_src->mtlSharedEvent;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkImportMetalSharedEventInfoEXT::safe_VkImportMetalSharedEventInfoEXT(const VkImportMetalSharedEventInfoEXT* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), mtlSharedEvent(in_struct->mtlSharedEvent) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImportMetalSharedEventInfoEXT::safe_VkImportMetalSharedEventInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT), pNext(nullptr), mtlSharedEvent() {}
+
+safe_VkImportMetalSharedEventInfoEXT::safe_VkImportMetalSharedEventInfoEXT(const safe_VkImportMetalSharedEventInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    mtlSharedEvent = copy_src.mtlSharedEvent;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImportMetalSharedEventInfoEXT& safe_VkImportMetalSharedEventInfoEXT::operator=(
+    const safe_VkImportMetalSharedEventInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    mtlSharedEvent = copy_src.mtlSharedEvent;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImportMetalSharedEventInfoEXT::~safe_VkImportMetalSharedEventInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkImportMetalSharedEventInfoEXT::initialize(const VkImportMetalSharedEventInfoEXT* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    mtlSharedEvent = in_struct->mtlSharedEvent;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImportMetalSharedEventInfoEXT::initialize(const safe_VkImportMetalSharedEventInfoEXT* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    mtlSharedEvent = copy_src->mtlSharedEvent;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+#endif  // VK_USE_PLATFORM_METAL_EXT
+
+safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT::safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
+    const VkPhysicalDeviceDescriptorBufferPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      combinedImageSamplerDescriptorSingleArray(in_struct->combinedImageSamplerDescriptorSingleArray),
+      bufferlessPushDescriptors(in_struct->bufferlessPushDescriptors),
+      allowSamplerImageViewPostSubmitCreation(in_struct->allowSamplerImageViewPostSubmitCreation),
+      descriptorBufferOffsetAlignment(in_struct->descriptorBufferOffsetAlignment),
+      maxDescriptorBufferBindings(in_struct->maxDescriptorBufferBindings),
+      maxResourceDescriptorBufferBindings(in_struct->maxResourceDescriptorBufferBindings),
+      maxSamplerDescriptorBufferBindings(in_struct->maxSamplerDescriptorBufferBindings),
+      maxEmbeddedImmutableSamplerBindings(in_struct->maxEmbeddedImmutableSamplerBindings),
+      maxEmbeddedImmutableSamplers(in_struct->maxEmbeddedImmutableSamplers),
+      bufferCaptureReplayDescriptorDataSize(in_struct->bufferCaptureReplayDescriptorDataSize),
+      imageCaptureReplayDescriptorDataSize(in_struct->imageCaptureReplayDescriptorDataSize),
+      imageViewCaptureReplayDescriptorDataSize(in_struct->imageViewCaptureReplayDescriptorDataSize),
+      samplerCaptureReplayDescriptorDataSize(in_struct->samplerCaptureReplayDescriptorDataSize),
+      accelerationStructureCaptureReplayDescriptorDataSize(in_struct->accelerationStructureCaptureReplayDescriptorDataSize),
+      samplerDescriptorSize(in_struct->samplerDescriptorSize),
+      combinedImageSamplerDescriptorSize(in_struct->combinedImageSamplerDescriptorSize),
+      sampledImageDescriptorSize(in_struct->sampledImageDescriptorSize),
+      storageImageDescriptorSize(in_struct->storageImageDescriptorSize),
+      uniformTexelBufferDescriptorSize(in_struct->uniformTexelBufferDescriptorSize),
+      robustUniformTexelBufferDescriptorSize(in_struct->robustUniformTexelBufferDescriptorSize),
+      storageTexelBufferDescriptorSize(in_struct->storageTexelBufferDescriptorSize),
+      robustStorageTexelBufferDescriptorSize(in_struct->robustStorageTexelBufferDescriptorSize),
+      uniformBufferDescriptorSize(in_struct->uniformBufferDescriptorSize),
+      robustUniformBufferDescriptorSize(in_struct->robustUniformBufferDescriptorSize),
+      storageBufferDescriptorSize(in_struct->storageBufferDescriptorSize),
+      robustStorageBufferDescriptorSize(in_struct->robustStorageBufferDescriptorSize),
+      inputAttachmentDescriptorSize(in_struct->inputAttachmentDescriptorSize),
+      accelerationStructureDescriptorSize(in_struct->accelerationStructureDescriptorSize),
+      maxSamplerDescriptorBufferRange(in_struct->maxSamplerDescriptorBufferRange),
+      maxResourceDescriptorBufferRange(in_struct->maxResourceDescriptorBufferRange),
+      samplerDescriptorBufferAddressSpaceSize(in_struct->samplerDescriptorBufferAddressSpaceSize),
+      resourceDescriptorBufferAddressSpaceSize(in_struct->resourceDescriptorBufferAddressSpaceSize),
+      descriptorBufferAddressSpaceSize(in_struct->descriptorBufferAddressSpaceSize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT::safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT),
+      pNext(nullptr),
+      combinedImageSamplerDescriptorSingleArray(),
+      bufferlessPushDescriptors(),
+      allowSamplerImageViewPostSubmitCreation(),
+      descriptorBufferOffsetAlignment(),
+      maxDescriptorBufferBindings(),
+      maxResourceDescriptorBufferBindings(),
+      maxSamplerDescriptorBufferBindings(),
+      maxEmbeddedImmutableSamplerBindings(),
+      maxEmbeddedImmutableSamplers(),
+      bufferCaptureReplayDescriptorDataSize(),
+      imageCaptureReplayDescriptorDataSize(),
+      imageViewCaptureReplayDescriptorDataSize(),
+      samplerCaptureReplayDescriptorDataSize(),
+      accelerationStructureCaptureReplayDescriptorDataSize(),
+      samplerDescriptorSize(),
+      combinedImageSamplerDescriptorSize(),
+      sampledImageDescriptorSize(),
+      storageImageDescriptorSize(),
+      uniformTexelBufferDescriptorSize(),
+      robustUniformTexelBufferDescriptorSize(),
+      storageTexelBufferDescriptorSize(),
+      robustStorageTexelBufferDescriptorSize(),
+      uniformBufferDescriptorSize(),
+      robustUniformBufferDescriptorSize(),
+      storageBufferDescriptorSize(),
+      robustStorageBufferDescriptorSize(),
+      inputAttachmentDescriptorSize(),
+      accelerationStructureDescriptorSize(),
+      maxSamplerDescriptorBufferRange(),
+      maxResourceDescriptorBufferRange(),
+      samplerDescriptorBufferAddressSpaceSize(),
+      resourceDescriptorBufferAddressSpaceSize(),
+      descriptorBufferAddressSpaceSize() {}
+
+safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT::safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
+    const safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    combinedImageSamplerDescriptorSingleArray = copy_src.combinedImageSamplerDescriptorSingleArray;
+    bufferlessPushDescriptors = copy_src.bufferlessPushDescriptors;
+    allowSamplerImageViewPostSubmitCreation = copy_src.allowSamplerImageViewPostSubmitCreation;
+    descriptorBufferOffsetAlignment = copy_src.descriptorBufferOffsetAlignment;
+    maxDescriptorBufferBindings = copy_src.maxDescriptorBufferBindings;
+    maxResourceDescriptorBufferBindings = copy_src.maxResourceDescriptorBufferBindings;
+    maxSamplerDescriptorBufferBindings = copy_src.maxSamplerDescriptorBufferBindings;
+    maxEmbeddedImmutableSamplerBindings = copy_src.maxEmbeddedImmutableSamplerBindings;
+    maxEmbeddedImmutableSamplers = copy_src.maxEmbeddedImmutableSamplers;
+    bufferCaptureReplayDescriptorDataSize = copy_src.bufferCaptureReplayDescriptorDataSize;
+    imageCaptureReplayDescriptorDataSize = copy_src.imageCaptureReplayDescriptorDataSize;
+    imageViewCaptureReplayDescriptorDataSize = copy_src.imageViewCaptureReplayDescriptorDataSize;
+    samplerCaptureReplayDescriptorDataSize = copy_src.samplerCaptureReplayDescriptorDataSize;
+    accelerationStructureCaptureReplayDescriptorDataSize = copy_src.accelerationStructureCaptureReplayDescriptorDataSize;
+    samplerDescriptorSize = copy_src.samplerDescriptorSize;
+    combinedImageSamplerDescriptorSize = copy_src.combinedImageSamplerDescriptorSize;
+    sampledImageDescriptorSize = copy_src.sampledImageDescriptorSize;
+    storageImageDescriptorSize = copy_src.storageImageDescriptorSize;
+    uniformTexelBufferDescriptorSize = copy_src.uniformTexelBufferDescriptorSize;
+    robustUniformTexelBufferDescriptorSize = copy_src.robustUniformTexelBufferDescriptorSize;
+    storageTexelBufferDescriptorSize = copy_src.storageTexelBufferDescriptorSize;
+    robustStorageTexelBufferDescriptorSize = copy_src.robustStorageTexelBufferDescriptorSize;
+    uniformBufferDescriptorSize = copy_src.uniformBufferDescriptorSize;
+    robustUniformBufferDescriptorSize = copy_src.robustUniformBufferDescriptorSize;
+    storageBufferDescriptorSize = copy_src.storageBufferDescriptorSize;
+    robustStorageBufferDescriptorSize = copy_src.robustStorageBufferDescriptorSize;
+    inputAttachmentDescriptorSize = copy_src.inputAttachmentDescriptorSize;
+    accelerationStructureDescriptorSize = copy_src.accelerationStructureDescriptorSize;
+    maxSamplerDescriptorBufferRange = copy_src.maxSamplerDescriptorBufferRange;
+    maxResourceDescriptorBufferRange = copy_src.maxResourceDescriptorBufferRange;
+    samplerDescriptorBufferAddressSpaceSize = copy_src.samplerDescriptorBufferAddressSpaceSize;
+    resourceDescriptorBufferAddressSpaceSize = copy_src.resourceDescriptorBufferAddressSpaceSize;
+    descriptorBufferAddressSpaceSize = copy_src.descriptorBufferAddressSpaceSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT& safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT::operator=(
+    const safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    combinedImageSamplerDescriptorSingleArray = copy_src.combinedImageSamplerDescriptorSingleArray;
+    bufferlessPushDescriptors = copy_src.bufferlessPushDescriptors;
+    allowSamplerImageViewPostSubmitCreation = copy_src.allowSamplerImageViewPostSubmitCreation;
+    descriptorBufferOffsetAlignment = copy_src.descriptorBufferOffsetAlignment;
+    maxDescriptorBufferBindings = copy_src.maxDescriptorBufferBindings;
+    maxResourceDescriptorBufferBindings = copy_src.maxResourceDescriptorBufferBindings;
+    maxSamplerDescriptorBufferBindings = copy_src.maxSamplerDescriptorBufferBindings;
+    maxEmbeddedImmutableSamplerBindings = copy_src.maxEmbeddedImmutableSamplerBindings;
+    maxEmbeddedImmutableSamplers = copy_src.maxEmbeddedImmutableSamplers;
+    bufferCaptureReplayDescriptorDataSize = copy_src.bufferCaptureReplayDescriptorDataSize;
+    imageCaptureReplayDescriptorDataSize = copy_src.imageCaptureReplayDescriptorDataSize;
+    imageViewCaptureReplayDescriptorDataSize = copy_src.imageViewCaptureReplayDescriptorDataSize;
+    samplerCaptureReplayDescriptorDataSize = copy_src.samplerCaptureReplayDescriptorDataSize;
+    accelerationStructureCaptureReplayDescriptorDataSize = copy_src.accelerationStructureCaptureReplayDescriptorDataSize;
+    samplerDescriptorSize = copy_src.samplerDescriptorSize;
+    combinedImageSamplerDescriptorSize = copy_src.combinedImageSamplerDescriptorSize;
+    sampledImageDescriptorSize = copy_src.sampledImageDescriptorSize;
+    storageImageDescriptorSize = copy_src.storageImageDescriptorSize;
+    uniformTexelBufferDescriptorSize = copy_src.uniformTexelBufferDescriptorSize;
+    robustUniformTexelBufferDescriptorSize = copy_src.robustUniformTexelBufferDescriptorSize;
+    storageTexelBufferDescriptorSize = copy_src.storageTexelBufferDescriptorSize;
+    robustStorageTexelBufferDescriptorSize = copy_src.robustStorageTexelBufferDescriptorSize;
+    uniformBufferDescriptorSize = copy_src.uniformBufferDescriptorSize;
+    robustUniformBufferDescriptorSize = copy_src.robustUniformBufferDescriptorSize;
+    storageBufferDescriptorSize = copy_src.storageBufferDescriptorSize;
+    robustStorageBufferDescriptorSize = copy_src.robustStorageBufferDescriptorSize;
+    inputAttachmentDescriptorSize = copy_src.inputAttachmentDescriptorSize;
+    accelerationStructureDescriptorSize = copy_src.accelerationStructureDescriptorSize;
+    maxSamplerDescriptorBufferRange = copy_src.maxSamplerDescriptorBufferRange;
+    maxResourceDescriptorBufferRange = copy_src.maxResourceDescriptorBufferRange;
+    samplerDescriptorBufferAddressSpaceSize = copy_src.samplerDescriptorBufferAddressSpaceSize;
+    resourceDescriptorBufferAddressSpaceSize = copy_src.resourceDescriptorBufferAddressSpaceSize;
+    descriptorBufferAddressSpaceSize = copy_src.descriptorBufferAddressSpaceSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT::~safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT::initialize(const VkPhysicalDeviceDescriptorBufferPropertiesEXT* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    combinedImageSamplerDescriptorSingleArray = in_struct->combinedImageSamplerDescriptorSingleArray;
+    bufferlessPushDescriptors = in_struct->bufferlessPushDescriptors;
+    allowSamplerImageViewPostSubmitCreation = in_struct->allowSamplerImageViewPostSubmitCreation;
+    descriptorBufferOffsetAlignment = in_struct->descriptorBufferOffsetAlignment;
+    maxDescriptorBufferBindings = in_struct->maxDescriptorBufferBindings;
+    maxResourceDescriptorBufferBindings = in_struct->maxResourceDescriptorBufferBindings;
+    maxSamplerDescriptorBufferBindings = in_struct->maxSamplerDescriptorBufferBindings;
+    maxEmbeddedImmutableSamplerBindings = in_struct->maxEmbeddedImmutableSamplerBindings;
+    maxEmbeddedImmutableSamplers = in_struct->maxEmbeddedImmutableSamplers;
+    bufferCaptureReplayDescriptorDataSize = in_struct->bufferCaptureReplayDescriptorDataSize;
+    imageCaptureReplayDescriptorDataSize = in_struct->imageCaptureReplayDescriptorDataSize;
+    imageViewCaptureReplayDescriptorDataSize = in_struct->imageViewCaptureReplayDescriptorDataSize;
+    samplerCaptureReplayDescriptorDataSize = in_struct->samplerCaptureReplayDescriptorDataSize;
+    accelerationStructureCaptureReplayDescriptorDataSize = in_struct->accelerationStructureCaptureReplayDescriptorDataSize;
+    samplerDescriptorSize = in_struct->samplerDescriptorSize;
+    combinedImageSamplerDescriptorSize = in_struct->combinedImageSamplerDescriptorSize;
+    sampledImageDescriptorSize = in_struct->sampledImageDescriptorSize;
+    storageImageDescriptorSize = in_struct->storageImageDescriptorSize;
+    uniformTexelBufferDescriptorSize = in_struct->uniformTexelBufferDescriptorSize;
+    robustUniformTexelBufferDescriptorSize = in_struct->robustUniformTexelBufferDescriptorSize;
+    storageTexelBufferDescriptorSize = in_struct->storageTexelBufferDescriptorSize;
+    robustStorageTexelBufferDescriptorSize = in_struct->robustStorageTexelBufferDescriptorSize;
+    uniformBufferDescriptorSize = in_struct->uniformBufferDescriptorSize;
+    robustUniformBufferDescriptorSize = in_struct->robustUniformBufferDescriptorSize;
+    storageBufferDescriptorSize = in_struct->storageBufferDescriptorSize;
+    robustStorageBufferDescriptorSize = in_struct->robustStorageBufferDescriptorSize;
+    inputAttachmentDescriptorSize = in_struct->inputAttachmentDescriptorSize;
+    accelerationStructureDescriptorSize = in_struct->accelerationStructureDescriptorSize;
+    maxSamplerDescriptorBufferRange = in_struct->maxSamplerDescriptorBufferRange;
+    maxResourceDescriptorBufferRange = in_struct->maxResourceDescriptorBufferRange;
+    samplerDescriptorBufferAddressSpaceSize = in_struct->samplerDescriptorBufferAddressSpaceSize;
+    resourceDescriptorBufferAddressSpaceSize = in_struct->resourceDescriptorBufferAddressSpaceSize;
+    descriptorBufferAddressSpaceSize = in_struct->descriptorBufferAddressSpaceSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT::initialize(
+    const safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    combinedImageSamplerDescriptorSingleArray = copy_src->combinedImageSamplerDescriptorSingleArray;
+    bufferlessPushDescriptors = copy_src->bufferlessPushDescriptors;
+    allowSamplerImageViewPostSubmitCreation = copy_src->allowSamplerImageViewPostSubmitCreation;
+    descriptorBufferOffsetAlignment = copy_src->descriptorBufferOffsetAlignment;
+    maxDescriptorBufferBindings = copy_src->maxDescriptorBufferBindings;
+    maxResourceDescriptorBufferBindings = copy_src->maxResourceDescriptorBufferBindings;
+    maxSamplerDescriptorBufferBindings = copy_src->maxSamplerDescriptorBufferBindings;
+    maxEmbeddedImmutableSamplerBindings = copy_src->maxEmbeddedImmutableSamplerBindings;
+    maxEmbeddedImmutableSamplers = copy_src->maxEmbeddedImmutableSamplers;
+    bufferCaptureReplayDescriptorDataSize = copy_src->bufferCaptureReplayDescriptorDataSize;
+    imageCaptureReplayDescriptorDataSize = copy_src->imageCaptureReplayDescriptorDataSize;
+    imageViewCaptureReplayDescriptorDataSize = copy_src->imageViewCaptureReplayDescriptorDataSize;
+    samplerCaptureReplayDescriptorDataSize = copy_src->samplerCaptureReplayDescriptorDataSize;
+    accelerationStructureCaptureReplayDescriptorDataSize = copy_src->accelerationStructureCaptureReplayDescriptorDataSize;
+    samplerDescriptorSize = copy_src->samplerDescriptorSize;
+    combinedImageSamplerDescriptorSize = copy_src->combinedImageSamplerDescriptorSize;
+    sampledImageDescriptorSize = copy_src->sampledImageDescriptorSize;
+    storageImageDescriptorSize = copy_src->storageImageDescriptorSize;
+    uniformTexelBufferDescriptorSize = copy_src->uniformTexelBufferDescriptorSize;
+    robustUniformTexelBufferDescriptorSize = copy_src->robustUniformTexelBufferDescriptorSize;
+    storageTexelBufferDescriptorSize = copy_src->storageTexelBufferDescriptorSize;
+    robustStorageTexelBufferDescriptorSize = copy_src->robustStorageTexelBufferDescriptorSize;
+    uniformBufferDescriptorSize = copy_src->uniformBufferDescriptorSize;
+    robustUniformBufferDescriptorSize = copy_src->robustUniformBufferDescriptorSize;
+    storageBufferDescriptorSize = copy_src->storageBufferDescriptorSize;
+    robustStorageBufferDescriptorSize = copy_src->robustStorageBufferDescriptorSize;
+    inputAttachmentDescriptorSize = copy_src->inputAttachmentDescriptorSize;
+    accelerationStructureDescriptorSize = copy_src->accelerationStructureDescriptorSize;
+    maxSamplerDescriptorBufferRange = copy_src->maxSamplerDescriptorBufferRange;
+    maxResourceDescriptorBufferRange = copy_src->maxResourceDescriptorBufferRange;
+    samplerDescriptorBufferAddressSpaceSize = copy_src->samplerDescriptorBufferAddressSpaceSize;
+    resourceDescriptorBufferAddressSpaceSize = copy_src->resourceDescriptorBufferAddressSpaceSize;
+    descriptorBufferAddressSpaceSize = copy_src->descriptorBufferAddressSpaceSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT::safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+    const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      combinedImageSamplerDensityMapDescriptorSize(in_struct->combinedImageSamplerDensityMapDescriptorSize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT::safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT),
+      pNext(nullptr),
+      combinedImageSamplerDensityMapDescriptorSize() {}
+
+safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT::safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+    const safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    combinedImageSamplerDensityMapDescriptorSize = copy_src.combinedImageSamplerDensityMapDescriptorSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT&
+safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT::operator=(
+    const safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    combinedImageSamplerDensityMapDescriptorSize = copy_src.combinedImageSamplerDensityMapDescriptorSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT::~safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT::initialize(
+    const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    combinedImageSamplerDensityMapDescriptorSize = in_struct->combinedImageSamplerDensityMapDescriptorSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT::initialize(
+    const safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    combinedImageSamplerDensityMapDescriptorSize = copy_src->combinedImageSamplerDensityMapDescriptorSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT::safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
+    const VkPhysicalDeviceDescriptorBufferFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      descriptorBuffer(in_struct->descriptorBuffer),
+      descriptorBufferCaptureReplay(in_struct->descriptorBufferCaptureReplay),
+      descriptorBufferImageLayoutIgnored(in_struct->descriptorBufferImageLayoutIgnored),
+      descriptorBufferPushDescriptors(in_struct->descriptorBufferPushDescriptors) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT::safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT),
+      pNext(nullptr),
+      descriptorBuffer(),
+      descriptorBufferCaptureReplay(),
+      descriptorBufferImageLayoutIgnored(),
+      descriptorBufferPushDescriptors() {}
+
+safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT::safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
+    const safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    descriptorBuffer = copy_src.descriptorBuffer;
+    descriptorBufferCaptureReplay = copy_src.descriptorBufferCaptureReplay;
+    descriptorBufferImageLayoutIgnored = copy_src.descriptorBufferImageLayoutIgnored;
+    descriptorBufferPushDescriptors = copy_src.descriptorBufferPushDescriptors;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT& safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    descriptorBuffer = copy_src.descriptorBuffer;
+    descriptorBufferCaptureReplay = copy_src.descriptorBufferCaptureReplay;
+    descriptorBufferImageLayoutIgnored = copy_src.descriptorBufferImageLayoutIgnored;
+    descriptorBufferPushDescriptors = copy_src.descriptorBufferPushDescriptors;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT::~safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT::initialize(const VkPhysicalDeviceDescriptorBufferFeaturesEXT* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    descriptorBuffer = in_struct->descriptorBuffer;
+    descriptorBufferCaptureReplay = in_struct->descriptorBufferCaptureReplay;
+    descriptorBufferImageLayoutIgnored = in_struct->descriptorBufferImageLayoutIgnored;
+    descriptorBufferPushDescriptors = in_struct->descriptorBufferPushDescriptors;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT::initialize(const safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    descriptorBuffer = copy_src->descriptorBuffer;
+    descriptorBufferCaptureReplay = copy_src->descriptorBufferCaptureReplay;
+    descriptorBufferImageLayoutIgnored = copy_src->descriptorBufferImageLayoutIgnored;
+    descriptorBufferPushDescriptors = copy_src->descriptorBufferPushDescriptors;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDescriptorAddressInfoEXT::safe_VkDescriptorAddressInfoEXT(const VkDescriptorAddressInfoEXT* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), address(in_struct->address), range(in_struct->range), format(in_struct->format) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDescriptorAddressInfoEXT::safe_VkDescriptorAddressInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT), pNext(nullptr), address(), range(), format() {}
+
+safe_VkDescriptorAddressInfoEXT::safe_VkDescriptorAddressInfoEXT(const safe_VkDescriptorAddressInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    address = copy_src.address;
+    range = copy_src.range;
+    format = copy_src.format;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDescriptorAddressInfoEXT& safe_VkDescriptorAddressInfoEXT::operator=(const safe_VkDescriptorAddressInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    address = copy_src.address;
+    range = copy_src.range;
+    format = copy_src.format;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDescriptorAddressInfoEXT::~safe_VkDescriptorAddressInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkDescriptorAddressInfoEXT::initialize(const VkDescriptorAddressInfoEXT* in_struct,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    address = in_struct->address;
+    range = in_struct->range;
+    format = in_struct->format;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDescriptorAddressInfoEXT::initialize(const safe_VkDescriptorAddressInfoEXT* copy_src,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    address = copy_src->address;
+    range = copy_src->range;
+    format = copy_src->format;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDescriptorBufferBindingInfoEXT::safe_VkDescriptorBufferBindingInfoEXT(const VkDescriptorBufferBindingInfoEXT* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType), address(in_struct->address), usage(in_struct->usage) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDescriptorBufferBindingInfoEXT::safe_VkDescriptorBufferBindingInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT), pNext(nullptr), address(), usage() {}
+
+safe_VkDescriptorBufferBindingInfoEXT::safe_VkDescriptorBufferBindingInfoEXT(
+    const safe_VkDescriptorBufferBindingInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    address = copy_src.address;
+    usage = copy_src.usage;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDescriptorBufferBindingInfoEXT& safe_VkDescriptorBufferBindingInfoEXT::operator=(
+    const safe_VkDescriptorBufferBindingInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    address = copy_src.address;
+    usage = copy_src.usage;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDescriptorBufferBindingInfoEXT::~safe_VkDescriptorBufferBindingInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkDescriptorBufferBindingInfoEXT::initialize(const VkDescriptorBufferBindingInfoEXT* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    address = in_struct->address;
+    usage = in_struct->usage;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDescriptorBufferBindingInfoEXT::initialize(const safe_VkDescriptorBufferBindingInfoEXT* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    address = copy_src->address;
+    usage = copy_src->usage;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT::safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
+    const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), buffer(in_struct->buffer) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT::safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT()
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT), pNext(nullptr), buffer() {}
+
+safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT::safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
+    const safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT& copy_src) {
+    sType = copy_src.sType;
+    buffer = copy_src.buffer;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT& safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT::operator=(
+    const safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    buffer = copy_src.buffer;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT::~safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT::initialize(
+    const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    buffer = in_struct->buffer;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT::initialize(
+    const safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    buffer = copy_src->buffer;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDescriptorGetInfoEXT::safe_VkDescriptorGetInfoEXT(const VkDescriptorGetInfoEXT* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), type(in_struct->type), data(&in_struct->data, in_struct->type) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDescriptorGetInfoEXT::safe_VkDescriptorGetInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT), pNext(nullptr), type() {}
+
+safe_VkDescriptorGetInfoEXT::safe_VkDescriptorGetInfoEXT(const safe_VkDescriptorGetInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    type = copy_src.type;
+    data.initialize(&copy_src.data);
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDescriptorGetInfoEXT& safe_VkDescriptorGetInfoEXT::operator=(const safe_VkDescriptorGetInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    type = copy_src.type;
+    data.initialize(&copy_src.data);
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDescriptorGetInfoEXT::~safe_VkDescriptorGetInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkDescriptorGetInfoEXT::initialize(const VkDescriptorGetInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    type = in_struct->type;
+    data.initialize(&in_struct->data, in_struct->type);
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDescriptorGetInfoEXT::initialize(const safe_VkDescriptorGetInfoEXT* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    type = copy_src->type;
+    data.initialize(&copy_src->data);
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkBufferCaptureDescriptorDataInfoEXT::safe_VkBufferCaptureDescriptorDataInfoEXT(
+    const VkBufferCaptureDescriptorDataInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), buffer(in_struct->buffer) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkBufferCaptureDescriptorDataInfoEXT::safe_VkBufferCaptureDescriptorDataInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT), pNext(nullptr), buffer() {}
+
+safe_VkBufferCaptureDescriptorDataInfoEXT::safe_VkBufferCaptureDescriptorDataInfoEXT(
+    const safe_VkBufferCaptureDescriptorDataInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    buffer = copy_src.buffer;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBufferCaptureDescriptorDataInfoEXT& safe_VkBufferCaptureDescriptorDataInfoEXT::operator=(
+    const safe_VkBufferCaptureDescriptorDataInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    buffer = copy_src.buffer;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkBufferCaptureDescriptorDataInfoEXT::~safe_VkBufferCaptureDescriptorDataInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkBufferCaptureDescriptorDataInfoEXT::initialize(const VkBufferCaptureDescriptorDataInfoEXT* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    buffer = in_struct->buffer;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkBufferCaptureDescriptorDataInfoEXT::initialize(const safe_VkBufferCaptureDescriptorDataInfoEXT* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    buffer = copy_src->buffer;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkImageCaptureDescriptorDataInfoEXT::safe_VkImageCaptureDescriptorDataInfoEXT(
+    const VkImageCaptureDescriptorDataInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), image(in_struct->image) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImageCaptureDescriptorDataInfoEXT::safe_VkImageCaptureDescriptorDataInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT), pNext(nullptr), image() {}
+
+safe_VkImageCaptureDescriptorDataInfoEXT::safe_VkImageCaptureDescriptorDataInfoEXT(
+    const safe_VkImageCaptureDescriptorDataInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    image = copy_src.image;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImageCaptureDescriptorDataInfoEXT& safe_VkImageCaptureDescriptorDataInfoEXT::operator=(
+    const safe_VkImageCaptureDescriptorDataInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    image = copy_src.image;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImageCaptureDescriptorDataInfoEXT::~safe_VkImageCaptureDescriptorDataInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkImageCaptureDescriptorDataInfoEXT::initialize(const VkImageCaptureDescriptorDataInfoEXT* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    image = in_struct->image;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImageCaptureDescriptorDataInfoEXT::initialize(const safe_VkImageCaptureDescriptorDataInfoEXT* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    image = copy_src->image;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkImageViewCaptureDescriptorDataInfoEXT::safe_VkImageViewCaptureDescriptorDataInfoEXT(
+    const VkImageViewCaptureDescriptorDataInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), imageView(in_struct->imageView) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImageViewCaptureDescriptorDataInfoEXT::safe_VkImageViewCaptureDescriptorDataInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT), pNext(nullptr), imageView() {}
+
+safe_VkImageViewCaptureDescriptorDataInfoEXT::safe_VkImageViewCaptureDescriptorDataInfoEXT(
+    const safe_VkImageViewCaptureDescriptorDataInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    imageView = copy_src.imageView;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImageViewCaptureDescriptorDataInfoEXT& safe_VkImageViewCaptureDescriptorDataInfoEXT::operator=(
+    const safe_VkImageViewCaptureDescriptorDataInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    imageView = copy_src.imageView;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImageViewCaptureDescriptorDataInfoEXT::~safe_VkImageViewCaptureDescriptorDataInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkImageViewCaptureDescriptorDataInfoEXT::initialize(const VkImageViewCaptureDescriptorDataInfoEXT* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    imageView = in_struct->imageView;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImageViewCaptureDescriptorDataInfoEXT::initialize(const safe_VkImageViewCaptureDescriptorDataInfoEXT* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imageView = copy_src->imageView;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSamplerCaptureDescriptorDataInfoEXT::safe_VkSamplerCaptureDescriptorDataInfoEXT(
+    const VkSamplerCaptureDescriptorDataInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), sampler(in_struct->sampler) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSamplerCaptureDescriptorDataInfoEXT::safe_VkSamplerCaptureDescriptorDataInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT), pNext(nullptr), sampler() {}
+
+safe_VkSamplerCaptureDescriptorDataInfoEXT::safe_VkSamplerCaptureDescriptorDataInfoEXT(
+    const safe_VkSamplerCaptureDescriptorDataInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    sampler = copy_src.sampler;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSamplerCaptureDescriptorDataInfoEXT& safe_VkSamplerCaptureDescriptorDataInfoEXT::operator=(
+    const safe_VkSamplerCaptureDescriptorDataInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    sampler = copy_src.sampler;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSamplerCaptureDescriptorDataInfoEXT::~safe_VkSamplerCaptureDescriptorDataInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkSamplerCaptureDescriptorDataInfoEXT::initialize(const VkSamplerCaptureDescriptorDataInfoEXT* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    sampler = in_struct->sampler;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSamplerCaptureDescriptorDataInfoEXT::initialize(const safe_VkSamplerCaptureDescriptorDataInfoEXT* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    sampler = copy_src->sampler;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT::safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
+    const VkOpaqueCaptureDescriptorDataCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), opaqueCaptureDescriptorData(in_struct->opaqueCaptureDescriptorData) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT::safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT),
+      pNext(nullptr),
+      opaqueCaptureDescriptorData(nullptr) {}
+
+safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT::safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
+    const safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    opaqueCaptureDescriptorData = copy_src.opaqueCaptureDescriptorData;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT& safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT::operator=(
+    const safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    opaqueCaptureDescriptorData = copy_src.opaqueCaptureDescriptorData;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT::~safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT::initialize(const VkOpaqueCaptureDescriptorDataCreateInfoEXT* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    opaqueCaptureDescriptorData = in_struct->opaqueCaptureDescriptorData;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT::initialize(const safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    opaqueCaptureDescriptorData = copy_src->opaqueCaptureDescriptorData;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT::safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT(
+    const VkAccelerationStructureCaptureDescriptorDataInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      accelerationStructure(in_struct->accelerationStructure),
+      accelerationStructureNV(in_struct->accelerationStructureNV) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT::safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT),
+      pNext(nullptr),
+      accelerationStructure(),
+      accelerationStructureNV() {}
+
+safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT::safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT(
+    const safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    accelerationStructure = copy_src.accelerationStructure;
+    accelerationStructureNV = copy_src.accelerationStructureNV;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT& safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT::operator=(
+    const safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    accelerationStructure = copy_src.accelerationStructure;
+    accelerationStructureNV = copy_src.accelerationStructureNV;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT::~safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT::initialize(
+    const VkAccelerationStructureCaptureDescriptorDataInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    accelerationStructure = in_struct->accelerationStructure;
+    accelerationStructureNV = in_struct->accelerationStructureNV;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT::initialize(
+    const safe_VkAccelerationStructureCaptureDescriptorDataInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    accelerationStructure = copy_src->accelerationStructure;
+    accelerationStructureNV = copy_src->accelerationStructureNV;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT::safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
+    const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), graphicsPipelineLibrary(in_struct->graphicsPipelineLibrary) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT::safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT), pNext(nullptr), graphicsPipelineLibrary() {}
+
+safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT::safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
+    const safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    graphicsPipelineLibrary = copy_src.graphicsPipelineLibrary;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT& safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    graphicsPipelineLibrary = copy_src.graphicsPipelineLibrary;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT::~safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT::initialize(
+    const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    graphicsPipelineLibrary = in_struct->graphicsPipelineLibrary;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    graphicsPipelineLibrary = copy_src->graphicsPipelineLibrary;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT::safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
+    const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      graphicsPipelineLibraryFastLinking(in_struct->graphicsPipelineLibraryFastLinking),
+      graphicsPipelineLibraryIndependentInterpolationDecoration(
+          in_struct->graphicsPipelineLibraryIndependentInterpolationDecoration) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT::safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT),
+      pNext(nullptr),
+      graphicsPipelineLibraryFastLinking(),
+      graphicsPipelineLibraryIndependentInterpolationDecoration() {}
+
+safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT::safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
+    const safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    graphicsPipelineLibraryFastLinking = copy_src.graphicsPipelineLibraryFastLinking;
+    graphicsPipelineLibraryIndependentInterpolationDecoration = copy_src.graphicsPipelineLibraryIndependentInterpolationDecoration;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT& safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT::operator=(
+    const safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    graphicsPipelineLibraryFastLinking = copy_src.graphicsPipelineLibraryFastLinking;
+    graphicsPipelineLibraryIndependentInterpolationDecoration = copy_src.graphicsPipelineLibraryIndependentInterpolationDecoration;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT::~safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT::initialize(
+    const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    graphicsPipelineLibraryFastLinking = in_struct->graphicsPipelineLibraryFastLinking;
+    graphicsPipelineLibraryIndependentInterpolationDecoration =
+        in_struct->graphicsPipelineLibraryIndependentInterpolationDecoration;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT::initialize(
+    const safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    graphicsPipelineLibraryFastLinking = copy_src->graphicsPipelineLibraryFastLinking;
+    graphicsPipelineLibraryIndependentInterpolationDecoration = copy_src->graphicsPipelineLibraryIndependentInterpolationDecoration;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkGraphicsPipelineLibraryCreateInfoEXT::safe_VkGraphicsPipelineLibraryCreateInfoEXT(
+    const VkGraphicsPipelineLibraryCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkGraphicsPipelineLibraryCreateInfoEXT::safe_VkGraphicsPipelineLibraryCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT), pNext(nullptr), flags() {}
+
+safe_VkGraphicsPipelineLibraryCreateInfoEXT::safe_VkGraphicsPipelineLibraryCreateInfoEXT(
+    const safe_VkGraphicsPipelineLibraryCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkGraphicsPipelineLibraryCreateInfoEXT& safe_VkGraphicsPipelineLibraryCreateInfoEXT::operator=(
+    const safe_VkGraphicsPipelineLibraryCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkGraphicsPipelineLibraryCreateInfoEXT::~safe_VkGraphicsPipelineLibraryCreateInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkGraphicsPipelineLibraryCreateInfoEXT::initialize(const VkGraphicsPipelineLibraryCreateInfoEXT* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkGraphicsPipelineLibraryCreateInfoEXT::initialize(const safe_VkGraphicsPipelineLibraryCreateInfoEXT* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
+    const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), ycbcr2plane444Formats(in_struct->ycbcr2plane444Formats) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT), pNext(nullptr), ycbcr2plane444Formats() {}
+
+safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
+    const safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    ycbcr2plane444Formats = copy_src.ycbcr2plane444Formats;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    ycbcr2plane444Formats = copy_src.ycbcr2plane444Formats;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::~safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::initialize(
+    const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    ycbcr2plane444Formats = in_struct->ycbcr2plane444Formats;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    ycbcr2plane444Formats = copy_src->ycbcr2plane444Formats;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT::safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
+    const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), fragmentDensityMapDeferred(in_struct->fragmentDensityMapDeferred) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT::safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT), pNext(nullptr), fragmentDensityMapDeferred() {}
+
+safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT::safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
+    const safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    fragmentDensityMapDeferred = copy_src.fragmentDensityMapDeferred;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT& safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    fragmentDensityMapDeferred = copy_src.fragmentDensityMapDeferred;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT::~safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT::initialize(
+    const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    fragmentDensityMapDeferred = in_struct->fragmentDensityMapDeferred;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    fragmentDensityMapDeferred = copy_src->fragmentDensityMapDeferred;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT::safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
+    const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      subsampledLoads(in_struct->subsampledLoads),
+      subsampledCoarseReconstructionEarlyAccess(in_struct->subsampledCoarseReconstructionEarlyAccess),
+      maxSubsampledArrayLayers(in_struct->maxSubsampledArrayLayers),
+      maxDescriptorSetSubsampledSamplers(in_struct->maxDescriptorSetSubsampledSamplers) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT::safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT),
+      pNext(nullptr),
+      subsampledLoads(),
+      subsampledCoarseReconstructionEarlyAccess(),
+      maxSubsampledArrayLayers(),
+      maxDescriptorSetSubsampledSamplers() {}
+
+safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT::safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
+    const safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    subsampledLoads = copy_src.subsampledLoads;
+    subsampledCoarseReconstructionEarlyAccess = copy_src.subsampledCoarseReconstructionEarlyAccess;
+    maxSubsampledArrayLayers = copy_src.maxSubsampledArrayLayers;
+    maxDescriptorSetSubsampledSamplers = copy_src.maxDescriptorSetSubsampledSamplers;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT& safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT::operator=(
+    const safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    subsampledLoads = copy_src.subsampledLoads;
+    subsampledCoarseReconstructionEarlyAccess = copy_src.subsampledCoarseReconstructionEarlyAccess;
+    maxSubsampledArrayLayers = copy_src.maxSubsampledArrayLayers;
+    maxDescriptorSetSubsampledSamplers = copy_src.maxDescriptorSetSubsampledSamplers;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT::~safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT::initialize(
+    const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    subsampledLoads = in_struct->subsampledLoads;
+    subsampledCoarseReconstructionEarlyAccess = in_struct->subsampledCoarseReconstructionEarlyAccess;
+    maxSubsampledArrayLayers = in_struct->maxSubsampledArrayLayers;
+    maxDescriptorSetSubsampledSamplers = in_struct->maxDescriptorSetSubsampledSamplers;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT::initialize(
+    const safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    subsampledLoads = copy_src->subsampledLoads;
+    subsampledCoarseReconstructionEarlyAccess = copy_src->subsampledCoarseReconstructionEarlyAccess;
+    maxSubsampledArrayLayers = copy_src->maxSubsampledArrayLayers;
+    maxDescriptorSetSubsampledSamplers = copy_src->maxDescriptorSetSubsampledSamplers;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT::safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
+    const VkPhysicalDeviceImageCompressionControlFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), imageCompressionControl(in_struct->imageCompressionControl) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT::safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT), pNext(nullptr), imageCompressionControl() {}
+
+safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT::safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
+    const safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    imageCompressionControl = copy_src.imageCompressionControl;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT& safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    imageCompressionControl = copy_src.imageCompressionControl;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT::~safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT::initialize(
+    const VkPhysicalDeviceImageCompressionControlFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    imageCompressionControl = in_struct->imageCompressionControl;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imageCompressionControl = copy_src->imageCompressionControl;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkImageCompressionControlEXT::safe_VkImageCompressionControlEXT(const VkImageCompressionControlEXT* in_struct,
+                                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      compressionControlPlaneCount(in_struct->compressionControlPlaneCount),
+      pFixedRateFlags(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pFixedRateFlags) {
+        pFixedRateFlags = new VkImageCompressionFixedRateFlagsEXT[in_struct->compressionControlPlaneCount];
+        memcpy((void*)pFixedRateFlags, (void*)in_struct->pFixedRateFlags,
+               sizeof(VkImageCompressionFixedRateFlagsEXT) * in_struct->compressionControlPlaneCount);
+    }
+}
+
+safe_VkImageCompressionControlEXT::safe_VkImageCompressionControlEXT()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT),
+      pNext(nullptr),
+      flags(),
+      compressionControlPlaneCount(),
+      pFixedRateFlags(nullptr) {}
+
+safe_VkImageCompressionControlEXT::safe_VkImageCompressionControlEXT(const safe_VkImageCompressionControlEXT& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    compressionControlPlaneCount = copy_src.compressionControlPlaneCount;
+    pFixedRateFlags = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pFixedRateFlags) {
+        pFixedRateFlags = new VkImageCompressionFixedRateFlagsEXT[copy_src.compressionControlPlaneCount];
+        memcpy((void*)pFixedRateFlags, (void*)copy_src.pFixedRateFlags,
+               sizeof(VkImageCompressionFixedRateFlagsEXT) * copy_src.compressionControlPlaneCount);
+    }
+}
+
+safe_VkImageCompressionControlEXT& safe_VkImageCompressionControlEXT::operator=(const safe_VkImageCompressionControlEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pFixedRateFlags) delete[] pFixedRateFlags;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    compressionControlPlaneCount = copy_src.compressionControlPlaneCount;
+    pFixedRateFlags = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pFixedRateFlags) {
+        pFixedRateFlags = new VkImageCompressionFixedRateFlagsEXT[copy_src.compressionControlPlaneCount];
+        memcpy((void*)pFixedRateFlags, (void*)copy_src.pFixedRateFlags,
+               sizeof(VkImageCompressionFixedRateFlagsEXT) * copy_src.compressionControlPlaneCount);
+    }
+
+    return *this;
+}
+
+safe_VkImageCompressionControlEXT::~safe_VkImageCompressionControlEXT() {
+    if (pFixedRateFlags) delete[] pFixedRateFlags;
+    FreePnextChain(pNext);
+}
+
+void safe_VkImageCompressionControlEXT::initialize(const VkImageCompressionControlEXT* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pFixedRateFlags) delete[] pFixedRateFlags;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    compressionControlPlaneCount = in_struct->compressionControlPlaneCount;
+    pFixedRateFlags = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pFixedRateFlags) {
+        pFixedRateFlags = new VkImageCompressionFixedRateFlagsEXT[in_struct->compressionControlPlaneCount];
+        memcpy((void*)pFixedRateFlags, (void*)in_struct->pFixedRateFlags,
+               sizeof(VkImageCompressionFixedRateFlagsEXT) * in_struct->compressionControlPlaneCount);
+    }
+}
+
+void safe_VkImageCompressionControlEXT::initialize(const safe_VkImageCompressionControlEXT* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    compressionControlPlaneCount = copy_src->compressionControlPlaneCount;
+    pFixedRateFlags = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pFixedRateFlags) {
+        pFixedRateFlags = new VkImageCompressionFixedRateFlagsEXT[copy_src->compressionControlPlaneCount];
+        memcpy((void*)pFixedRateFlags, (void*)copy_src->pFixedRateFlags,
+               sizeof(VkImageCompressionFixedRateFlagsEXT) * copy_src->compressionControlPlaneCount);
+    }
+}
+
+safe_VkImageCompressionPropertiesEXT::safe_VkImageCompressionPropertiesEXT(const VkImageCompressionPropertiesEXT* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType),
+      imageCompressionFlags(in_struct->imageCompressionFlags),
+      imageCompressionFixedRateFlags(in_struct->imageCompressionFixedRateFlags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImageCompressionPropertiesEXT::safe_VkImageCompressionPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT),
+      pNext(nullptr),
+      imageCompressionFlags(),
+      imageCompressionFixedRateFlags() {}
+
+safe_VkImageCompressionPropertiesEXT::safe_VkImageCompressionPropertiesEXT(const safe_VkImageCompressionPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    imageCompressionFlags = copy_src.imageCompressionFlags;
+    imageCompressionFixedRateFlags = copy_src.imageCompressionFixedRateFlags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImageCompressionPropertiesEXT& safe_VkImageCompressionPropertiesEXT::operator=(
+    const safe_VkImageCompressionPropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    imageCompressionFlags = copy_src.imageCompressionFlags;
+    imageCompressionFixedRateFlags = copy_src.imageCompressionFixedRateFlags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImageCompressionPropertiesEXT::~safe_VkImageCompressionPropertiesEXT() { FreePnextChain(pNext); }
+
+void safe_VkImageCompressionPropertiesEXT::initialize(const VkImageCompressionPropertiesEXT* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    imageCompressionFlags = in_struct->imageCompressionFlags;
+    imageCompressionFixedRateFlags = in_struct->imageCompressionFixedRateFlags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImageCompressionPropertiesEXT::initialize(const safe_VkImageCompressionPropertiesEXT* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imageCompressionFlags = copy_src->imageCompressionFlags;
+    imageCompressionFixedRateFlags = copy_src->imageCompressionFixedRateFlags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT::safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
+    const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), attachmentFeedbackLoopLayout(in_struct->attachmentFeedbackLoopLayout) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT::safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT),
+      pNext(nullptr),
+      attachmentFeedbackLoopLayout() {}
+
+safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT::safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
+    const safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    attachmentFeedbackLoopLayout = copy_src.attachmentFeedbackLoopLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT&
+safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    attachmentFeedbackLoopLayout = copy_src.attachmentFeedbackLoopLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT::~safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT::initialize(
+    const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    attachmentFeedbackLoopLayout = in_struct->attachmentFeedbackLoopLayout;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    attachmentFeedbackLoopLayout = copy_src->attachmentFeedbackLoopLayout;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDevice4444FormatsFeaturesEXT::safe_VkPhysicalDevice4444FormatsFeaturesEXT(
+    const VkPhysicalDevice4444FormatsFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), formatA4R4G4B4(in_struct->formatA4R4G4B4), formatA4B4G4R4(in_struct->formatA4B4G4R4) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevice4444FormatsFeaturesEXT::safe_VkPhysicalDevice4444FormatsFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT), pNext(nullptr), formatA4R4G4B4(), formatA4B4G4R4() {}
+
+safe_VkPhysicalDevice4444FormatsFeaturesEXT::safe_VkPhysicalDevice4444FormatsFeaturesEXT(
+    const safe_VkPhysicalDevice4444FormatsFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    formatA4R4G4B4 = copy_src.formatA4R4G4B4;
+    formatA4B4G4R4 = copy_src.formatA4B4G4R4;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevice4444FormatsFeaturesEXT& safe_VkPhysicalDevice4444FormatsFeaturesEXT::operator=(
+    const safe_VkPhysicalDevice4444FormatsFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    formatA4R4G4B4 = copy_src.formatA4R4G4B4;
+    formatA4B4G4R4 = copy_src.formatA4B4G4R4;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevice4444FormatsFeaturesEXT::~safe_VkPhysicalDevice4444FormatsFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDevice4444FormatsFeaturesEXT::initialize(const VkPhysicalDevice4444FormatsFeaturesEXT* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    formatA4R4G4B4 = in_struct->formatA4R4G4B4;
+    formatA4B4G4R4 = in_struct->formatA4B4G4R4;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevice4444FormatsFeaturesEXT::initialize(const safe_VkPhysicalDevice4444FormatsFeaturesEXT* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    formatA4R4G4B4 = copy_src->formatA4R4G4B4;
+    formatA4B4G4R4 = copy_src->formatA4B4G4R4;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceFaultFeaturesEXT::safe_VkPhysicalDeviceFaultFeaturesEXT(const VkPhysicalDeviceFaultFeaturesEXT* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType), deviceFault(in_struct->deviceFault), deviceFaultVendorBinary(in_struct->deviceFaultVendorBinary) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceFaultFeaturesEXT::safe_VkPhysicalDeviceFaultFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT), pNext(nullptr), deviceFault(), deviceFaultVendorBinary() {}
+
+safe_VkPhysicalDeviceFaultFeaturesEXT::safe_VkPhysicalDeviceFaultFeaturesEXT(
+    const safe_VkPhysicalDeviceFaultFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    deviceFault = copy_src.deviceFault;
+    deviceFaultVendorBinary = copy_src.deviceFaultVendorBinary;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceFaultFeaturesEXT& safe_VkPhysicalDeviceFaultFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceFaultFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    deviceFault = copy_src.deviceFault;
+    deviceFaultVendorBinary = copy_src.deviceFaultVendorBinary;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceFaultFeaturesEXT::~safe_VkPhysicalDeviceFaultFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceFaultFeaturesEXT::initialize(const VkPhysicalDeviceFaultFeaturesEXT* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    deviceFault = in_struct->deviceFault;
+    deviceFaultVendorBinary = in_struct->deviceFaultVendorBinary;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceFaultFeaturesEXT::initialize(const safe_VkPhysicalDeviceFaultFeaturesEXT* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    deviceFault = copy_src->deviceFault;
+    deviceFaultVendorBinary = copy_src->deviceFaultVendorBinary;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDeviceFaultCountsEXT::safe_VkDeviceFaultCountsEXT(const VkDeviceFaultCountsEXT* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      addressInfoCount(in_struct->addressInfoCount),
+      vendorInfoCount(in_struct->vendorInfoCount),
+      vendorBinarySize(in_struct->vendorBinarySize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDeviceFaultCountsEXT::safe_VkDeviceFaultCountsEXT()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT), pNext(nullptr), addressInfoCount(), vendorInfoCount(), vendorBinarySize() {}
+
+safe_VkDeviceFaultCountsEXT::safe_VkDeviceFaultCountsEXT(const safe_VkDeviceFaultCountsEXT& copy_src) {
+    sType = copy_src.sType;
+    addressInfoCount = copy_src.addressInfoCount;
+    vendorInfoCount = copy_src.vendorInfoCount;
+    vendorBinarySize = copy_src.vendorBinarySize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDeviceFaultCountsEXT& safe_VkDeviceFaultCountsEXT::operator=(const safe_VkDeviceFaultCountsEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    addressInfoCount = copy_src.addressInfoCount;
+    vendorInfoCount = copy_src.vendorInfoCount;
+    vendorBinarySize = copy_src.vendorBinarySize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDeviceFaultCountsEXT::~safe_VkDeviceFaultCountsEXT() { FreePnextChain(pNext); }
+
+void safe_VkDeviceFaultCountsEXT::initialize(const VkDeviceFaultCountsEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    addressInfoCount = in_struct->addressInfoCount;
+    vendorInfoCount = in_struct->vendorInfoCount;
+    vendorBinarySize = in_struct->vendorBinarySize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDeviceFaultCountsEXT::initialize(const safe_VkDeviceFaultCountsEXT* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    addressInfoCount = copy_src->addressInfoCount;
+    vendorInfoCount = copy_src->vendorInfoCount;
+    vendorBinarySize = copy_src->vendorBinarySize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDeviceFaultInfoEXT::safe_VkDeviceFaultInfoEXT(const VkDeviceFaultInfoEXT* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), pAddressInfos(nullptr), pVendorInfos(nullptr), pVendorBinaryData(in_struct->pVendorBinaryData) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = in_struct->description[i];
+    }
+
+    if (in_struct->pAddressInfos) {
+        pAddressInfos = new VkDeviceFaultAddressInfoEXT(*in_struct->pAddressInfos);
+    }
+
+    if (in_struct->pVendorInfos) {
+        pVendorInfos = new VkDeviceFaultVendorInfoEXT(*in_struct->pVendorInfos);
+    }
+}
+
+safe_VkDeviceFaultInfoEXT::safe_VkDeviceFaultInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT),
+      pNext(nullptr),
+      pAddressInfos(nullptr),
+      pVendorInfos(nullptr),
+      pVendorBinaryData(nullptr) {}
+
+safe_VkDeviceFaultInfoEXT::safe_VkDeviceFaultInfoEXT(const safe_VkDeviceFaultInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    pAddressInfos = nullptr;
+    pVendorInfos = nullptr;
+    pVendorBinaryData = copy_src.pVendorBinaryData;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = copy_src.description[i];
+    }
+
+    if (copy_src.pAddressInfos) {
+        pAddressInfos = new VkDeviceFaultAddressInfoEXT(*copy_src.pAddressInfos);
+    }
+
+    if (copy_src.pVendorInfos) {
+        pVendorInfos = new VkDeviceFaultVendorInfoEXT(*copy_src.pVendorInfos);
+    }
+}
+
+safe_VkDeviceFaultInfoEXT& safe_VkDeviceFaultInfoEXT::operator=(const safe_VkDeviceFaultInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pAddressInfos) delete pAddressInfos;
+    if (pVendorInfos) delete pVendorInfos;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pAddressInfos = nullptr;
+    pVendorInfos = nullptr;
+    pVendorBinaryData = copy_src.pVendorBinaryData;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = copy_src.description[i];
+    }
+
+    if (copy_src.pAddressInfos) {
+        pAddressInfos = new VkDeviceFaultAddressInfoEXT(*copy_src.pAddressInfos);
+    }
+
+    if (copy_src.pVendorInfos) {
+        pVendorInfos = new VkDeviceFaultVendorInfoEXT(*copy_src.pVendorInfos);
+    }
+
+    return *this;
+}
+
+safe_VkDeviceFaultInfoEXT::~safe_VkDeviceFaultInfoEXT() {
+    if (pAddressInfos) delete pAddressInfos;
+    if (pVendorInfos) delete pVendorInfos;
+    FreePnextChain(pNext);
+}
+
+void safe_VkDeviceFaultInfoEXT::initialize(const VkDeviceFaultInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pAddressInfos) delete pAddressInfos;
+    if (pVendorInfos) delete pVendorInfos;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pAddressInfos = nullptr;
+    pVendorInfos = nullptr;
+    pVendorBinaryData = in_struct->pVendorBinaryData;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = in_struct->description[i];
+    }
+
+    if (in_struct->pAddressInfos) {
+        pAddressInfos = new VkDeviceFaultAddressInfoEXT(*in_struct->pAddressInfos);
+    }
+
+    if (in_struct->pVendorInfos) {
+        pVendorInfos = new VkDeviceFaultVendorInfoEXT(*in_struct->pVendorInfos);
+    }
+}
+
+void safe_VkDeviceFaultInfoEXT::initialize(const safe_VkDeviceFaultInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pAddressInfos = nullptr;
+    pVendorInfos = nullptr;
+    pVendorBinaryData = copy_src->pVendorBinaryData;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = copy_src->description[i];
+    }
+
+    if (copy_src->pAddressInfos) {
+        pAddressInfos = new VkDeviceFaultAddressInfoEXT(*copy_src->pAddressInfos);
+    }
+
+    if (copy_src->pVendorInfos) {
+        pVendorInfos = new VkDeviceFaultVendorInfoEXT(*copy_src->pVendorInfos);
+    }
+}
+
+safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT::
+    safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+        const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+        bool copy_pnext)
+    : sType(in_struct->sType),
+      rasterizationOrderColorAttachmentAccess(in_struct->rasterizationOrderColorAttachmentAccess),
+      rasterizationOrderDepthAttachmentAccess(in_struct->rasterizationOrderDepthAttachmentAccess),
+      rasterizationOrderStencilAttachmentAccess(in_struct->rasterizationOrderStencilAttachmentAccess) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT::
+    safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT),
+      pNext(nullptr),
+      rasterizationOrderColorAttachmentAccess(),
+      rasterizationOrderDepthAttachmentAccess(),
+      rasterizationOrderStencilAttachmentAccess() {}
+
+safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT::
+    safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+        const safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    rasterizationOrderColorAttachmentAccess = copy_src.rasterizationOrderColorAttachmentAccess;
+    rasterizationOrderDepthAttachmentAccess = copy_src.rasterizationOrderDepthAttachmentAccess;
+    rasterizationOrderStencilAttachmentAccess = copy_src.rasterizationOrderStencilAttachmentAccess;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT&
+safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    rasterizationOrderColorAttachmentAccess = copy_src.rasterizationOrderColorAttachmentAccess;
+    rasterizationOrderDepthAttachmentAccess = copy_src.rasterizationOrderDepthAttachmentAccess;
+    rasterizationOrderStencilAttachmentAccess = copy_src.rasterizationOrderStencilAttachmentAccess;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT::
+    ~safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT::initialize(
+    const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    rasterizationOrderColorAttachmentAccess = in_struct->rasterizationOrderColorAttachmentAccess;
+    rasterizationOrderDepthAttachmentAccess = in_struct->rasterizationOrderDepthAttachmentAccess;
+    rasterizationOrderStencilAttachmentAccess = in_struct->rasterizationOrderStencilAttachmentAccess;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* copy_src,
+    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    rasterizationOrderColorAttachmentAccess = copy_src->rasterizationOrderColorAttachmentAccess;
+    rasterizationOrderDepthAttachmentAccess = copy_src->rasterizationOrderDepthAttachmentAccess;
+    rasterizationOrderStencilAttachmentAccess = copy_src->rasterizationOrderStencilAttachmentAccess;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT::safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
+    const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), formatRgba10x6WithoutYCbCrSampler(in_struct->formatRgba10x6WithoutYCbCrSampler) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT::safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT), pNext(nullptr), formatRgba10x6WithoutYCbCrSampler() {}
+
+safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT::safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
+    const safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    formatRgba10x6WithoutYCbCrSampler = copy_src.formatRgba10x6WithoutYCbCrSampler;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT& safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    formatRgba10x6WithoutYCbCrSampler = copy_src.formatRgba10x6WithoutYCbCrSampler;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT::~safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT::initialize(const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    formatRgba10x6WithoutYCbCrSampler = in_struct->formatRgba10x6WithoutYCbCrSampler;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT::initialize(const safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    formatRgba10x6WithoutYCbCrSampler = copy_src->formatRgba10x6WithoutYCbCrSampler;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+
+safe_VkDirectFBSurfaceCreateInfoEXT::safe_VkDirectFBSurfaceCreateInfoEXT(const VkDirectFBSurfaceCreateInfoEXT* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags), dfb(nullptr), surface(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->dfb) {
+        dfb = new IDirectFB(*in_struct->dfb);
+    }
+
+    if (in_struct->surface) {
+        surface = new IDirectFBSurface(*in_struct->surface);
+    }
+}
+
+safe_VkDirectFBSurfaceCreateInfoEXT::safe_VkDirectFBSurfaceCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT), pNext(nullptr), flags(), dfb(nullptr), surface(nullptr) {}
+
+safe_VkDirectFBSurfaceCreateInfoEXT::safe_VkDirectFBSurfaceCreateInfoEXT(const safe_VkDirectFBSurfaceCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    dfb = nullptr;
+    surface = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.dfb) {
+        dfb = new IDirectFB(*copy_src.dfb);
+    }
+
+    if (copy_src.surface) {
+        surface = new IDirectFBSurface(*copy_src.surface);
+    }
+}
+
+safe_VkDirectFBSurfaceCreateInfoEXT& safe_VkDirectFBSurfaceCreateInfoEXT::operator=(
+    const safe_VkDirectFBSurfaceCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (dfb) delete dfb;
+    if (surface) delete surface;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    dfb = nullptr;
+    surface = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.dfb) {
+        dfb = new IDirectFB(*copy_src.dfb);
+    }
+
+    if (copy_src.surface) {
+        surface = new IDirectFBSurface(*copy_src.surface);
+    }
+
+    return *this;
+}
+
+safe_VkDirectFBSurfaceCreateInfoEXT::~safe_VkDirectFBSurfaceCreateInfoEXT() {
+    if (dfb) delete dfb;
+    if (surface) delete surface;
+    FreePnextChain(pNext);
+}
+
+void safe_VkDirectFBSurfaceCreateInfoEXT::initialize(const VkDirectFBSurfaceCreateInfoEXT* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    if (dfb) delete dfb;
+    if (surface) delete surface;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    dfb = nullptr;
+    surface = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->dfb) {
+        dfb = new IDirectFB(*in_struct->dfb);
+    }
+
+    if (in_struct->surface) {
+        surface = new IDirectFBSurface(*in_struct->surface);
+    }
+}
+
+void safe_VkDirectFBSurfaceCreateInfoEXT::initialize(const safe_VkDirectFBSurfaceCreateInfoEXT* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    dfb = nullptr;
+    surface = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->dfb) {
+        dfb = new IDirectFB(*copy_src->dfb);
+    }
+
+    if (copy_src->surface) {
+        surface = new IDirectFBSurface(*copy_src->surface);
+    }
+}
+#endif  // VK_USE_PLATFORM_DIRECTFB_EXT
+
+safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT::safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
+    const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), mutableDescriptorType(in_struct->mutableDescriptorType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT::safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT), pNext(nullptr), mutableDescriptorType() {}
+
+safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT::safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
+    const safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    mutableDescriptorType = copy_src.mutableDescriptorType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT& safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    mutableDescriptorType = copy_src.mutableDescriptorType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT::~safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT::initialize(
+    const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    mutableDescriptorType = in_struct->mutableDescriptorType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    mutableDescriptorType = copy_src->mutableDescriptorType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkMutableDescriptorTypeListEXT::safe_VkMutableDescriptorTypeListEXT(const VkMutableDescriptorTypeListEXT* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state)
+    : descriptorTypeCount(in_struct->descriptorTypeCount), pDescriptorTypes(nullptr) {
+    if (in_struct->pDescriptorTypes) {
+        pDescriptorTypes = new VkDescriptorType[in_struct->descriptorTypeCount];
+        memcpy((void*)pDescriptorTypes, (void*)in_struct->pDescriptorTypes,
+               sizeof(VkDescriptorType) * in_struct->descriptorTypeCount);
+    }
+}
+
+safe_VkMutableDescriptorTypeListEXT::safe_VkMutableDescriptorTypeListEXT() : descriptorTypeCount(), pDescriptorTypes(nullptr) {}
+
+safe_VkMutableDescriptorTypeListEXT::safe_VkMutableDescriptorTypeListEXT(const safe_VkMutableDescriptorTypeListEXT& copy_src) {
+    descriptorTypeCount = copy_src.descriptorTypeCount;
+    pDescriptorTypes = nullptr;
+
+    if (copy_src.pDescriptorTypes) {
+        pDescriptorTypes = new VkDescriptorType[copy_src.descriptorTypeCount];
+        memcpy((void*)pDescriptorTypes, (void*)copy_src.pDescriptorTypes, sizeof(VkDescriptorType) * copy_src.descriptorTypeCount);
+    }
+}
+
+safe_VkMutableDescriptorTypeListEXT& safe_VkMutableDescriptorTypeListEXT::operator=(
+    const safe_VkMutableDescriptorTypeListEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pDescriptorTypes) delete[] pDescriptorTypes;
+
+    descriptorTypeCount = copy_src.descriptorTypeCount;
+    pDescriptorTypes = nullptr;
+
+    if (copy_src.pDescriptorTypes) {
+        pDescriptorTypes = new VkDescriptorType[copy_src.descriptorTypeCount];
+        memcpy((void*)pDescriptorTypes, (void*)copy_src.pDescriptorTypes, sizeof(VkDescriptorType) * copy_src.descriptorTypeCount);
+    }
+
+    return *this;
+}
+
+safe_VkMutableDescriptorTypeListEXT::~safe_VkMutableDescriptorTypeListEXT() {
+    if (pDescriptorTypes) delete[] pDescriptorTypes;
+}
+
+void safe_VkMutableDescriptorTypeListEXT::initialize(const VkMutableDescriptorTypeListEXT* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pDescriptorTypes) delete[] pDescriptorTypes;
+    descriptorTypeCount = in_struct->descriptorTypeCount;
+    pDescriptorTypes = nullptr;
+
+    if (in_struct->pDescriptorTypes) {
+        pDescriptorTypes = new VkDescriptorType[in_struct->descriptorTypeCount];
+        memcpy((void*)pDescriptorTypes, (void*)in_struct->pDescriptorTypes,
+               sizeof(VkDescriptorType) * in_struct->descriptorTypeCount);
+    }
+}
+
+void safe_VkMutableDescriptorTypeListEXT::initialize(const safe_VkMutableDescriptorTypeListEXT* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    descriptorTypeCount = copy_src->descriptorTypeCount;
+    pDescriptorTypes = nullptr;
+
+    if (copy_src->pDescriptorTypes) {
+        pDescriptorTypes = new VkDescriptorType[copy_src->descriptorTypeCount];
+        memcpy((void*)pDescriptorTypes, (void*)copy_src->pDescriptorTypes,
+               sizeof(VkDescriptorType) * copy_src->descriptorTypeCount);
+    }
+}
+
+safe_VkMutableDescriptorTypeCreateInfoEXT::safe_VkMutableDescriptorTypeCreateInfoEXT(
+    const VkMutableDescriptorTypeCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      mutableDescriptorTypeListCount(in_struct->mutableDescriptorTypeListCount),
+      pMutableDescriptorTypeLists(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (mutableDescriptorTypeListCount && in_struct->pMutableDescriptorTypeLists) {
+        pMutableDescriptorTypeLists = new safe_VkMutableDescriptorTypeListEXT[mutableDescriptorTypeListCount];
+        for (uint32_t i = 0; i < mutableDescriptorTypeListCount; ++i) {
+            pMutableDescriptorTypeLists[i].initialize(&in_struct->pMutableDescriptorTypeLists[i]);
+        }
+    }
+}
+
+safe_VkMutableDescriptorTypeCreateInfoEXT::safe_VkMutableDescriptorTypeCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT),
+      pNext(nullptr),
+      mutableDescriptorTypeListCount(),
+      pMutableDescriptorTypeLists(nullptr) {}
+
+safe_VkMutableDescriptorTypeCreateInfoEXT::safe_VkMutableDescriptorTypeCreateInfoEXT(
+    const safe_VkMutableDescriptorTypeCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    mutableDescriptorTypeListCount = copy_src.mutableDescriptorTypeListCount;
+    pMutableDescriptorTypeLists = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (mutableDescriptorTypeListCount && copy_src.pMutableDescriptorTypeLists) {
+        pMutableDescriptorTypeLists = new safe_VkMutableDescriptorTypeListEXT[mutableDescriptorTypeListCount];
+        for (uint32_t i = 0; i < mutableDescriptorTypeListCount; ++i) {
+            pMutableDescriptorTypeLists[i].initialize(&copy_src.pMutableDescriptorTypeLists[i]);
+        }
+    }
+}
+
+safe_VkMutableDescriptorTypeCreateInfoEXT& safe_VkMutableDescriptorTypeCreateInfoEXT::operator=(
+    const safe_VkMutableDescriptorTypeCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pMutableDescriptorTypeLists) delete[] pMutableDescriptorTypeLists;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    mutableDescriptorTypeListCount = copy_src.mutableDescriptorTypeListCount;
+    pMutableDescriptorTypeLists = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (mutableDescriptorTypeListCount && copy_src.pMutableDescriptorTypeLists) {
+        pMutableDescriptorTypeLists = new safe_VkMutableDescriptorTypeListEXT[mutableDescriptorTypeListCount];
+        for (uint32_t i = 0; i < mutableDescriptorTypeListCount; ++i) {
+            pMutableDescriptorTypeLists[i].initialize(&copy_src.pMutableDescriptorTypeLists[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkMutableDescriptorTypeCreateInfoEXT::~safe_VkMutableDescriptorTypeCreateInfoEXT() {
+    if (pMutableDescriptorTypeLists) delete[] pMutableDescriptorTypeLists;
+    FreePnextChain(pNext);
+}
+
+void safe_VkMutableDescriptorTypeCreateInfoEXT::initialize(const VkMutableDescriptorTypeCreateInfoEXT* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pMutableDescriptorTypeLists) delete[] pMutableDescriptorTypeLists;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    mutableDescriptorTypeListCount = in_struct->mutableDescriptorTypeListCount;
+    pMutableDescriptorTypeLists = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (mutableDescriptorTypeListCount && in_struct->pMutableDescriptorTypeLists) {
+        pMutableDescriptorTypeLists = new safe_VkMutableDescriptorTypeListEXT[mutableDescriptorTypeListCount];
+        for (uint32_t i = 0; i < mutableDescriptorTypeListCount; ++i) {
+            pMutableDescriptorTypeLists[i].initialize(&in_struct->pMutableDescriptorTypeLists[i]);
+        }
+    }
+}
+
+void safe_VkMutableDescriptorTypeCreateInfoEXT::initialize(const safe_VkMutableDescriptorTypeCreateInfoEXT* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    mutableDescriptorTypeListCount = copy_src->mutableDescriptorTypeListCount;
+    pMutableDescriptorTypeLists = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (mutableDescriptorTypeListCount && copy_src->pMutableDescriptorTypeLists) {
+        pMutableDescriptorTypeLists = new safe_VkMutableDescriptorTypeListEXT[mutableDescriptorTypeListCount];
+        for (uint32_t i = 0; i < mutableDescriptorTypeListCount; ++i) {
+            pMutableDescriptorTypeLists[i].initialize(&copy_src->pMutableDescriptorTypeLists[i]);
+        }
+    }
+}
+
+safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT::safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
+    const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), vertexInputDynamicState(in_struct->vertexInputDynamicState) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT::safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT), pNext(nullptr), vertexInputDynamicState() {}
+
+safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT::safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
+    const safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    vertexInputDynamicState = copy_src.vertexInputDynamicState;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT& safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    vertexInputDynamicState = copy_src.vertexInputDynamicState;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT::~safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT::initialize(
+    const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    vertexInputDynamicState = in_struct->vertexInputDynamicState;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    vertexInputDynamicState = copy_src->vertexInputDynamicState;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVertexInputBindingDescription2EXT::safe_VkVertexInputBindingDescription2EXT(
+    const VkVertexInputBindingDescription2EXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      binding(in_struct->binding),
+      stride(in_struct->stride),
+      inputRate(in_struct->inputRate),
+      divisor(in_struct->divisor) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVertexInputBindingDescription2EXT::safe_VkVertexInputBindingDescription2EXT()
+    : sType(VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT),
+      pNext(nullptr),
+      binding(),
+      stride(),
+      inputRate(),
+      divisor() {}
+
+safe_VkVertexInputBindingDescription2EXT::safe_VkVertexInputBindingDescription2EXT(
+    const safe_VkVertexInputBindingDescription2EXT& copy_src) {
+    sType = copy_src.sType;
+    binding = copy_src.binding;
+    stride = copy_src.stride;
+    inputRate = copy_src.inputRate;
+    divisor = copy_src.divisor;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVertexInputBindingDescription2EXT& safe_VkVertexInputBindingDescription2EXT::operator=(
+    const safe_VkVertexInputBindingDescription2EXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    binding = copy_src.binding;
+    stride = copy_src.stride;
+    inputRate = copy_src.inputRate;
+    divisor = copy_src.divisor;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVertexInputBindingDescription2EXT::~safe_VkVertexInputBindingDescription2EXT() { FreePnextChain(pNext); }
+
+void safe_VkVertexInputBindingDescription2EXT::initialize(const VkVertexInputBindingDescription2EXT* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    binding = in_struct->binding;
+    stride = in_struct->stride;
+    inputRate = in_struct->inputRate;
+    divisor = in_struct->divisor;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVertexInputBindingDescription2EXT::initialize(const safe_VkVertexInputBindingDescription2EXT* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    binding = copy_src->binding;
+    stride = copy_src->stride;
+    inputRate = copy_src->inputRate;
+    divisor = copy_src->divisor;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVertexInputAttributeDescription2EXT::safe_VkVertexInputAttributeDescription2EXT(
+    const VkVertexInputAttributeDescription2EXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      location(in_struct->location),
+      binding(in_struct->binding),
+      format(in_struct->format),
+      offset(in_struct->offset) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVertexInputAttributeDescription2EXT::safe_VkVertexInputAttributeDescription2EXT()
+    : sType(VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT),
+      pNext(nullptr),
+      location(),
+      binding(),
+      format(),
+      offset() {}
+
+safe_VkVertexInputAttributeDescription2EXT::safe_VkVertexInputAttributeDescription2EXT(
+    const safe_VkVertexInputAttributeDescription2EXT& copy_src) {
+    sType = copy_src.sType;
+    location = copy_src.location;
+    binding = copy_src.binding;
+    format = copy_src.format;
+    offset = copy_src.offset;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVertexInputAttributeDescription2EXT& safe_VkVertexInputAttributeDescription2EXT::operator=(
+    const safe_VkVertexInputAttributeDescription2EXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    location = copy_src.location;
+    binding = copy_src.binding;
+    format = copy_src.format;
+    offset = copy_src.offset;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVertexInputAttributeDescription2EXT::~safe_VkVertexInputAttributeDescription2EXT() { FreePnextChain(pNext); }
+
+void safe_VkVertexInputAttributeDescription2EXT::initialize(const VkVertexInputAttributeDescription2EXT* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    location = in_struct->location;
+    binding = in_struct->binding;
+    format = in_struct->format;
+    offset = in_struct->offset;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVertexInputAttributeDescription2EXT::initialize(const safe_VkVertexInputAttributeDescription2EXT* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    location = copy_src->location;
+    binding = copy_src->binding;
+    format = copy_src->format;
+    offset = copy_src->offset;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceDrmPropertiesEXT::safe_VkPhysicalDeviceDrmPropertiesEXT(const VkPhysicalDeviceDrmPropertiesEXT* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType),
+      hasPrimary(in_struct->hasPrimary),
+      hasRender(in_struct->hasRender),
+      primaryMajor(in_struct->primaryMajor),
+      primaryMinor(in_struct->primaryMinor),
+      renderMajor(in_struct->renderMajor),
+      renderMinor(in_struct->renderMinor) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDrmPropertiesEXT::safe_VkPhysicalDeviceDrmPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT),
+      pNext(nullptr),
+      hasPrimary(),
+      hasRender(),
+      primaryMajor(),
+      primaryMinor(),
+      renderMajor(),
+      renderMinor() {}
+
+safe_VkPhysicalDeviceDrmPropertiesEXT::safe_VkPhysicalDeviceDrmPropertiesEXT(
+    const safe_VkPhysicalDeviceDrmPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    hasPrimary = copy_src.hasPrimary;
+    hasRender = copy_src.hasRender;
+    primaryMajor = copy_src.primaryMajor;
+    primaryMinor = copy_src.primaryMinor;
+    renderMajor = copy_src.renderMajor;
+    renderMinor = copy_src.renderMinor;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDrmPropertiesEXT& safe_VkPhysicalDeviceDrmPropertiesEXT::operator=(
+    const safe_VkPhysicalDeviceDrmPropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    hasPrimary = copy_src.hasPrimary;
+    hasRender = copy_src.hasRender;
+    primaryMajor = copy_src.primaryMajor;
+    primaryMinor = copy_src.primaryMinor;
+    renderMajor = copy_src.renderMajor;
+    renderMinor = copy_src.renderMinor;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDrmPropertiesEXT::~safe_VkPhysicalDeviceDrmPropertiesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceDrmPropertiesEXT::initialize(const VkPhysicalDeviceDrmPropertiesEXT* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    hasPrimary = in_struct->hasPrimary;
+    hasRender = in_struct->hasRender;
+    primaryMajor = in_struct->primaryMajor;
+    primaryMinor = in_struct->primaryMinor;
+    renderMajor = in_struct->renderMajor;
+    renderMinor = in_struct->renderMinor;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDrmPropertiesEXT::initialize(const safe_VkPhysicalDeviceDrmPropertiesEXT* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    hasPrimary = copy_src->hasPrimary;
+    hasRender = copy_src->hasRender;
+    primaryMajor = copy_src->primaryMajor;
+    primaryMinor = copy_src->primaryMinor;
+    renderMajor = copy_src->renderMajor;
+    renderMinor = copy_src->renderMinor;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT::safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
+    const VkPhysicalDeviceAddressBindingReportFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), reportAddressBinding(in_struct->reportAddressBinding) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT::safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT), pNext(nullptr), reportAddressBinding() {}
+
+safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT::safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
+    const safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    reportAddressBinding = copy_src.reportAddressBinding;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT& safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    reportAddressBinding = copy_src.reportAddressBinding;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT::~safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT::initialize(
+    const VkPhysicalDeviceAddressBindingReportFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    reportAddressBinding = in_struct->reportAddressBinding;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    reportAddressBinding = copy_src->reportAddressBinding;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDeviceAddressBindingCallbackDataEXT::safe_VkDeviceAddressBindingCallbackDataEXT(
+    const VkDeviceAddressBindingCallbackDataEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      baseAddress(in_struct->baseAddress),
+      size(in_struct->size),
+      bindingType(in_struct->bindingType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDeviceAddressBindingCallbackDataEXT::safe_VkDeviceAddressBindingCallbackDataEXT()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT),
+      pNext(nullptr),
+      flags(),
+      baseAddress(),
+      size(),
+      bindingType() {}
+
+safe_VkDeviceAddressBindingCallbackDataEXT::safe_VkDeviceAddressBindingCallbackDataEXT(
+    const safe_VkDeviceAddressBindingCallbackDataEXT& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    baseAddress = copy_src.baseAddress;
+    size = copy_src.size;
+    bindingType = copy_src.bindingType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDeviceAddressBindingCallbackDataEXT& safe_VkDeviceAddressBindingCallbackDataEXT::operator=(
+    const safe_VkDeviceAddressBindingCallbackDataEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    baseAddress = copy_src.baseAddress;
+    size = copy_src.size;
+    bindingType = copy_src.bindingType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDeviceAddressBindingCallbackDataEXT::~safe_VkDeviceAddressBindingCallbackDataEXT() { FreePnextChain(pNext); }
+
+void safe_VkDeviceAddressBindingCallbackDataEXT::initialize(const VkDeviceAddressBindingCallbackDataEXT* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    baseAddress = in_struct->baseAddress;
+    size = in_struct->size;
+    bindingType = in_struct->bindingType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDeviceAddressBindingCallbackDataEXT::initialize(const safe_VkDeviceAddressBindingCallbackDataEXT* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    baseAddress = copy_src->baseAddress;
+    size = copy_src->size;
+    bindingType = copy_src->bindingType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceDepthClipControlFeaturesEXT::safe_VkPhysicalDeviceDepthClipControlFeaturesEXT(
+    const VkPhysicalDeviceDepthClipControlFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), depthClipControl(in_struct->depthClipControl) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDepthClipControlFeaturesEXT::safe_VkPhysicalDeviceDepthClipControlFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT), pNext(nullptr), depthClipControl() {}
+
+safe_VkPhysicalDeviceDepthClipControlFeaturesEXT::safe_VkPhysicalDeviceDepthClipControlFeaturesEXT(
+    const safe_VkPhysicalDeviceDepthClipControlFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    depthClipControl = copy_src.depthClipControl;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDepthClipControlFeaturesEXT& safe_VkPhysicalDeviceDepthClipControlFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceDepthClipControlFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    depthClipControl = copy_src.depthClipControl;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDepthClipControlFeaturesEXT::~safe_VkPhysicalDeviceDepthClipControlFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceDepthClipControlFeaturesEXT::initialize(const VkPhysicalDeviceDepthClipControlFeaturesEXT* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    depthClipControl = in_struct->depthClipControl;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDepthClipControlFeaturesEXT::initialize(const safe_VkPhysicalDeviceDepthClipControlFeaturesEXT* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    depthClipControl = copy_src->depthClipControl;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineViewportDepthClipControlCreateInfoEXT::safe_VkPipelineViewportDepthClipControlCreateInfoEXT(
+    const VkPipelineViewportDepthClipControlCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), negativeOneToOne(in_struct->negativeOneToOne) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPipelineViewportDepthClipControlCreateInfoEXT::safe_VkPipelineViewportDepthClipControlCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT), pNext(nullptr), negativeOneToOne() {}
+
+safe_VkPipelineViewportDepthClipControlCreateInfoEXT::safe_VkPipelineViewportDepthClipControlCreateInfoEXT(
+    const safe_VkPipelineViewportDepthClipControlCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    negativeOneToOne = copy_src.negativeOneToOne;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPipelineViewportDepthClipControlCreateInfoEXT& safe_VkPipelineViewportDepthClipControlCreateInfoEXT::operator=(
+    const safe_VkPipelineViewportDepthClipControlCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    negativeOneToOne = copy_src.negativeOneToOne;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineViewportDepthClipControlCreateInfoEXT::~safe_VkPipelineViewportDepthClipControlCreateInfoEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineViewportDepthClipControlCreateInfoEXT::initialize(
+    const VkPipelineViewportDepthClipControlCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    negativeOneToOne = in_struct->negativeOneToOne;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPipelineViewportDepthClipControlCreateInfoEXT::initialize(
+    const safe_VkPipelineViewportDepthClipControlCreateInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    negativeOneToOne = copy_src->negativeOneToOne;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT::safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
+    const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      primitiveTopologyListRestart(in_struct->primitiveTopologyListRestart),
+      primitiveTopologyPatchListRestart(in_struct->primitiveTopologyPatchListRestart) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT::safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT),
+      pNext(nullptr),
+      primitiveTopologyListRestart(),
+      primitiveTopologyPatchListRestart() {}
+
+safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT::safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
+    const safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    primitiveTopologyListRestart = copy_src.primitiveTopologyListRestart;
+    primitiveTopologyPatchListRestart = copy_src.primitiveTopologyPatchListRestart;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT&
+safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT::operator=(
+    const safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    primitiveTopologyListRestart = copy_src.primitiveTopologyListRestart;
+    primitiveTopologyPatchListRestart = copy_src.primitiveTopologyPatchListRestart;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT::~safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT::initialize(
+    const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    primitiveTopologyListRestart = in_struct->primitiveTopologyListRestart;
+    primitiveTopologyPatchListRestart = in_struct->primitiveTopologyPatchListRestart;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT::initialize(
+    const safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    primitiveTopologyListRestart = copy_src->primitiveTopologyListRestart;
+    primitiveTopologyPatchListRestart = copy_src->primitiveTopologyPatchListRestart;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelinePropertiesIdentifierEXT::safe_VkPipelinePropertiesIdentifierEXT(const VkPipelinePropertiesIdentifierEXT* in_struct,
+                                                                               [[maybe_unused]] PNextCopyState* copy_state,
+                                                                               bool copy_pnext)
+    : sType(in_struct->sType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        pipelineIdentifier[i] = in_struct->pipelineIdentifier[i];
+    }
+}
+
+safe_VkPipelinePropertiesIdentifierEXT::safe_VkPipelinePropertiesIdentifierEXT()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT), pNext(nullptr) {}
+
+safe_VkPipelinePropertiesIdentifierEXT::safe_VkPipelinePropertiesIdentifierEXT(
+    const safe_VkPipelinePropertiesIdentifierEXT& copy_src) {
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        pipelineIdentifier[i] = copy_src.pipelineIdentifier[i];
+    }
+}
+
+safe_VkPipelinePropertiesIdentifierEXT& safe_VkPipelinePropertiesIdentifierEXT::operator=(
+    const safe_VkPipelinePropertiesIdentifierEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        pipelineIdentifier[i] = copy_src.pipelineIdentifier[i];
+    }
+
+    return *this;
+}
+
+safe_VkPipelinePropertiesIdentifierEXT::~safe_VkPipelinePropertiesIdentifierEXT() { FreePnextChain(pNext); }
+
+void safe_VkPipelinePropertiesIdentifierEXT::initialize(const VkPipelinePropertiesIdentifierEXT* in_struct,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        pipelineIdentifier[i] = in_struct->pipelineIdentifier[i];
+    }
+}
+
+void safe_VkPipelinePropertiesIdentifierEXT::initialize(const safe_VkPipelinePropertiesIdentifierEXT* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        pipelineIdentifier[i] = copy_src->pipelineIdentifier[i];
+    }
+}
+
+safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT::safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
+    const VkPhysicalDevicePipelinePropertiesFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), pipelinePropertiesIdentifier(in_struct->pipelinePropertiesIdentifier) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT::safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT), pNext(nullptr), pipelinePropertiesIdentifier() {}
+
+safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT::safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
+    const safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    pipelinePropertiesIdentifier = copy_src.pipelinePropertiesIdentifier;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT& safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT::operator=(
+    const safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pipelinePropertiesIdentifier = copy_src.pipelinePropertiesIdentifier;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT::~safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT::initialize(const VkPhysicalDevicePipelinePropertiesFeaturesEXT* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pipelinePropertiesIdentifier = in_struct->pipelinePropertiesIdentifier;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT::initialize(
+    const safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pipelinePropertiesIdentifier = copy_src->pipelinePropertiesIdentifier;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT::safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT(
+    const VkPhysicalDeviceFrameBoundaryFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), frameBoundary(in_struct->frameBoundary) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT::safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT), pNext(nullptr), frameBoundary() {}
+
+safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT::safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT(
+    const safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    frameBoundary = copy_src.frameBoundary;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT& safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    frameBoundary = copy_src.frameBoundary;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT::~safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT::initialize(const VkPhysicalDeviceFrameBoundaryFeaturesEXT* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    frameBoundary = in_struct->frameBoundary;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT::initialize(const safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    frameBoundary = copy_src->frameBoundary;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkFrameBoundaryEXT::safe_VkFrameBoundaryEXT(const VkFrameBoundaryEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                                 bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      frameID(in_struct->frameID),
+      imageCount(in_struct->imageCount),
+      pImages(nullptr),
+      bufferCount(in_struct->bufferCount),
+      pBuffers(nullptr),
+      tagName(in_struct->tagName),
+      tagSize(in_struct->tagSize),
+      pTag(in_struct->pTag) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (imageCount && in_struct->pImages) {
+        pImages = new VkImage[imageCount];
+        for (uint32_t i = 0; i < imageCount; ++i) {
+            pImages[i] = in_struct->pImages[i];
+        }
+    }
+    if (bufferCount && in_struct->pBuffers) {
+        pBuffers = new VkBuffer[bufferCount];
+        for (uint32_t i = 0; i < bufferCount; ++i) {
+            pBuffers[i] = in_struct->pBuffers[i];
+        }
+    }
+}
+
+safe_VkFrameBoundaryEXT::safe_VkFrameBoundaryEXT()
+    : sType(VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT),
+      pNext(nullptr),
+      flags(),
+      frameID(),
+      imageCount(),
+      pImages(nullptr),
+      bufferCount(),
+      pBuffers(nullptr),
+      tagName(),
+      tagSize(),
+      pTag(nullptr) {}
+
+safe_VkFrameBoundaryEXT::safe_VkFrameBoundaryEXT(const safe_VkFrameBoundaryEXT& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    frameID = copy_src.frameID;
+    imageCount = copy_src.imageCount;
+    pImages = nullptr;
+    bufferCount = copy_src.bufferCount;
+    pBuffers = nullptr;
+    tagName = copy_src.tagName;
+    tagSize = copy_src.tagSize;
+    pTag = copy_src.pTag;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (imageCount && copy_src.pImages) {
+        pImages = new VkImage[imageCount];
+        for (uint32_t i = 0; i < imageCount; ++i) {
+            pImages[i] = copy_src.pImages[i];
+        }
+    }
+    if (bufferCount && copy_src.pBuffers) {
+        pBuffers = new VkBuffer[bufferCount];
+        for (uint32_t i = 0; i < bufferCount; ++i) {
+            pBuffers[i] = copy_src.pBuffers[i];
+        }
+    }
+}
+
+safe_VkFrameBoundaryEXT& safe_VkFrameBoundaryEXT::operator=(const safe_VkFrameBoundaryEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pImages) delete[] pImages;
+    if (pBuffers) delete[] pBuffers;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    frameID = copy_src.frameID;
+    imageCount = copy_src.imageCount;
+    pImages = nullptr;
+    bufferCount = copy_src.bufferCount;
+    pBuffers = nullptr;
+    tagName = copy_src.tagName;
+    tagSize = copy_src.tagSize;
+    pTag = copy_src.pTag;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (imageCount && copy_src.pImages) {
+        pImages = new VkImage[imageCount];
+        for (uint32_t i = 0; i < imageCount; ++i) {
+            pImages[i] = copy_src.pImages[i];
+        }
+    }
+    if (bufferCount && copy_src.pBuffers) {
+        pBuffers = new VkBuffer[bufferCount];
+        for (uint32_t i = 0; i < bufferCount; ++i) {
+            pBuffers[i] = copy_src.pBuffers[i];
+        }
+    }
+
+    return *this;
+}
+
+safe_VkFrameBoundaryEXT::~safe_VkFrameBoundaryEXT() {
+    if (pImages) delete[] pImages;
+    if (pBuffers) delete[] pBuffers;
+    FreePnextChain(pNext);
+}
+
+void safe_VkFrameBoundaryEXT::initialize(const VkFrameBoundaryEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pImages) delete[] pImages;
+    if (pBuffers) delete[] pBuffers;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    frameID = in_struct->frameID;
+    imageCount = in_struct->imageCount;
+    pImages = nullptr;
+    bufferCount = in_struct->bufferCount;
+    pBuffers = nullptr;
+    tagName = in_struct->tagName;
+    tagSize = in_struct->tagSize;
+    pTag = in_struct->pTag;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (imageCount && in_struct->pImages) {
+        pImages = new VkImage[imageCount];
+        for (uint32_t i = 0; i < imageCount; ++i) {
+            pImages[i] = in_struct->pImages[i];
+        }
+    }
+    if (bufferCount && in_struct->pBuffers) {
+        pBuffers = new VkBuffer[bufferCount];
+        for (uint32_t i = 0; i < bufferCount; ++i) {
+            pBuffers[i] = in_struct->pBuffers[i];
+        }
+    }
+}
+
+void safe_VkFrameBoundaryEXT::initialize(const safe_VkFrameBoundaryEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    frameID = copy_src->frameID;
+    imageCount = copy_src->imageCount;
+    pImages = nullptr;
+    bufferCount = copy_src->bufferCount;
+    pBuffers = nullptr;
+    tagName = copy_src->tagName;
+    tagSize = copy_src->tagSize;
+    pTag = copy_src->pTag;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (imageCount && copy_src->pImages) {
+        pImages = new VkImage[imageCount];
+        for (uint32_t i = 0; i < imageCount; ++i) {
+            pImages[i] = copy_src->pImages[i];
+        }
+    }
+    if (bufferCount && copy_src->pBuffers) {
+        pBuffers = new VkBuffer[bufferCount];
+        for (uint32_t i = 0; i < bufferCount; ++i) {
+            pBuffers[i] = copy_src->pBuffers[i];
+        }
+    }
+}
+
+safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT::
+    safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+        const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+        bool copy_pnext)
+    : sType(in_struct->sType), multisampledRenderToSingleSampled(in_struct->multisampledRenderToSingleSampled) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT::
+    safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT),
+      pNext(nullptr),
+      multisampledRenderToSingleSampled() {}
+
+safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT::
+    safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+        const safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    multisampledRenderToSingleSampled = copy_src.multisampledRenderToSingleSampled;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT&
+safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    multisampledRenderToSingleSampled = copy_src.multisampledRenderToSingleSampled;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT::
+    ~safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT::initialize(
+    const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    multisampledRenderToSingleSampled = in_struct->multisampledRenderToSingleSampled;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* copy_src,
+    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    multisampledRenderToSingleSampled = copy_src->multisampledRenderToSingleSampled;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSubpassResolvePerformanceQueryEXT::safe_VkSubpassResolvePerformanceQueryEXT(
+    const VkSubpassResolvePerformanceQueryEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), optimal(in_struct->optimal) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSubpassResolvePerformanceQueryEXT::safe_VkSubpassResolvePerformanceQueryEXT()
+    : sType(VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT), pNext(nullptr), optimal() {}
+
+safe_VkSubpassResolvePerformanceQueryEXT::safe_VkSubpassResolvePerformanceQueryEXT(
+    const safe_VkSubpassResolvePerformanceQueryEXT& copy_src) {
+    sType = copy_src.sType;
+    optimal = copy_src.optimal;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSubpassResolvePerformanceQueryEXT& safe_VkSubpassResolvePerformanceQueryEXT::operator=(
+    const safe_VkSubpassResolvePerformanceQueryEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    optimal = copy_src.optimal;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSubpassResolvePerformanceQueryEXT::~safe_VkSubpassResolvePerformanceQueryEXT() { FreePnextChain(pNext); }
+
+void safe_VkSubpassResolvePerformanceQueryEXT::initialize(const VkSubpassResolvePerformanceQueryEXT* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    optimal = in_struct->optimal;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSubpassResolvePerformanceQueryEXT::initialize(const safe_VkSubpassResolvePerformanceQueryEXT* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    optimal = copy_src->optimal;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkMultisampledRenderToSingleSampledInfoEXT::safe_VkMultisampledRenderToSingleSampledInfoEXT(
+    const VkMultisampledRenderToSingleSampledInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      multisampledRenderToSingleSampledEnable(in_struct->multisampledRenderToSingleSampledEnable),
+      rasterizationSamples(in_struct->rasterizationSamples) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMultisampledRenderToSingleSampledInfoEXT::safe_VkMultisampledRenderToSingleSampledInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT),
+      pNext(nullptr),
+      multisampledRenderToSingleSampledEnable(),
+      rasterizationSamples() {}
+
+safe_VkMultisampledRenderToSingleSampledInfoEXT::safe_VkMultisampledRenderToSingleSampledInfoEXT(
+    const safe_VkMultisampledRenderToSingleSampledInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    multisampledRenderToSingleSampledEnable = copy_src.multisampledRenderToSingleSampledEnable;
+    rasterizationSamples = copy_src.rasterizationSamples;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMultisampledRenderToSingleSampledInfoEXT& safe_VkMultisampledRenderToSingleSampledInfoEXT::operator=(
+    const safe_VkMultisampledRenderToSingleSampledInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    multisampledRenderToSingleSampledEnable = copy_src.multisampledRenderToSingleSampledEnable;
+    rasterizationSamples = copy_src.rasterizationSamples;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMultisampledRenderToSingleSampledInfoEXT::~safe_VkMultisampledRenderToSingleSampledInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkMultisampledRenderToSingleSampledInfoEXT::initialize(const VkMultisampledRenderToSingleSampledInfoEXT* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    multisampledRenderToSingleSampledEnable = in_struct->multisampledRenderToSingleSampledEnable;
+    rasterizationSamples = in_struct->rasterizationSamples;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMultisampledRenderToSingleSampledInfoEXT::initialize(const safe_VkMultisampledRenderToSingleSampledInfoEXT* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    multisampledRenderToSingleSampledEnable = copy_src->multisampledRenderToSingleSampledEnable;
+    rasterizationSamples = copy_src->rasterizationSamples;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT::safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
+    const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      extendedDynamicState2(in_struct->extendedDynamicState2),
+      extendedDynamicState2LogicOp(in_struct->extendedDynamicState2LogicOp),
+      extendedDynamicState2PatchControlPoints(in_struct->extendedDynamicState2PatchControlPoints) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT::safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT),
+      pNext(nullptr),
+      extendedDynamicState2(),
+      extendedDynamicState2LogicOp(),
+      extendedDynamicState2PatchControlPoints() {}
+
+safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT::safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
+    const safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    extendedDynamicState2 = copy_src.extendedDynamicState2;
+    extendedDynamicState2LogicOp = copy_src.extendedDynamicState2LogicOp;
+    extendedDynamicState2PatchControlPoints = copy_src.extendedDynamicState2PatchControlPoints;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT& safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    extendedDynamicState2 = copy_src.extendedDynamicState2;
+    extendedDynamicState2LogicOp = copy_src.extendedDynamicState2LogicOp;
+    extendedDynamicState2PatchControlPoints = copy_src.extendedDynamicState2PatchControlPoints;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT::~safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT::initialize(
+    const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    extendedDynamicState2 = in_struct->extendedDynamicState2;
+    extendedDynamicState2LogicOp = in_struct->extendedDynamicState2LogicOp;
+    extendedDynamicState2PatchControlPoints = in_struct->extendedDynamicState2PatchControlPoints;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    extendedDynamicState2 = copy_src->extendedDynamicState2;
+    extendedDynamicState2LogicOp = copy_src->extendedDynamicState2LogicOp;
+    extendedDynamicState2PatchControlPoints = copy_src->extendedDynamicState2PatchControlPoints;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT::safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
+    const VkPhysicalDeviceColorWriteEnableFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), colorWriteEnable(in_struct->colorWriteEnable) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT::safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT), pNext(nullptr), colorWriteEnable() {}
+
+safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT::safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
+    const safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    colorWriteEnable = copy_src.colorWriteEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT& safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    colorWriteEnable = copy_src.colorWriteEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT::~safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT::initialize(const VkPhysicalDeviceColorWriteEnableFeaturesEXT* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    colorWriteEnable = in_struct->colorWriteEnable;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT::initialize(const safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    colorWriteEnable = copy_src->colorWriteEnable;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineColorWriteCreateInfoEXT::safe_VkPipelineColorWriteCreateInfoEXT(const VkPipelineColorWriteCreateInfoEXT* in_struct,
+                                                                               [[maybe_unused]] PNextCopyState* copy_state,
+                                                                               bool copy_pnext)
+    : sType(in_struct->sType), attachmentCount(in_struct->attachmentCount), pColorWriteEnables(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pColorWriteEnables) {
+        pColorWriteEnables = new VkBool32[in_struct->attachmentCount];
+        memcpy((void*)pColorWriteEnables, (void*)in_struct->pColorWriteEnables, sizeof(VkBool32) * in_struct->attachmentCount);
+    }
+}
+
+safe_VkPipelineColorWriteCreateInfoEXT::safe_VkPipelineColorWriteCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT),
+      pNext(nullptr),
+      attachmentCount(),
+      pColorWriteEnables(nullptr) {}
+
+safe_VkPipelineColorWriteCreateInfoEXT::safe_VkPipelineColorWriteCreateInfoEXT(
+    const safe_VkPipelineColorWriteCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    attachmentCount = copy_src.attachmentCount;
+    pColorWriteEnables = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pColorWriteEnables) {
+        pColorWriteEnables = new VkBool32[copy_src.attachmentCount];
+        memcpy((void*)pColorWriteEnables, (void*)copy_src.pColorWriteEnables, sizeof(VkBool32) * copy_src.attachmentCount);
+    }
+}
+
+safe_VkPipelineColorWriteCreateInfoEXT& safe_VkPipelineColorWriteCreateInfoEXT::operator=(
+    const safe_VkPipelineColorWriteCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pColorWriteEnables) delete[] pColorWriteEnables;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    attachmentCount = copy_src.attachmentCount;
+    pColorWriteEnables = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pColorWriteEnables) {
+        pColorWriteEnables = new VkBool32[copy_src.attachmentCount];
+        memcpy((void*)pColorWriteEnables, (void*)copy_src.pColorWriteEnables, sizeof(VkBool32) * copy_src.attachmentCount);
+    }
+
+    return *this;
+}
+
+safe_VkPipelineColorWriteCreateInfoEXT::~safe_VkPipelineColorWriteCreateInfoEXT() {
+    if (pColorWriteEnables) delete[] pColorWriteEnables;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineColorWriteCreateInfoEXT::initialize(const VkPipelineColorWriteCreateInfoEXT* in_struct,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pColorWriteEnables) delete[] pColorWriteEnables;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    attachmentCount = in_struct->attachmentCount;
+    pColorWriteEnables = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pColorWriteEnables) {
+        pColorWriteEnables = new VkBool32[in_struct->attachmentCount];
+        memcpy((void*)pColorWriteEnables, (void*)in_struct->pColorWriteEnables, sizeof(VkBool32) * in_struct->attachmentCount);
+    }
+}
+
+void safe_VkPipelineColorWriteCreateInfoEXT::initialize(const safe_VkPipelineColorWriteCreateInfoEXT* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    attachmentCount = copy_src->attachmentCount;
+    pColorWriteEnables = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pColorWriteEnables) {
+        pColorWriteEnables = new VkBool32[copy_src->attachmentCount];
+        memcpy((void*)pColorWriteEnables, (void*)copy_src->pColorWriteEnables, sizeof(VkBool32) * copy_src->attachmentCount);
+    }
+}
+
+safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT::safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
+    const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      primitivesGeneratedQuery(in_struct->primitivesGeneratedQuery),
+      primitivesGeneratedQueryWithRasterizerDiscard(in_struct->primitivesGeneratedQueryWithRasterizerDiscard),
+      primitivesGeneratedQueryWithNonZeroStreams(in_struct->primitivesGeneratedQueryWithNonZeroStreams) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT::safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT),
+      pNext(nullptr),
+      primitivesGeneratedQuery(),
+      primitivesGeneratedQueryWithRasterizerDiscard(),
+      primitivesGeneratedQueryWithNonZeroStreams() {}
+
+safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT::safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
+    const safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    primitivesGeneratedQuery = copy_src.primitivesGeneratedQuery;
+    primitivesGeneratedQueryWithRasterizerDiscard = copy_src.primitivesGeneratedQueryWithRasterizerDiscard;
+    primitivesGeneratedQueryWithNonZeroStreams = copy_src.primitivesGeneratedQueryWithNonZeroStreams;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT& safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT::operator=(
+    const safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    primitivesGeneratedQuery = copy_src.primitivesGeneratedQuery;
+    primitivesGeneratedQueryWithRasterizerDiscard = copy_src.primitivesGeneratedQueryWithRasterizerDiscard;
+    primitivesGeneratedQueryWithNonZeroStreams = copy_src.primitivesGeneratedQueryWithNonZeroStreams;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT::~safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT::initialize(
+    const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    primitivesGeneratedQuery = in_struct->primitivesGeneratedQuery;
+    primitivesGeneratedQueryWithRasterizerDiscard = in_struct->primitivesGeneratedQueryWithRasterizerDiscard;
+    primitivesGeneratedQueryWithNonZeroStreams = in_struct->primitivesGeneratedQueryWithNonZeroStreams;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT::initialize(
+    const safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    primitivesGeneratedQuery = copy_src->primitivesGeneratedQuery;
+    primitivesGeneratedQueryWithRasterizerDiscard = copy_src->primitivesGeneratedQueryWithRasterizerDiscard;
+    primitivesGeneratedQueryWithNonZeroStreams = copy_src->primitivesGeneratedQueryWithNonZeroStreams;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT::safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
+    const VkPhysicalDeviceImageViewMinLodFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), minLod(in_struct->minLod) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT::safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT), pNext(nullptr), minLod() {}
+
+safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT::safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
+    const safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    minLod = copy_src.minLod;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT& safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    minLod = copy_src.minLod;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT::~safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT::initialize(const VkPhysicalDeviceImageViewMinLodFeaturesEXT* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    minLod = in_struct->minLod;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT::initialize(const safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    minLod = copy_src->minLod;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkImageViewMinLodCreateInfoEXT::safe_VkImageViewMinLodCreateInfoEXT(const VkImageViewMinLodCreateInfoEXT* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType), minLod(in_struct->minLod) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImageViewMinLodCreateInfoEXT::safe_VkImageViewMinLodCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT), pNext(nullptr), minLod() {}
+
+safe_VkImageViewMinLodCreateInfoEXT::safe_VkImageViewMinLodCreateInfoEXT(const safe_VkImageViewMinLodCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    minLod = copy_src.minLod;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImageViewMinLodCreateInfoEXT& safe_VkImageViewMinLodCreateInfoEXT::operator=(
+    const safe_VkImageViewMinLodCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    minLod = copy_src.minLod;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImageViewMinLodCreateInfoEXT::~safe_VkImageViewMinLodCreateInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkImageViewMinLodCreateInfoEXT::initialize(const VkImageViewMinLodCreateInfoEXT* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    minLod = in_struct->minLod;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImageViewMinLodCreateInfoEXT::initialize(const safe_VkImageViewMinLodCreateInfoEXT* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    minLod = copy_src->minLod;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceMultiDrawFeaturesEXT::safe_VkPhysicalDeviceMultiDrawFeaturesEXT(
+    const VkPhysicalDeviceMultiDrawFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), multiDraw(in_struct->multiDraw) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMultiDrawFeaturesEXT::safe_VkPhysicalDeviceMultiDrawFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT), pNext(nullptr), multiDraw() {}
+
+safe_VkPhysicalDeviceMultiDrawFeaturesEXT::safe_VkPhysicalDeviceMultiDrawFeaturesEXT(
+    const safe_VkPhysicalDeviceMultiDrawFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    multiDraw = copy_src.multiDraw;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMultiDrawFeaturesEXT& safe_VkPhysicalDeviceMultiDrawFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceMultiDrawFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    multiDraw = copy_src.multiDraw;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMultiDrawFeaturesEXT::~safe_VkPhysicalDeviceMultiDrawFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceMultiDrawFeaturesEXT::initialize(const VkPhysicalDeviceMultiDrawFeaturesEXT* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    multiDraw = in_struct->multiDraw;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMultiDrawFeaturesEXT::initialize(const safe_VkPhysicalDeviceMultiDrawFeaturesEXT* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    multiDraw = copy_src->multiDraw;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceMultiDrawPropertiesEXT::safe_VkPhysicalDeviceMultiDrawPropertiesEXT(
+    const VkPhysicalDeviceMultiDrawPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), maxMultiDrawCount(in_struct->maxMultiDrawCount) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMultiDrawPropertiesEXT::safe_VkPhysicalDeviceMultiDrawPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT), pNext(nullptr), maxMultiDrawCount() {}
+
+safe_VkPhysicalDeviceMultiDrawPropertiesEXT::safe_VkPhysicalDeviceMultiDrawPropertiesEXT(
+    const safe_VkPhysicalDeviceMultiDrawPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    maxMultiDrawCount = copy_src.maxMultiDrawCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMultiDrawPropertiesEXT& safe_VkPhysicalDeviceMultiDrawPropertiesEXT::operator=(
+    const safe_VkPhysicalDeviceMultiDrawPropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxMultiDrawCount = copy_src.maxMultiDrawCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMultiDrawPropertiesEXT::~safe_VkPhysicalDeviceMultiDrawPropertiesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceMultiDrawPropertiesEXT::initialize(const VkPhysicalDeviceMultiDrawPropertiesEXT* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxMultiDrawCount = in_struct->maxMultiDrawCount;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMultiDrawPropertiesEXT::initialize(const safe_VkPhysicalDeviceMultiDrawPropertiesEXT* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxMultiDrawCount = copy_src->maxMultiDrawCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT::safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
+    const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), image2DViewOf3D(in_struct->image2DViewOf3D), sampler2DViewOf3D(in_struct->sampler2DViewOf3D) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT::safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT),
+      pNext(nullptr),
+      image2DViewOf3D(),
+      sampler2DViewOf3D() {}
+
+safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT::safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
+    const safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    image2DViewOf3D = copy_src.image2DViewOf3D;
+    sampler2DViewOf3D = copy_src.sampler2DViewOf3D;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT& safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    image2DViewOf3D = copy_src.image2DViewOf3D;
+    sampler2DViewOf3D = copy_src.sampler2DViewOf3D;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT::~safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT::initialize(const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    image2DViewOf3D = in_struct->image2DViewOf3D;
+    sampler2DViewOf3D = in_struct->sampler2DViewOf3D;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT::initialize(const safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    image2DViewOf3D = copy_src->image2DViewOf3D;
+    sampler2DViewOf3D = copy_src->sampler2DViewOf3D;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceShaderTileImageFeaturesEXT::safe_VkPhysicalDeviceShaderTileImageFeaturesEXT(
+    const VkPhysicalDeviceShaderTileImageFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      shaderTileImageColorReadAccess(in_struct->shaderTileImageColorReadAccess),
+      shaderTileImageDepthReadAccess(in_struct->shaderTileImageDepthReadAccess),
+      shaderTileImageStencilReadAccess(in_struct->shaderTileImageStencilReadAccess) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderTileImageFeaturesEXT::safe_VkPhysicalDeviceShaderTileImageFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT),
+      pNext(nullptr),
+      shaderTileImageColorReadAccess(),
+      shaderTileImageDepthReadAccess(),
+      shaderTileImageStencilReadAccess() {}
+
+safe_VkPhysicalDeviceShaderTileImageFeaturesEXT::safe_VkPhysicalDeviceShaderTileImageFeaturesEXT(
+    const safe_VkPhysicalDeviceShaderTileImageFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    shaderTileImageColorReadAccess = copy_src.shaderTileImageColorReadAccess;
+    shaderTileImageDepthReadAccess = copy_src.shaderTileImageDepthReadAccess;
+    shaderTileImageStencilReadAccess = copy_src.shaderTileImageStencilReadAccess;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderTileImageFeaturesEXT& safe_VkPhysicalDeviceShaderTileImageFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceShaderTileImageFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderTileImageColorReadAccess = copy_src.shaderTileImageColorReadAccess;
+    shaderTileImageDepthReadAccess = copy_src.shaderTileImageDepthReadAccess;
+    shaderTileImageStencilReadAccess = copy_src.shaderTileImageStencilReadAccess;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderTileImageFeaturesEXT::~safe_VkPhysicalDeviceShaderTileImageFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceShaderTileImageFeaturesEXT::initialize(const VkPhysicalDeviceShaderTileImageFeaturesEXT* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderTileImageColorReadAccess = in_struct->shaderTileImageColorReadAccess;
+    shaderTileImageDepthReadAccess = in_struct->shaderTileImageDepthReadAccess;
+    shaderTileImageStencilReadAccess = in_struct->shaderTileImageStencilReadAccess;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderTileImageFeaturesEXT::initialize(const safe_VkPhysicalDeviceShaderTileImageFeaturesEXT* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderTileImageColorReadAccess = copy_src->shaderTileImageColorReadAccess;
+    shaderTileImageDepthReadAccess = copy_src->shaderTileImageDepthReadAccess;
+    shaderTileImageStencilReadAccess = copy_src->shaderTileImageStencilReadAccess;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceShaderTileImagePropertiesEXT::safe_VkPhysicalDeviceShaderTileImagePropertiesEXT(
+    const VkPhysicalDeviceShaderTileImagePropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      shaderTileImageCoherentReadAccelerated(in_struct->shaderTileImageCoherentReadAccelerated),
+      shaderTileImageReadSampleFromPixelRateInvocation(in_struct->shaderTileImageReadSampleFromPixelRateInvocation),
+      shaderTileImageReadFromHelperInvocation(in_struct->shaderTileImageReadFromHelperInvocation) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderTileImagePropertiesEXT::safe_VkPhysicalDeviceShaderTileImagePropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT),
+      pNext(nullptr),
+      shaderTileImageCoherentReadAccelerated(),
+      shaderTileImageReadSampleFromPixelRateInvocation(),
+      shaderTileImageReadFromHelperInvocation() {}
+
+safe_VkPhysicalDeviceShaderTileImagePropertiesEXT::safe_VkPhysicalDeviceShaderTileImagePropertiesEXT(
+    const safe_VkPhysicalDeviceShaderTileImagePropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    shaderTileImageCoherentReadAccelerated = copy_src.shaderTileImageCoherentReadAccelerated;
+    shaderTileImageReadSampleFromPixelRateInvocation = copy_src.shaderTileImageReadSampleFromPixelRateInvocation;
+    shaderTileImageReadFromHelperInvocation = copy_src.shaderTileImageReadFromHelperInvocation;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderTileImagePropertiesEXT& safe_VkPhysicalDeviceShaderTileImagePropertiesEXT::operator=(
+    const safe_VkPhysicalDeviceShaderTileImagePropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderTileImageCoherentReadAccelerated = copy_src.shaderTileImageCoherentReadAccelerated;
+    shaderTileImageReadSampleFromPixelRateInvocation = copy_src.shaderTileImageReadSampleFromPixelRateInvocation;
+    shaderTileImageReadFromHelperInvocation = copy_src.shaderTileImageReadFromHelperInvocation;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderTileImagePropertiesEXT::~safe_VkPhysicalDeviceShaderTileImagePropertiesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceShaderTileImagePropertiesEXT::initialize(const VkPhysicalDeviceShaderTileImagePropertiesEXT* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderTileImageCoherentReadAccelerated = in_struct->shaderTileImageCoherentReadAccelerated;
+    shaderTileImageReadSampleFromPixelRateInvocation = in_struct->shaderTileImageReadSampleFromPixelRateInvocation;
+    shaderTileImageReadFromHelperInvocation = in_struct->shaderTileImageReadFromHelperInvocation;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderTileImagePropertiesEXT::initialize(
+    const safe_VkPhysicalDeviceShaderTileImagePropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderTileImageCoherentReadAccelerated = copy_src->shaderTileImageCoherentReadAccelerated;
+    shaderTileImageReadSampleFromPixelRateInvocation = copy_src->shaderTileImageReadSampleFromPixelRateInvocation;
+    shaderTileImageReadFromHelperInvocation = copy_src->shaderTileImageReadFromHelperInvocation;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkMicromapCreateInfoEXT::safe_VkMicromapCreateInfoEXT(const VkMicromapCreateInfoEXT* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      createFlags(in_struct->createFlags),
+      buffer(in_struct->buffer),
+      offset(in_struct->offset),
+      size(in_struct->size),
+      type(in_struct->type),
+      deviceAddress(in_struct->deviceAddress) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMicromapCreateInfoEXT::safe_VkMicromapCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT),
+      pNext(nullptr),
+      createFlags(),
+      buffer(),
+      offset(),
+      size(),
+      type(),
+      deviceAddress() {}
+
+safe_VkMicromapCreateInfoEXT::safe_VkMicromapCreateInfoEXT(const safe_VkMicromapCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    createFlags = copy_src.createFlags;
+    buffer = copy_src.buffer;
+    offset = copy_src.offset;
+    size = copy_src.size;
+    type = copy_src.type;
+    deviceAddress = copy_src.deviceAddress;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMicromapCreateInfoEXT& safe_VkMicromapCreateInfoEXT::operator=(const safe_VkMicromapCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    createFlags = copy_src.createFlags;
+    buffer = copy_src.buffer;
+    offset = copy_src.offset;
+    size = copy_src.size;
+    type = copy_src.type;
+    deviceAddress = copy_src.deviceAddress;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMicromapCreateInfoEXT::~safe_VkMicromapCreateInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkMicromapCreateInfoEXT::initialize(const VkMicromapCreateInfoEXT* in_struct,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    createFlags = in_struct->createFlags;
+    buffer = in_struct->buffer;
+    offset = in_struct->offset;
+    size = in_struct->size;
+    type = in_struct->type;
+    deviceAddress = in_struct->deviceAddress;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMicromapCreateInfoEXT::initialize(const safe_VkMicromapCreateInfoEXT* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    createFlags = copy_src->createFlags;
+    buffer = copy_src->buffer;
+    offset = copy_src->offset;
+    size = copy_src->size;
+    type = copy_src->type;
+    deviceAddress = copy_src->deviceAddress;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT::safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
+    const VkPhysicalDeviceOpacityMicromapFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      micromap(in_struct->micromap),
+      micromapCaptureReplay(in_struct->micromapCaptureReplay),
+      micromapHostCommands(in_struct->micromapHostCommands) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT::safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT),
+      pNext(nullptr),
+      micromap(),
+      micromapCaptureReplay(),
+      micromapHostCommands() {}
+
+safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT::safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
+    const safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    micromap = copy_src.micromap;
+    micromapCaptureReplay = copy_src.micromapCaptureReplay;
+    micromapHostCommands = copy_src.micromapHostCommands;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT& safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    micromap = copy_src.micromap;
+    micromapCaptureReplay = copy_src.micromapCaptureReplay;
+    micromapHostCommands = copy_src.micromapHostCommands;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT::~safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT::initialize(const VkPhysicalDeviceOpacityMicromapFeaturesEXT* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    micromap = in_struct->micromap;
+    micromapCaptureReplay = in_struct->micromapCaptureReplay;
+    micromapHostCommands = in_struct->micromapHostCommands;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT::initialize(const safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    micromap = copy_src->micromap;
+    micromapCaptureReplay = copy_src->micromapCaptureReplay;
+    micromapHostCommands = copy_src->micromapHostCommands;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT::safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
+    const VkPhysicalDeviceOpacityMicromapPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      maxOpacity2StateSubdivisionLevel(in_struct->maxOpacity2StateSubdivisionLevel),
+      maxOpacity4StateSubdivisionLevel(in_struct->maxOpacity4StateSubdivisionLevel) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT::safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT),
+      pNext(nullptr),
+      maxOpacity2StateSubdivisionLevel(),
+      maxOpacity4StateSubdivisionLevel() {}
+
+safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT::safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
+    const safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    maxOpacity2StateSubdivisionLevel = copy_src.maxOpacity2StateSubdivisionLevel;
+    maxOpacity4StateSubdivisionLevel = copy_src.maxOpacity4StateSubdivisionLevel;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT& safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT::operator=(
+    const safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxOpacity2StateSubdivisionLevel = copy_src.maxOpacity2StateSubdivisionLevel;
+    maxOpacity4StateSubdivisionLevel = copy_src.maxOpacity4StateSubdivisionLevel;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT::~safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT::initialize(const VkPhysicalDeviceOpacityMicromapPropertiesEXT* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxOpacity2StateSubdivisionLevel = in_struct->maxOpacity2StateSubdivisionLevel;
+    maxOpacity4StateSubdivisionLevel = in_struct->maxOpacity4StateSubdivisionLevel;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT::initialize(
+    const safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxOpacity2StateSubdivisionLevel = copy_src->maxOpacity2StateSubdivisionLevel;
+    maxOpacity4StateSubdivisionLevel = copy_src->maxOpacity4StateSubdivisionLevel;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkMicromapVersionInfoEXT::safe_VkMicromapVersionInfoEXT(const VkMicromapVersionInfoEXT* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), pVersionData(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pVersionData) {
+        pVersionData = new uint8_t[2 * VK_UUID_SIZE];
+        memcpy((void*)pVersionData, (void*)in_struct->pVersionData, sizeof(uint8_t) * 2 * VK_UUID_SIZE);
+    }
+}
+
+safe_VkMicromapVersionInfoEXT::safe_VkMicromapVersionInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT), pNext(nullptr), pVersionData(nullptr) {}
+
+safe_VkMicromapVersionInfoEXT::safe_VkMicromapVersionInfoEXT(const safe_VkMicromapVersionInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    pVersionData = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pVersionData) {
+        pVersionData = new uint8_t[2 * VK_UUID_SIZE];
+        memcpy((void*)pVersionData, (void*)copy_src.pVersionData, sizeof(uint8_t) * 2 * VK_UUID_SIZE);
+    }
+}
+
+safe_VkMicromapVersionInfoEXT& safe_VkMicromapVersionInfoEXT::operator=(const safe_VkMicromapVersionInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pVersionData) delete[] pVersionData;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pVersionData = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pVersionData) {
+        pVersionData = new uint8_t[2 * VK_UUID_SIZE];
+        memcpy((void*)pVersionData, (void*)copy_src.pVersionData, sizeof(uint8_t) * 2 * VK_UUID_SIZE);
+    }
+
+    return *this;
+}
+
+safe_VkMicromapVersionInfoEXT::~safe_VkMicromapVersionInfoEXT() {
+    if (pVersionData) delete[] pVersionData;
+    FreePnextChain(pNext);
+}
+
+void safe_VkMicromapVersionInfoEXT::initialize(const VkMicromapVersionInfoEXT* in_struct,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pVersionData) delete[] pVersionData;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pVersionData = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pVersionData) {
+        pVersionData = new uint8_t[2 * VK_UUID_SIZE];
+        memcpy((void*)pVersionData, (void*)in_struct->pVersionData, sizeof(uint8_t) * 2 * VK_UUID_SIZE);
+    }
+}
+
+void safe_VkMicromapVersionInfoEXT::initialize(const safe_VkMicromapVersionInfoEXT* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pVersionData = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pVersionData) {
+        pVersionData = new uint8_t[2 * VK_UUID_SIZE];
+        memcpy((void*)pVersionData, (void*)copy_src->pVersionData, sizeof(uint8_t) * 2 * VK_UUID_SIZE);
+    }
+}
+
+safe_VkCopyMicromapToMemoryInfoEXT::safe_VkCopyMicromapToMemoryInfoEXT(const VkCopyMicromapToMemoryInfoEXT* in_struct,
+                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), src(in_struct->src), dst(&in_struct->dst), mode(in_struct->mode) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkCopyMicromapToMemoryInfoEXT::safe_VkCopyMicromapToMemoryInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT), pNext(nullptr), src(), mode() {}
+
+safe_VkCopyMicromapToMemoryInfoEXT::safe_VkCopyMicromapToMemoryInfoEXT(const safe_VkCopyMicromapToMemoryInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    src = copy_src.src;
+    dst.initialize(&copy_src.dst);
+    mode = copy_src.mode;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkCopyMicromapToMemoryInfoEXT& safe_VkCopyMicromapToMemoryInfoEXT::operator=(
+    const safe_VkCopyMicromapToMemoryInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    src = copy_src.src;
+    dst.initialize(&copy_src.dst);
+    mode = copy_src.mode;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkCopyMicromapToMemoryInfoEXT::~safe_VkCopyMicromapToMemoryInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkCopyMicromapToMemoryInfoEXT::initialize(const VkCopyMicromapToMemoryInfoEXT* in_struct,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    src = in_struct->src;
+    dst.initialize(&in_struct->dst);
+    mode = in_struct->mode;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkCopyMicromapToMemoryInfoEXT::initialize(const safe_VkCopyMicromapToMemoryInfoEXT* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    src = copy_src->src;
+    dst.initialize(&copy_src->dst);
+    mode = copy_src->mode;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkCopyMemoryToMicromapInfoEXT::safe_VkCopyMemoryToMicromapInfoEXT(const VkCopyMemoryToMicromapInfoEXT* in_struct,
+                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), src(&in_struct->src), dst(in_struct->dst), mode(in_struct->mode) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkCopyMemoryToMicromapInfoEXT::safe_VkCopyMemoryToMicromapInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT), pNext(nullptr), dst(), mode() {}
+
+safe_VkCopyMemoryToMicromapInfoEXT::safe_VkCopyMemoryToMicromapInfoEXT(const safe_VkCopyMemoryToMicromapInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    src.initialize(&copy_src.src);
+    dst = copy_src.dst;
+    mode = copy_src.mode;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkCopyMemoryToMicromapInfoEXT& safe_VkCopyMemoryToMicromapInfoEXT::operator=(
+    const safe_VkCopyMemoryToMicromapInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    src.initialize(&copy_src.src);
+    dst = copy_src.dst;
+    mode = copy_src.mode;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkCopyMemoryToMicromapInfoEXT::~safe_VkCopyMemoryToMicromapInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkCopyMemoryToMicromapInfoEXT::initialize(const VkCopyMemoryToMicromapInfoEXT* in_struct,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    src.initialize(&in_struct->src);
+    dst = in_struct->dst;
+    mode = in_struct->mode;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkCopyMemoryToMicromapInfoEXT::initialize(const safe_VkCopyMemoryToMicromapInfoEXT* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    src.initialize(&copy_src->src);
+    dst = copy_src->dst;
+    mode = copy_src->mode;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkCopyMicromapInfoEXT::safe_VkCopyMicromapInfoEXT(const VkCopyMicromapInfoEXT* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), src(in_struct->src), dst(in_struct->dst), mode(in_struct->mode) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkCopyMicromapInfoEXT::safe_VkCopyMicromapInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT), pNext(nullptr), src(), dst(), mode() {}
+
+safe_VkCopyMicromapInfoEXT::safe_VkCopyMicromapInfoEXT(const safe_VkCopyMicromapInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    src = copy_src.src;
+    dst = copy_src.dst;
+    mode = copy_src.mode;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkCopyMicromapInfoEXT& safe_VkCopyMicromapInfoEXT::operator=(const safe_VkCopyMicromapInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    src = copy_src.src;
+    dst = copy_src.dst;
+    mode = copy_src.mode;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkCopyMicromapInfoEXT::~safe_VkCopyMicromapInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkCopyMicromapInfoEXT::initialize(const VkCopyMicromapInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    src = in_struct->src;
+    dst = in_struct->dst;
+    mode = in_struct->mode;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkCopyMicromapInfoEXT::initialize(const safe_VkCopyMicromapInfoEXT* copy_src,
+                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    src = copy_src->src;
+    dst = copy_src->dst;
+    mode = copy_src->mode;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkMicromapBuildSizesInfoEXT::safe_VkMicromapBuildSizesInfoEXT(const VkMicromapBuildSizesInfoEXT* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      micromapSize(in_struct->micromapSize),
+      buildScratchSize(in_struct->buildScratchSize),
+      discardable(in_struct->discardable) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMicromapBuildSizesInfoEXT::safe_VkMicromapBuildSizesInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT), pNext(nullptr), micromapSize(), buildScratchSize(), discardable() {}
+
+safe_VkMicromapBuildSizesInfoEXT::safe_VkMicromapBuildSizesInfoEXT(const safe_VkMicromapBuildSizesInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    micromapSize = copy_src.micromapSize;
+    buildScratchSize = copy_src.buildScratchSize;
+    discardable = copy_src.discardable;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMicromapBuildSizesInfoEXT& safe_VkMicromapBuildSizesInfoEXT::operator=(const safe_VkMicromapBuildSizesInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    micromapSize = copy_src.micromapSize;
+    buildScratchSize = copy_src.buildScratchSize;
+    discardable = copy_src.discardable;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMicromapBuildSizesInfoEXT::~safe_VkMicromapBuildSizesInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkMicromapBuildSizesInfoEXT::initialize(const VkMicromapBuildSizesInfoEXT* in_struct,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    micromapSize = in_struct->micromapSize;
+    buildScratchSize = in_struct->buildScratchSize;
+    discardable = in_struct->discardable;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMicromapBuildSizesInfoEXT::initialize(const safe_VkMicromapBuildSizesInfoEXT* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    micromapSize = copy_src->micromapSize;
+    buildScratchSize = copy_src->buildScratchSize;
+    discardable = copy_src->discardable;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT::safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
+    const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      borderColorSwizzle(in_struct->borderColorSwizzle),
+      borderColorSwizzleFromImage(in_struct->borderColorSwizzleFromImage) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT::safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT),
+      pNext(nullptr),
+      borderColorSwizzle(),
+      borderColorSwizzleFromImage() {}
+
+safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT::safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
+    const safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    borderColorSwizzle = copy_src.borderColorSwizzle;
+    borderColorSwizzleFromImage = copy_src.borderColorSwizzleFromImage;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT& safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    borderColorSwizzle = copy_src.borderColorSwizzle;
+    borderColorSwizzleFromImage = copy_src.borderColorSwizzleFromImage;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT::~safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT::initialize(const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    borderColorSwizzle = in_struct->borderColorSwizzle;
+    borderColorSwizzleFromImage = in_struct->borderColorSwizzleFromImage;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    borderColorSwizzle = copy_src->borderColorSwizzle;
+    borderColorSwizzleFromImage = copy_src->borderColorSwizzleFromImage;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSamplerBorderColorComponentMappingCreateInfoEXT::safe_VkSamplerBorderColorComponentMappingCreateInfoEXT(
+    const VkSamplerBorderColorComponentMappingCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), components(in_struct->components), srgb(in_struct->srgb) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSamplerBorderColorComponentMappingCreateInfoEXT::safe_VkSamplerBorderColorComponentMappingCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT), pNext(nullptr), components(), srgb() {}
+
+safe_VkSamplerBorderColorComponentMappingCreateInfoEXT::safe_VkSamplerBorderColorComponentMappingCreateInfoEXT(
+    const safe_VkSamplerBorderColorComponentMappingCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    components = copy_src.components;
+    srgb = copy_src.srgb;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSamplerBorderColorComponentMappingCreateInfoEXT& safe_VkSamplerBorderColorComponentMappingCreateInfoEXT::operator=(
+    const safe_VkSamplerBorderColorComponentMappingCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    components = copy_src.components;
+    srgb = copy_src.srgb;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSamplerBorderColorComponentMappingCreateInfoEXT::~safe_VkSamplerBorderColorComponentMappingCreateInfoEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkSamplerBorderColorComponentMappingCreateInfoEXT::initialize(
+    const VkSamplerBorderColorComponentMappingCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    components = in_struct->components;
+    srgb = in_struct->srgb;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSamplerBorderColorComponentMappingCreateInfoEXT::initialize(
+    const safe_VkSamplerBorderColorComponentMappingCreateInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    components = copy_src->components;
+    srgb = copy_src->srgb;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT::safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
+    const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), pageableDeviceLocalMemory(in_struct->pageableDeviceLocalMemory) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT::safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT),
+      pNext(nullptr),
+      pageableDeviceLocalMemory() {}
+
+safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT::safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
+    const safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    pageableDeviceLocalMemory = copy_src.pageableDeviceLocalMemory;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT& safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT::operator=(
+    const safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pageableDeviceLocalMemory = copy_src.pageableDeviceLocalMemory;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT::~safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT::initialize(
+    const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pageableDeviceLocalMemory = in_struct->pageableDeviceLocalMemory;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT::initialize(
+    const safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pageableDeviceLocalMemory = copy_src->pageableDeviceLocalMemory;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT::safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
+    const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), imageSlicedViewOf3D(in_struct->imageSlicedViewOf3D) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT::safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT), pNext(nullptr), imageSlicedViewOf3D() {}
+
+safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT::safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
+    const safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    imageSlicedViewOf3D = copy_src.imageSlicedViewOf3D;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT& safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    imageSlicedViewOf3D = copy_src.imageSlicedViewOf3D;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT::~safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT::initialize(
+    const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    imageSlicedViewOf3D = in_struct->imageSlicedViewOf3D;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imageSlicedViewOf3D = copy_src->imageSlicedViewOf3D;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkImageViewSlicedCreateInfoEXT::safe_VkImageViewSlicedCreateInfoEXT(const VkImageViewSlicedCreateInfoEXT* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType), sliceOffset(in_struct->sliceOffset), sliceCount(in_struct->sliceCount) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImageViewSlicedCreateInfoEXT::safe_VkImageViewSlicedCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT), pNext(nullptr), sliceOffset(), sliceCount() {}
+
+safe_VkImageViewSlicedCreateInfoEXT::safe_VkImageViewSlicedCreateInfoEXT(const safe_VkImageViewSlicedCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    sliceOffset = copy_src.sliceOffset;
+    sliceCount = copy_src.sliceCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImageViewSlicedCreateInfoEXT& safe_VkImageViewSlicedCreateInfoEXT::operator=(
+    const safe_VkImageViewSlicedCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    sliceOffset = copy_src.sliceOffset;
+    sliceCount = copy_src.sliceCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImageViewSlicedCreateInfoEXT::~safe_VkImageViewSlicedCreateInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkImageViewSlicedCreateInfoEXT::initialize(const VkImageViewSlicedCreateInfoEXT* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    sliceOffset = in_struct->sliceOffset;
+    sliceCount = in_struct->sliceCount;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImageViewSlicedCreateInfoEXT::initialize(const safe_VkImageViewSlicedCreateInfoEXT* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    sliceOffset = copy_src->sliceOffset;
+    sliceCount = copy_src->sliceCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT::safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
+    const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), depthClampZeroOne(in_struct->depthClampZeroOne) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT::safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT), pNext(nullptr), depthClampZeroOne() {}
+
+safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT::safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
+    const safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    depthClampZeroOne = copy_src.depthClampZeroOne;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT& safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    depthClampZeroOne = copy_src.depthClampZeroOne;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT::~safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT::initialize(const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    depthClampZeroOne = in_struct->depthClampZeroOne;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    depthClampZeroOne = copy_src->depthClampZeroOne;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT::safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
+    const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), nonSeamlessCubeMap(in_struct->nonSeamlessCubeMap) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT::safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT), pNext(nullptr), nonSeamlessCubeMap() {}
+
+safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT::safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
+    const safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    nonSeamlessCubeMap = copy_src.nonSeamlessCubeMap;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT& safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    nonSeamlessCubeMap = copy_src.nonSeamlessCubeMap;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT::~safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT::initialize(const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    nonSeamlessCubeMap = in_struct->nonSeamlessCubeMap;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    nonSeamlessCubeMap = copy_src->nonSeamlessCubeMap;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT::safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+    const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), imageCompressionControlSwapchain(in_struct->imageCompressionControlSwapchain) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT::safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT),
+      pNext(nullptr),
+      imageCompressionControlSwapchain() {}
+
+safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT::safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+    const safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    imageCompressionControlSwapchain = copy_src.imageCompressionControlSwapchain;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT&
+safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    imageCompressionControlSwapchain = copy_src.imageCompressionControlSwapchain;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT::
+    ~safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT::initialize(
+    const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    imageCompressionControlSwapchain = in_struct->imageCompressionControlSwapchain;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imageCompressionControlSwapchain = copy_src->imageCompressionControlSwapchain;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT::safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT(
+    const VkPhysicalDeviceNestedCommandBufferFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      nestedCommandBuffer(in_struct->nestedCommandBuffer),
+      nestedCommandBufferRendering(in_struct->nestedCommandBufferRendering),
+      nestedCommandBufferSimultaneousUse(in_struct->nestedCommandBufferSimultaneousUse) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT::safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT),
+      pNext(nullptr),
+      nestedCommandBuffer(),
+      nestedCommandBufferRendering(),
+      nestedCommandBufferSimultaneousUse() {}
+
+safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT::safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT(
+    const safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    nestedCommandBuffer = copy_src.nestedCommandBuffer;
+    nestedCommandBufferRendering = copy_src.nestedCommandBufferRendering;
+    nestedCommandBufferSimultaneousUse = copy_src.nestedCommandBufferSimultaneousUse;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT& safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    nestedCommandBuffer = copy_src.nestedCommandBuffer;
+    nestedCommandBufferRendering = copy_src.nestedCommandBufferRendering;
+    nestedCommandBufferSimultaneousUse = copy_src.nestedCommandBufferSimultaneousUse;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT::~safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT::initialize(
+    const VkPhysicalDeviceNestedCommandBufferFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    nestedCommandBuffer = in_struct->nestedCommandBuffer;
+    nestedCommandBufferRendering = in_struct->nestedCommandBufferRendering;
+    nestedCommandBufferSimultaneousUse = in_struct->nestedCommandBufferSimultaneousUse;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    nestedCommandBuffer = copy_src->nestedCommandBuffer;
+    nestedCommandBufferRendering = copy_src->nestedCommandBufferRendering;
+    nestedCommandBufferSimultaneousUse = copy_src->nestedCommandBufferSimultaneousUse;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT::safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT(
+    const VkPhysicalDeviceNestedCommandBufferPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), maxCommandBufferNestingLevel(in_struct->maxCommandBufferNestingLevel) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT::safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT),
+      pNext(nullptr),
+      maxCommandBufferNestingLevel() {}
+
+safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT::safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT(
+    const safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    maxCommandBufferNestingLevel = copy_src.maxCommandBufferNestingLevel;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT& safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT::operator=(
+    const safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxCommandBufferNestingLevel = copy_src.maxCommandBufferNestingLevel;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT::~safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT::initialize(
+    const VkPhysicalDeviceNestedCommandBufferPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxCommandBufferNestingLevel = in_struct->maxCommandBufferNestingLevel;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT::initialize(
+    const safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxCommandBufferNestingLevel = copy_src->maxCommandBufferNestingLevel;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkExternalMemoryAcquireUnmodifiedEXT::safe_VkExternalMemoryAcquireUnmodifiedEXT(
+    const VkExternalMemoryAcquireUnmodifiedEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), acquireUnmodifiedMemory(in_struct->acquireUnmodifiedMemory) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkExternalMemoryAcquireUnmodifiedEXT::safe_VkExternalMemoryAcquireUnmodifiedEXT()
+    : sType(VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT), pNext(nullptr), acquireUnmodifiedMemory() {}
+
+safe_VkExternalMemoryAcquireUnmodifiedEXT::safe_VkExternalMemoryAcquireUnmodifiedEXT(
+    const safe_VkExternalMemoryAcquireUnmodifiedEXT& copy_src) {
+    sType = copy_src.sType;
+    acquireUnmodifiedMemory = copy_src.acquireUnmodifiedMemory;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkExternalMemoryAcquireUnmodifiedEXT& safe_VkExternalMemoryAcquireUnmodifiedEXT::operator=(
+    const safe_VkExternalMemoryAcquireUnmodifiedEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    acquireUnmodifiedMemory = copy_src.acquireUnmodifiedMemory;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkExternalMemoryAcquireUnmodifiedEXT::~safe_VkExternalMemoryAcquireUnmodifiedEXT() { FreePnextChain(pNext); }
+
+void safe_VkExternalMemoryAcquireUnmodifiedEXT::initialize(const VkExternalMemoryAcquireUnmodifiedEXT* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    acquireUnmodifiedMemory = in_struct->acquireUnmodifiedMemory;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkExternalMemoryAcquireUnmodifiedEXT::initialize(const safe_VkExternalMemoryAcquireUnmodifiedEXT* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    acquireUnmodifiedMemory = copy_src->acquireUnmodifiedMemory;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
+    const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      extendedDynamicState3TessellationDomainOrigin(in_struct->extendedDynamicState3TessellationDomainOrigin),
+      extendedDynamicState3DepthClampEnable(in_struct->extendedDynamicState3DepthClampEnable),
+      extendedDynamicState3PolygonMode(in_struct->extendedDynamicState3PolygonMode),
+      extendedDynamicState3RasterizationSamples(in_struct->extendedDynamicState3RasterizationSamples),
+      extendedDynamicState3SampleMask(in_struct->extendedDynamicState3SampleMask),
+      extendedDynamicState3AlphaToCoverageEnable(in_struct->extendedDynamicState3AlphaToCoverageEnable),
+      extendedDynamicState3AlphaToOneEnable(in_struct->extendedDynamicState3AlphaToOneEnable),
+      extendedDynamicState3LogicOpEnable(in_struct->extendedDynamicState3LogicOpEnable),
+      extendedDynamicState3ColorBlendEnable(in_struct->extendedDynamicState3ColorBlendEnable),
+      extendedDynamicState3ColorBlendEquation(in_struct->extendedDynamicState3ColorBlendEquation),
+      extendedDynamicState3ColorWriteMask(in_struct->extendedDynamicState3ColorWriteMask),
+      extendedDynamicState3RasterizationStream(in_struct->extendedDynamicState3RasterizationStream),
+      extendedDynamicState3ConservativeRasterizationMode(in_struct->extendedDynamicState3ConservativeRasterizationMode),
+      extendedDynamicState3ExtraPrimitiveOverestimationSize(in_struct->extendedDynamicState3ExtraPrimitiveOverestimationSize),
+      extendedDynamicState3DepthClipEnable(in_struct->extendedDynamicState3DepthClipEnable),
+      extendedDynamicState3SampleLocationsEnable(in_struct->extendedDynamicState3SampleLocationsEnable),
+      extendedDynamicState3ColorBlendAdvanced(in_struct->extendedDynamicState3ColorBlendAdvanced),
+      extendedDynamicState3ProvokingVertexMode(in_struct->extendedDynamicState3ProvokingVertexMode),
+      extendedDynamicState3LineRasterizationMode(in_struct->extendedDynamicState3LineRasterizationMode),
+      extendedDynamicState3LineStippleEnable(in_struct->extendedDynamicState3LineStippleEnable),
+      extendedDynamicState3DepthClipNegativeOneToOne(in_struct->extendedDynamicState3DepthClipNegativeOneToOne),
+      extendedDynamicState3ViewportWScalingEnable(in_struct->extendedDynamicState3ViewportWScalingEnable),
+      extendedDynamicState3ViewportSwizzle(in_struct->extendedDynamicState3ViewportSwizzle),
+      extendedDynamicState3CoverageToColorEnable(in_struct->extendedDynamicState3CoverageToColorEnable),
+      extendedDynamicState3CoverageToColorLocation(in_struct->extendedDynamicState3CoverageToColorLocation),
+      extendedDynamicState3CoverageModulationMode(in_struct->extendedDynamicState3CoverageModulationMode),
+      extendedDynamicState3CoverageModulationTableEnable(in_struct->extendedDynamicState3CoverageModulationTableEnable),
+      extendedDynamicState3CoverageModulationTable(in_struct->extendedDynamicState3CoverageModulationTable),
+      extendedDynamicState3CoverageReductionMode(in_struct->extendedDynamicState3CoverageReductionMode),
+      extendedDynamicState3RepresentativeFragmentTestEnable(in_struct->extendedDynamicState3RepresentativeFragmentTestEnable),
+      extendedDynamicState3ShadingRateImageEnable(in_struct->extendedDynamicState3ShadingRateImageEnable) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT),
+      pNext(nullptr),
+      extendedDynamicState3TessellationDomainOrigin(),
+      extendedDynamicState3DepthClampEnable(),
+      extendedDynamicState3PolygonMode(),
+      extendedDynamicState3RasterizationSamples(),
+      extendedDynamicState3SampleMask(),
+      extendedDynamicState3AlphaToCoverageEnable(),
+      extendedDynamicState3AlphaToOneEnable(),
+      extendedDynamicState3LogicOpEnable(),
+      extendedDynamicState3ColorBlendEnable(),
+      extendedDynamicState3ColorBlendEquation(),
+      extendedDynamicState3ColorWriteMask(),
+      extendedDynamicState3RasterizationStream(),
+      extendedDynamicState3ConservativeRasterizationMode(),
+      extendedDynamicState3ExtraPrimitiveOverestimationSize(),
+      extendedDynamicState3DepthClipEnable(),
+      extendedDynamicState3SampleLocationsEnable(),
+      extendedDynamicState3ColorBlendAdvanced(),
+      extendedDynamicState3ProvokingVertexMode(),
+      extendedDynamicState3LineRasterizationMode(),
+      extendedDynamicState3LineStippleEnable(),
+      extendedDynamicState3DepthClipNegativeOneToOne(),
+      extendedDynamicState3ViewportWScalingEnable(),
+      extendedDynamicState3ViewportSwizzle(),
+      extendedDynamicState3CoverageToColorEnable(),
+      extendedDynamicState3CoverageToColorLocation(),
+      extendedDynamicState3CoverageModulationMode(),
+      extendedDynamicState3CoverageModulationTableEnable(),
+      extendedDynamicState3CoverageModulationTable(),
+      extendedDynamicState3CoverageReductionMode(),
+      extendedDynamicState3RepresentativeFragmentTestEnable(),
+      extendedDynamicState3ShadingRateImageEnable() {}
+
+safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
+    const safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    extendedDynamicState3TessellationDomainOrigin = copy_src.extendedDynamicState3TessellationDomainOrigin;
+    extendedDynamicState3DepthClampEnable = copy_src.extendedDynamicState3DepthClampEnable;
+    extendedDynamicState3PolygonMode = copy_src.extendedDynamicState3PolygonMode;
+    extendedDynamicState3RasterizationSamples = copy_src.extendedDynamicState3RasterizationSamples;
+    extendedDynamicState3SampleMask = copy_src.extendedDynamicState3SampleMask;
+    extendedDynamicState3AlphaToCoverageEnable = copy_src.extendedDynamicState3AlphaToCoverageEnable;
+    extendedDynamicState3AlphaToOneEnable = copy_src.extendedDynamicState3AlphaToOneEnable;
+    extendedDynamicState3LogicOpEnable = copy_src.extendedDynamicState3LogicOpEnable;
+    extendedDynamicState3ColorBlendEnable = copy_src.extendedDynamicState3ColorBlendEnable;
+    extendedDynamicState3ColorBlendEquation = copy_src.extendedDynamicState3ColorBlendEquation;
+    extendedDynamicState3ColorWriteMask = copy_src.extendedDynamicState3ColorWriteMask;
+    extendedDynamicState3RasterizationStream = copy_src.extendedDynamicState3RasterizationStream;
+    extendedDynamicState3ConservativeRasterizationMode = copy_src.extendedDynamicState3ConservativeRasterizationMode;
+    extendedDynamicState3ExtraPrimitiveOverestimationSize = copy_src.extendedDynamicState3ExtraPrimitiveOverestimationSize;
+    extendedDynamicState3DepthClipEnable = copy_src.extendedDynamicState3DepthClipEnable;
+    extendedDynamicState3SampleLocationsEnable = copy_src.extendedDynamicState3SampleLocationsEnable;
+    extendedDynamicState3ColorBlendAdvanced = copy_src.extendedDynamicState3ColorBlendAdvanced;
+    extendedDynamicState3ProvokingVertexMode = copy_src.extendedDynamicState3ProvokingVertexMode;
+    extendedDynamicState3LineRasterizationMode = copy_src.extendedDynamicState3LineRasterizationMode;
+    extendedDynamicState3LineStippleEnable = copy_src.extendedDynamicState3LineStippleEnable;
+    extendedDynamicState3DepthClipNegativeOneToOne = copy_src.extendedDynamicState3DepthClipNegativeOneToOne;
+    extendedDynamicState3ViewportWScalingEnable = copy_src.extendedDynamicState3ViewportWScalingEnable;
+    extendedDynamicState3ViewportSwizzle = copy_src.extendedDynamicState3ViewportSwizzle;
+    extendedDynamicState3CoverageToColorEnable = copy_src.extendedDynamicState3CoverageToColorEnable;
+    extendedDynamicState3CoverageToColorLocation = copy_src.extendedDynamicState3CoverageToColorLocation;
+    extendedDynamicState3CoverageModulationMode = copy_src.extendedDynamicState3CoverageModulationMode;
+    extendedDynamicState3CoverageModulationTableEnable = copy_src.extendedDynamicState3CoverageModulationTableEnable;
+    extendedDynamicState3CoverageModulationTable = copy_src.extendedDynamicState3CoverageModulationTable;
+    extendedDynamicState3CoverageReductionMode = copy_src.extendedDynamicState3CoverageReductionMode;
+    extendedDynamicState3RepresentativeFragmentTestEnable = copy_src.extendedDynamicState3RepresentativeFragmentTestEnable;
+    extendedDynamicState3ShadingRateImageEnable = copy_src.extendedDynamicState3ShadingRateImageEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT& safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    extendedDynamicState3TessellationDomainOrigin = copy_src.extendedDynamicState3TessellationDomainOrigin;
+    extendedDynamicState3DepthClampEnable = copy_src.extendedDynamicState3DepthClampEnable;
+    extendedDynamicState3PolygonMode = copy_src.extendedDynamicState3PolygonMode;
+    extendedDynamicState3RasterizationSamples = copy_src.extendedDynamicState3RasterizationSamples;
+    extendedDynamicState3SampleMask = copy_src.extendedDynamicState3SampleMask;
+    extendedDynamicState3AlphaToCoverageEnable = copy_src.extendedDynamicState3AlphaToCoverageEnable;
+    extendedDynamicState3AlphaToOneEnable = copy_src.extendedDynamicState3AlphaToOneEnable;
+    extendedDynamicState3LogicOpEnable = copy_src.extendedDynamicState3LogicOpEnable;
+    extendedDynamicState3ColorBlendEnable = copy_src.extendedDynamicState3ColorBlendEnable;
+    extendedDynamicState3ColorBlendEquation = copy_src.extendedDynamicState3ColorBlendEquation;
+    extendedDynamicState3ColorWriteMask = copy_src.extendedDynamicState3ColorWriteMask;
+    extendedDynamicState3RasterizationStream = copy_src.extendedDynamicState3RasterizationStream;
+    extendedDynamicState3ConservativeRasterizationMode = copy_src.extendedDynamicState3ConservativeRasterizationMode;
+    extendedDynamicState3ExtraPrimitiveOverestimationSize = copy_src.extendedDynamicState3ExtraPrimitiveOverestimationSize;
+    extendedDynamicState3DepthClipEnable = copy_src.extendedDynamicState3DepthClipEnable;
+    extendedDynamicState3SampleLocationsEnable = copy_src.extendedDynamicState3SampleLocationsEnable;
+    extendedDynamicState3ColorBlendAdvanced = copy_src.extendedDynamicState3ColorBlendAdvanced;
+    extendedDynamicState3ProvokingVertexMode = copy_src.extendedDynamicState3ProvokingVertexMode;
+    extendedDynamicState3LineRasterizationMode = copy_src.extendedDynamicState3LineRasterizationMode;
+    extendedDynamicState3LineStippleEnable = copy_src.extendedDynamicState3LineStippleEnable;
+    extendedDynamicState3DepthClipNegativeOneToOne = copy_src.extendedDynamicState3DepthClipNegativeOneToOne;
+    extendedDynamicState3ViewportWScalingEnable = copy_src.extendedDynamicState3ViewportWScalingEnable;
+    extendedDynamicState3ViewportSwizzle = copy_src.extendedDynamicState3ViewportSwizzle;
+    extendedDynamicState3CoverageToColorEnable = copy_src.extendedDynamicState3CoverageToColorEnable;
+    extendedDynamicState3CoverageToColorLocation = copy_src.extendedDynamicState3CoverageToColorLocation;
+    extendedDynamicState3CoverageModulationMode = copy_src.extendedDynamicState3CoverageModulationMode;
+    extendedDynamicState3CoverageModulationTableEnable = copy_src.extendedDynamicState3CoverageModulationTableEnable;
+    extendedDynamicState3CoverageModulationTable = copy_src.extendedDynamicState3CoverageModulationTable;
+    extendedDynamicState3CoverageReductionMode = copy_src.extendedDynamicState3CoverageReductionMode;
+    extendedDynamicState3RepresentativeFragmentTestEnable = copy_src.extendedDynamicState3RepresentativeFragmentTestEnable;
+    extendedDynamicState3ShadingRateImageEnable = copy_src.extendedDynamicState3ShadingRateImageEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::~safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::initialize(
+    const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    extendedDynamicState3TessellationDomainOrigin = in_struct->extendedDynamicState3TessellationDomainOrigin;
+    extendedDynamicState3DepthClampEnable = in_struct->extendedDynamicState3DepthClampEnable;
+    extendedDynamicState3PolygonMode = in_struct->extendedDynamicState3PolygonMode;
+    extendedDynamicState3RasterizationSamples = in_struct->extendedDynamicState3RasterizationSamples;
+    extendedDynamicState3SampleMask = in_struct->extendedDynamicState3SampleMask;
+    extendedDynamicState3AlphaToCoverageEnable = in_struct->extendedDynamicState3AlphaToCoverageEnable;
+    extendedDynamicState3AlphaToOneEnable = in_struct->extendedDynamicState3AlphaToOneEnable;
+    extendedDynamicState3LogicOpEnable = in_struct->extendedDynamicState3LogicOpEnable;
+    extendedDynamicState3ColorBlendEnable = in_struct->extendedDynamicState3ColorBlendEnable;
+    extendedDynamicState3ColorBlendEquation = in_struct->extendedDynamicState3ColorBlendEquation;
+    extendedDynamicState3ColorWriteMask = in_struct->extendedDynamicState3ColorWriteMask;
+    extendedDynamicState3RasterizationStream = in_struct->extendedDynamicState3RasterizationStream;
+    extendedDynamicState3ConservativeRasterizationMode = in_struct->extendedDynamicState3ConservativeRasterizationMode;
+    extendedDynamicState3ExtraPrimitiveOverestimationSize = in_struct->extendedDynamicState3ExtraPrimitiveOverestimationSize;
+    extendedDynamicState3DepthClipEnable = in_struct->extendedDynamicState3DepthClipEnable;
+    extendedDynamicState3SampleLocationsEnable = in_struct->extendedDynamicState3SampleLocationsEnable;
+    extendedDynamicState3ColorBlendAdvanced = in_struct->extendedDynamicState3ColorBlendAdvanced;
+    extendedDynamicState3ProvokingVertexMode = in_struct->extendedDynamicState3ProvokingVertexMode;
+    extendedDynamicState3LineRasterizationMode = in_struct->extendedDynamicState3LineRasterizationMode;
+    extendedDynamicState3LineStippleEnable = in_struct->extendedDynamicState3LineStippleEnable;
+    extendedDynamicState3DepthClipNegativeOneToOne = in_struct->extendedDynamicState3DepthClipNegativeOneToOne;
+    extendedDynamicState3ViewportWScalingEnable = in_struct->extendedDynamicState3ViewportWScalingEnable;
+    extendedDynamicState3ViewportSwizzle = in_struct->extendedDynamicState3ViewportSwizzle;
+    extendedDynamicState3CoverageToColorEnable = in_struct->extendedDynamicState3CoverageToColorEnable;
+    extendedDynamicState3CoverageToColorLocation = in_struct->extendedDynamicState3CoverageToColorLocation;
+    extendedDynamicState3CoverageModulationMode = in_struct->extendedDynamicState3CoverageModulationMode;
+    extendedDynamicState3CoverageModulationTableEnable = in_struct->extendedDynamicState3CoverageModulationTableEnable;
+    extendedDynamicState3CoverageModulationTable = in_struct->extendedDynamicState3CoverageModulationTable;
+    extendedDynamicState3CoverageReductionMode = in_struct->extendedDynamicState3CoverageReductionMode;
+    extendedDynamicState3RepresentativeFragmentTestEnable = in_struct->extendedDynamicState3RepresentativeFragmentTestEnable;
+    extendedDynamicState3ShadingRateImageEnable = in_struct->extendedDynamicState3ShadingRateImageEnable;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    extendedDynamicState3TessellationDomainOrigin = copy_src->extendedDynamicState3TessellationDomainOrigin;
+    extendedDynamicState3DepthClampEnable = copy_src->extendedDynamicState3DepthClampEnable;
+    extendedDynamicState3PolygonMode = copy_src->extendedDynamicState3PolygonMode;
+    extendedDynamicState3RasterizationSamples = copy_src->extendedDynamicState3RasterizationSamples;
+    extendedDynamicState3SampleMask = copy_src->extendedDynamicState3SampleMask;
+    extendedDynamicState3AlphaToCoverageEnable = copy_src->extendedDynamicState3AlphaToCoverageEnable;
+    extendedDynamicState3AlphaToOneEnable = copy_src->extendedDynamicState3AlphaToOneEnable;
+    extendedDynamicState3LogicOpEnable = copy_src->extendedDynamicState3LogicOpEnable;
+    extendedDynamicState3ColorBlendEnable = copy_src->extendedDynamicState3ColorBlendEnable;
+    extendedDynamicState3ColorBlendEquation = copy_src->extendedDynamicState3ColorBlendEquation;
+    extendedDynamicState3ColorWriteMask = copy_src->extendedDynamicState3ColorWriteMask;
+    extendedDynamicState3RasterizationStream = copy_src->extendedDynamicState3RasterizationStream;
+    extendedDynamicState3ConservativeRasterizationMode = copy_src->extendedDynamicState3ConservativeRasterizationMode;
+    extendedDynamicState3ExtraPrimitiveOverestimationSize = copy_src->extendedDynamicState3ExtraPrimitiveOverestimationSize;
+    extendedDynamicState3DepthClipEnable = copy_src->extendedDynamicState3DepthClipEnable;
+    extendedDynamicState3SampleLocationsEnable = copy_src->extendedDynamicState3SampleLocationsEnable;
+    extendedDynamicState3ColorBlendAdvanced = copy_src->extendedDynamicState3ColorBlendAdvanced;
+    extendedDynamicState3ProvokingVertexMode = copy_src->extendedDynamicState3ProvokingVertexMode;
+    extendedDynamicState3LineRasterizationMode = copy_src->extendedDynamicState3LineRasterizationMode;
+    extendedDynamicState3LineStippleEnable = copy_src->extendedDynamicState3LineStippleEnable;
+    extendedDynamicState3DepthClipNegativeOneToOne = copy_src->extendedDynamicState3DepthClipNegativeOneToOne;
+    extendedDynamicState3ViewportWScalingEnable = copy_src->extendedDynamicState3ViewportWScalingEnable;
+    extendedDynamicState3ViewportSwizzle = copy_src->extendedDynamicState3ViewportSwizzle;
+    extendedDynamicState3CoverageToColorEnable = copy_src->extendedDynamicState3CoverageToColorEnable;
+    extendedDynamicState3CoverageToColorLocation = copy_src->extendedDynamicState3CoverageToColorLocation;
+    extendedDynamicState3CoverageModulationMode = copy_src->extendedDynamicState3CoverageModulationMode;
+    extendedDynamicState3CoverageModulationTableEnable = copy_src->extendedDynamicState3CoverageModulationTableEnable;
+    extendedDynamicState3CoverageModulationTable = copy_src->extendedDynamicState3CoverageModulationTable;
+    extendedDynamicState3CoverageReductionMode = copy_src->extendedDynamicState3CoverageReductionMode;
+    extendedDynamicState3RepresentativeFragmentTestEnable = copy_src->extendedDynamicState3RepresentativeFragmentTestEnable;
+    extendedDynamicState3ShadingRateImageEnable = copy_src->extendedDynamicState3ShadingRateImageEnable;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT::safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
+    const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), dynamicPrimitiveTopologyUnrestricted(in_struct->dynamicPrimitiveTopologyUnrestricted) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT::safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT),
+      pNext(nullptr),
+      dynamicPrimitiveTopologyUnrestricted() {}
+
+safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT::safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
+    const safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    dynamicPrimitiveTopologyUnrestricted = copy_src.dynamicPrimitiveTopologyUnrestricted;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT& safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT::operator=(
+    const safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    dynamicPrimitiveTopologyUnrestricted = copy_src.dynamicPrimitiveTopologyUnrestricted;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT::~safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT::initialize(
+    const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    dynamicPrimitiveTopologyUnrestricted = in_struct->dynamicPrimitiveTopologyUnrestricted;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT::initialize(
+    const safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    dynamicPrimitiveTopologyUnrestricted = copy_src->dynamicPrimitiveTopologyUnrestricted;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT::safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
+    const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), subpassMergeFeedback(in_struct->subpassMergeFeedback) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT::safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT), pNext(nullptr), subpassMergeFeedback() {}
+
+safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT::safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
+    const safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    subpassMergeFeedback = copy_src.subpassMergeFeedback;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT& safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    subpassMergeFeedback = copy_src.subpassMergeFeedback;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT::~safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT::initialize(
+    const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    subpassMergeFeedback = in_struct->subpassMergeFeedback;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    subpassMergeFeedback = copy_src->subpassMergeFeedback;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkRenderPassCreationControlEXT::safe_VkRenderPassCreationControlEXT(const VkRenderPassCreationControlEXT* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType), disallowMerging(in_struct->disallowMerging) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkRenderPassCreationControlEXT::safe_VkRenderPassCreationControlEXT()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT), pNext(nullptr), disallowMerging() {}
+
+safe_VkRenderPassCreationControlEXT::safe_VkRenderPassCreationControlEXT(const safe_VkRenderPassCreationControlEXT& copy_src) {
+    sType = copy_src.sType;
+    disallowMerging = copy_src.disallowMerging;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkRenderPassCreationControlEXT& safe_VkRenderPassCreationControlEXT::operator=(
+    const safe_VkRenderPassCreationControlEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    disallowMerging = copy_src.disallowMerging;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkRenderPassCreationControlEXT::~safe_VkRenderPassCreationControlEXT() { FreePnextChain(pNext); }
+
+void safe_VkRenderPassCreationControlEXT::initialize(const VkRenderPassCreationControlEXT* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    disallowMerging = in_struct->disallowMerging;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkRenderPassCreationControlEXT::initialize(const safe_VkRenderPassCreationControlEXT* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    disallowMerging = copy_src->disallowMerging;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkRenderPassCreationFeedbackCreateInfoEXT::safe_VkRenderPassCreationFeedbackCreateInfoEXT(
+    const VkRenderPassCreationFeedbackCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), pRenderPassFeedback(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pRenderPassFeedback) {
+        pRenderPassFeedback = new VkRenderPassCreationFeedbackInfoEXT(*in_struct->pRenderPassFeedback);
+    }
+}
+
+safe_VkRenderPassCreationFeedbackCreateInfoEXT::safe_VkRenderPassCreationFeedbackCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT), pNext(nullptr), pRenderPassFeedback(nullptr) {}
+
+safe_VkRenderPassCreationFeedbackCreateInfoEXT::safe_VkRenderPassCreationFeedbackCreateInfoEXT(
+    const safe_VkRenderPassCreationFeedbackCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    pRenderPassFeedback = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pRenderPassFeedback) {
+        pRenderPassFeedback = new VkRenderPassCreationFeedbackInfoEXT(*copy_src.pRenderPassFeedback);
+    }
+}
+
+safe_VkRenderPassCreationFeedbackCreateInfoEXT& safe_VkRenderPassCreationFeedbackCreateInfoEXT::operator=(
+    const safe_VkRenderPassCreationFeedbackCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pRenderPassFeedback) delete pRenderPassFeedback;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pRenderPassFeedback = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pRenderPassFeedback) {
+        pRenderPassFeedback = new VkRenderPassCreationFeedbackInfoEXT(*copy_src.pRenderPassFeedback);
+    }
+
+    return *this;
+}
+
+safe_VkRenderPassCreationFeedbackCreateInfoEXT::~safe_VkRenderPassCreationFeedbackCreateInfoEXT() {
+    if (pRenderPassFeedback) delete pRenderPassFeedback;
+    FreePnextChain(pNext);
+}
+
+void safe_VkRenderPassCreationFeedbackCreateInfoEXT::initialize(const VkRenderPassCreationFeedbackCreateInfoEXT* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pRenderPassFeedback) delete pRenderPassFeedback;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pRenderPassFeedback = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pRenderPassFeedback) {
+        pRenderPassFeedback = new VkRenderPassCreationFeedbackInfoEXT(*in_struct->pRenderPassFeedback);
+    }
+}
+
+void safe_VkRenderPassCreationFeedbackCreateInfoEXT::initialize(const safe_VkRenderPassCreationFeedbackCreateInfoEXT* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pRenderPassFeedback = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pRenderPassFeedback) {
+        pRenderPassFeedback = new VkRenderPassCreationFeedbackInfoEXT(*copy_src->pRenderPassFeedback);
+    }
+}
+
+safe_VkRenderPassSubpassFeedbackCreateInfoEXT::safe_VkRenderPassSubpassFeedbackCreateInfoEXT(
+    const VkRenderPassSubpassFeedbackCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), pSubpassFeedback(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pSubpassFeedback) {
+        pSubpassFeedback = new VkRenderPassSubpassFeedbackInfoEXT(*in_struct->pSubpassFeedback);
+    }
+}
+
+safe_VkRenderPassSubpassFeedbackCreateInfoEXT::safe_VkRenderPassSubpassFeedbackCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT), pNext(nullptr), pSubpassFeedback(nullptr) {}
+
+safe_VkRenderPassSubpassFeedbackCreateInfoEXT::safe_VkRenderPassSubpassFeedbackCreateInfoEXT(
+    const safe_VkRenderPassSubpassFeedbackCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    pSubpassFeedback = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pSubpassFeedback) {
+        pSubpassFeedback = new VkRenderPassSubpassFeedbackInfoEXT(*copy_src.pSubpassFeedback);
+    }
+}
+
+safe_VkRenderPassSubpassFeedbackCreateInfoEXT& safe_VkRenderPassSubpassFeedbackCreateInfoEXT::operator=(
+    const safe_VkRenderPassSubpassFeedbackCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pSubpassFeedback) delete pSubpassFeedback;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pSubpassFeedback = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pSubpassFeedback) {
+        pSubpassFeedback = new VkRenderPassSubpassFeedbackInfoEXT(*copy_src.pSubpassFeedback);
+    }
+
+    return *this;
+}
+
+safe_VkRenderPassSubpassFeedbackCreateInfoEXT::~safe_VkRenderPassSubpassFeedbackCreateInfoEXT() {
+    if (pSubpassFeedback) delete pSubpassFeedback;
+    FreePnextChain(pNext);
+}
+
+void safe_VkRenderPassSubpassFeedbackCreateInfoEXT::initialize(const VkRenderPassSubpassFeedbackCreateInfoEXT* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pSubpassFeedback) delete pSubpassFeedback;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pSubpassFeedback = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pSubpassFeedback) {
+        pSubpassFeedback = new VkRenderPassSubpassFeedbackInfoEXT(*in_struct->pSubpassFeedback);
+    }
+}
+
+void safe_VkRenderPassSubpassFeedbackCreateInfoEXT::initialize(const safe_VkRenderPassSubpassFeedbackCreateInfoEXT* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pSubpassFeedback = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pSubpassFeedback) {
+        pSubpassFeedback = new VkRenderPassSubpassFeedbackInfoEXT(*copy_src->pSubpassFeedback);
+    }
+}
+
+safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT::safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
+    const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), shaderModuleIdentifier(in_struct->shaderModuleIdentifier) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT::safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT), pNext(nullptr), shaderModuleIdentifier() {}
+
+safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT::safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
+    const safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    shaderModuleIdentifier = copy_src.shaderModuleIdentifier;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT& safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderModuleIdentifier = copy_src.shaderModuleIdentifier;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT::~safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT::initialize(
+    const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderModuleIdentifier = in_struct->shaderModuleIdentifier;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderModuleIdentifier = copy_src->shaderModuleIdentifier;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT::safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
+    const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        shaderModuleIdentifierAlgorithmUUID[i] = in_struct->shaderModuleIdentifierAlgorithmUUID[i];
+    }
+}
+
+safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT::safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT), pNext(nullptr) {}
+
+safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT::safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
+    const safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        shaderModuleIdentifierAlgorithmUUID[i] = copy_src.shaderModuleIdentifierAlgorithmUUID[i];
+    }
+}
+
+safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT& safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT::operator=(
+    const safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        shaderModuleIdentifierAlgorithmUUID[i] = copy_src.shaderModuleIdentifierAlgorithmUUID[i];
+    }
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT::~safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT::initialize(
+    const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        shaderModuleIdentifierAlgorithmUUID[i] = in_struct->shaderModuleIdentifierAlgorithmUUID[i];
+    }
+}
+
+void safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT::initialize(
+    const safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        shaderModuleIdentifierAlgorithmUUID[i] = copy_src->shaderModuleIdentifierAlgorithmUUID[i];
+    }
+}
+
+safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT::safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
+    const VkPipelineShaderStageModuleIdentifierCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), identifierSize(in_struct->identifierSize), pIdentifier(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pIdentifier) {
+        pIdentifier = new uint8_t[in_struct->identifierSize];
+        memcpy((void*)pIdentifier, (void*)in_struct->pIdentifier, sizeof(uint8_t) * in_struct->identifierSize);
+    }
+}
+
+safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT::safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT),
+      pNext(nullptr),
+      identifierSize(),
+      pIdentifier(nullptr) {}
+
+safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT::safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
+    const safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    identifierSize = copy_src.identifierSize;
+    pIdentifier = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pIdentifier) {
+        pIdentifier = new uint8_t[copy_src.identifierSize];
+        memcpy((void*)pIdentifier, (void*)copy_src.pIdentifier, sizeof(uint8_t) * copy_src.identifierSize);
+    }
+}
+
+safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT& safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT::operator=(
+    const safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pIdentifier) delete[] pIdentifier;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    identifierSize = copy_src.identifierSize;
+    pIdentifier = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pIdentifier) {
+        pIdentifier = new uint8_t[copy_src.identifierSize];
+        memcpy((void*)pIdentifier, (void*)copy_src.pIdentifier, sizeof(uint8_t) * copy_src.identifierSize);
+    }
+
+    return *this;
+}
+
+safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT::~safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT() {
+    if (pIdentifier) delete[] pIdentifier;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT::initialize(
+    const VkPipelineShaderStageModuleIdentifierCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pIdentifier) delete[] pIdentifier;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    identifierSize = in_struct->identifierSize;
+    pIdentifier = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pIdentifier) {
+        pIdentifier = new uint8_t[in_struct->identifierSize];
+        memcpy((void*)pIdentifier, (void*)in_struct->pIdentifier, sizeof(uint8_t) * in_struct->identifierSize);
+    }
+}
+
+void safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT::initialize(
+    const safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    identifierSize = copy_src->identifierSize;
+    pIdentifier = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pIdentifier) {
+        pIdentifier = new uint8_t[copy_src->identifierSize];
+        memcpy((void*)pIdentifier, (void*)copy_src->pIdentifier, sizeof(uint8_t) * copy_src->identifierSize);
+    }
+}
+
+safe_VkShaderModuleIdentifierEXT::safe_VkShaderModuleIdentifierEXT(const VkShaderModuleIdentifierEXT* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), identifierSize(in_struct->identifierSize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    for (uint32_t i = 0; i < VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT; ++i) {
+        identifier[i] = in_struct->identifier[i];
+    }
+}
+
+safe_VkShaderModuleIdentifierEXT::safe_VkShaderModuleIdentifierEXT()
+    : sType(VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT), pNext(nullptr), identifierSize() {}
+
+safe_VkShaderModuleIdentifierEXT::safe_VkShaderModuleIdentifierEXT(const safe_VkShaderModuleIdentifierEXT& copy_src) {
+    sType = copy_src.sType;
+    identifierSize = copy_src.identifierSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT; ++i) {
+        identifier[i] = copy_src.identifier[i];
+    }
+}
+
+safe_VkShaderModuleIdentifierEXT& safe_VkShaderModuleIdentifierEXT::operator=(const safe_VkShaderModuleIdentifierEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    identifierSize = copy_src.identifierSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT; ++i) {
+        identifier[i] = copy_src.identifier[i];
+    }
+
+    return *this;
+}
+
+safe_VkShaderModuleIdentifierEXT::~safe_VkShaderModuleIdentifierEXT() { FreePnextChain(pNext); }
+
+void safe_VkShaderModuleIdentifierEXT::initialize(const VkShaderModuleIdentifierEXT* in_struct,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    identifierSize = in_struct->identifierSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    for (uint32_t i = 0; i < VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT; ++i) {
+        identifier[i] = in_struct->identifier[i];
+    }
+}
+
+void safe_VkShaderModuleIdentifierEXT::initialize(const safe_VkShaderModuleIdentifierEXT* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    identifierSize = copy_src->identifierSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT; ++i) {
+        identifier[i] = copy_src->identifier[i];
+    }
+}
+
+safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT::safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
+    const VkPhysicalDeviceLegacyDitheringFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), legacyDithering(in_struct->legacyDithering) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT::safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT), pNext(nullptr), legacyDithering() {}
+
+safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT::safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
+    const safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    legacyDithering = copy_src.legacyDithering;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT& safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    legacyDithering = copy_src.legacyDithering;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT::~safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT::initialize(const VkPhysicalDeviceLegacyDitheringFeaturesEXT* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    legacyDithering = in_struct->legacyDithering;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT::initialize(const safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    legacyDithering = copy_src->legacyDithering;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT::safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
+    const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), pipelineProtectedAccess(in_struct->pipelineProtectedAccess) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT::safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT), pNext(nullptr), pipelineProtectedAccess() {}
+
+safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT::safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
+    const safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    pipelineProtectedAccess = copy_src.pipelineProtectedAccess;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT& safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT::operator=(
+    const safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pipelineProtectedAccess = copy_src.pipelineProtectedAccess;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT::~safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT::initialize(
+    const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pipelineProtectedAccess = in_struct->pipelineProtectedAccess;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT::initialize(
+    const safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pipelineProtectedAccess = copy_src->pipelineProtectedAccess;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceShaderObjectFeaturesEXT::safe_VkPhysicalDeviceShaderObjectFeaturesEXT(
+    const VkPhysicalDeviceShaderObjectFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), shaderObject(in_struct->shaderObject) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderObjectFeaturesEXT::safe_VkPhysicalDeviceShaderObjectFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT), pNext(nullptr), shaderObject() {}
+
+safe_VkPhysicalDeviceShaderObjectFeaturesEXT::safe_VkPhysicalDeviceShaderObjectFeaturesEXT(
+    const safe_VkPhysicalDeviceShaderObjectFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    shaderObject = copy_src.shaderObject;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderObjectFeaturesEXT& safe_VkPhysicalDeviceShaderObjectFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceShaderObjectFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderObject = copy_src.shaderObject;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderObjectFeaturesEXT::~safe_VkPhysicalDeviceShaderObjectFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceShaderObjectFeaturesEXT::initialize(const VkPhysicalDeviceShaderObjectFeaturesEXT* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderObject = in_struct->shaderObject;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderObjectFeaturesEXT::initialize(const safe_VkPhysicalDeviceShaderObjectFeaturesEXT* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderObject = copy_src->shaderObject;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceShaderObjectPropertiesEXT::safe_VkPhysicalDeviceShaderObjectPropertiesEXT(
+    const VkPhysicalDeviceShaderObjectPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), shaderBinaryVersion(in_struct->shaderBinaryVersion) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        shaderBinaryUUID[i] = in_struct->shaderBinaryUUID[i];
+    }
+}
+
+safe_VkPhysicalDeviceShaderObjectPropertiesEXT::safe_VkPhysicalDeviceShaderObjectPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT), pNext(nullptr), shaderBinaryVersion() {}
+
+safe_VkPhysicalDeviceShaderObjectPropertiesEXT::safe_VkPhysicalDeviceShaderObjectPropertiesEXT(
+    const safe_VkPhysicalDeviceShaderObjectPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    shaderBinaryVersion = copy_src.shaderBinaryVersion;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        shaderBinaryUUID[i] = copy_src.shaderBinaryUUID[i];
+    }
+}
+
+safe_VkPhysicalDeviceShaderObjectPropertiesEXT& safe_VkPhysicalDeviceShaderObjectPropertiesEXT::operator=(
+    const safe_VkPhysicalDeviceShaderObjectPropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderBinaryVersion = copy_src.shaderBinaryVersion;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        shaderBinaryUUID[i] = copy_src.shaderBinaryUUID[i];
+    }
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderObjectPropertiesEXT::~safe_VkPhysicalDeviceShaderObjectPropertiesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceShaderObjectPropertiesEXT::initialize(const VkPhysicalDeviceShaderObjectPropertiesEXT* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderBinaryVersion = in_struct->shaderBinaryVersion;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        shaderBinaryUUID[i] = in_struct->shaderBinaryUUID[i];
+    }
+}
+
+void safe_VkPhysicalDeviceShaderObjectPropertiesEXT::initialize(const safe_VkPhysicalDeviceShaderObjectPropertiesEXT* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderBinaryVersion = copy_src->shaderBinaryVersion;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        shaderBinaryUUID[i] = copy_src->shaderBinaryUUID[i];
+    }
+}
+
+safe_VkShaderCreateInfoEXT::safe_VkShaderCreateInfoEXT(const VkShaderCreateInfoEXT* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      stage(in_struct->stage),
+      nextStage(in_struct->nextStage),
+      codeType(in_struct->codeType),
+      codeSize(in_struct->codeSize),
+      pCode(in_struct->pCode),
+      setLayoutCount(in_struct->setLayoutCount),
+      pSetLayouts(nullptr),
+      pushConstantRangeCount(in_struct->pushConstantRangeCount),
+      pPushConstantRanges(nullptr),
+      pSpecializationInfo(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    pName = SafeStringCopy(in_struct->pName);
+    if (setLayoutCount && in_struct->pSetLayouts) {
+        pSetLayouts = new VkDescriptorSetLayout[setLayoutCount];
+        for (uint32_t i = 0; i < setLayoutCount; ++i) {
+            pSetLayouts[i] = in_struct->pSetLayouts[i];
+        }
+    }
+
+    if (in_struct->pPushConstantRanges) {
+        pPushConstantRanges = new VkPushConstantRange[in_struct->pushConstantRangeCount];
+        memcpy((void*)pPushConstantRanges, (void*)in_struct->pPushConstantRanges,
+               sizeof(VkPushConstantRange) * in_struct->pushConstantRangeCount);
+    }
+    if (in_struct->pSpecializationInfo) pSpecializationInfo = new safe_VkSpecializationInfo(in_struct->pSpecializationInfo);
+}
+
+safe_VkShaderCreateInfoEXT::safe_VkShaderCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT),
+      pNext(nullptr),
+      flags(),
+      stage(),
+      nextStage(),
+      codeType(),
+      codeSize(),
+      pCode(nullptr),
+      pName(nullptr),
+      setLayoutCount(),
+      pSetLayouts(nullptr),
+      pushConstantRangeCount(),
+      pPushConstantRanges(nullptr),
+      pSpecializationInfo(nullptr) {}
+
+safe_VkShaderCreateInfoEXT::safe_VkShaderCreateInfoEXT(const safe_VkShaderCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    stage = copy_src.stage;
+    nextStage = copy_src.nextStage;
+    codeType = copy_src.codeType;
+    codeSize = copy_src.codeSize;
+    pCode = copy_src.pCode;
+    setLayoutCount = copy_src.setLayoutCount;
+    pSetLayouts = nullptr;
+    pushConstantRangeCount = copy_src.pushConstantRangeCount;
+    pPushConstantRanges = nullptr;
+    pSpecializationInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    pName = SafeStringCopy(copy_src.pName);
+    if (setLayoutCount && copy_src.pSetLayouts) {
+        pSetLayouts = new VkDescriptorSetLayout[setLayoutCount];
+        for (uint32_t i = 0; i < setLayoutCount; ++i) {
+            pSetLayouts[i] = copy_src.pSetLayouts[i];
+        }
+    }
+
+    if (copy_src.pPushConstantRanges) {
+        pPushConstantRanges = new VkPushConstantRange[copy_src.pushConstantRangeCount];
+        memcpy((void*)pPushConstantRanges, (void*)copy_src.pPushConstantRanges,
+               sizeof(VkPushConstantRange) * copy_src.pushConstantRangeCount);
+    }
+    if (copy_src.pSpecializationInfo) pSpecializationInfo = new safe_VkSpecializationInfo(*copy_src.pSpecializationInfo);
+}
+
+safe_VkShaderCreateInfoEXT& safe_VkShaderCreateInfoEXT::operator=(const safe_VkShaderCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pName) delete[] pName;
+    if (pSetLayouts) delete[] pSetLayouts;
+    if (pPushConstantRanges) delete[] pPushConstantRanges;
+    if (pSpecializationInfo) delete pSpecializationInfo;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    stage = copy_src.stage;
+    nextStage = copy_src.nextStage;
+    codeType = copy_src.codeType;
+    codeSize = copy_src.codeSize;
+    pCode = copy_src.pCode;
+    setLayoutCount = copy_src.setLayoutCount;
+    pSetLayouts = nullptr;
+    pushConstantRangeCount = copy_src.pushConstantRangeCount;
+    pPushConstantRanges = nullptr;
+    pSpecializationInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    pName = SafeStringCopy(copy_src.pName);
+    if (setLayoutCount && copy_src.pSetLayouts) {
+        pSetLayouts = new VkDescriptorSetLayout[setLayoutCount];
+        for (uint32_t i = 0; i < setLayoutCount; ++i) {
+            pSetLayouts[i] = copy_src.pSetLayouts[i];
+        }
+    }
+
+    if (copy_src.pPushConstantRanges) {
+        pPushConstantRanges = new VkPushConstantRange[copy_src.pushConstantRangeCount];
+        memcpy((void*)pPushConstantRanges, (void*)copy_src.pPushConstantRanges,
+               sizeof(VkPushConstantRange) * copy_src.pushConstantRangeCount);
+    }
+    if (copy_src.pSpecializationInfo) pSpecializationInfo = new safe_VkSpecializationInfo(*copy_src.pSpecializationInfo);
+
+    return *this;
+}
+
+safe_VkShaderCreateInfoEXT::~safe_VkShaderCreateInfoEXT() {
+    if (pName) delete[] pName;
+    if (pSetLayouts) delete[] pSetLayouts;
+    if (pPushConstantRanges) delete[] pPushConstantRanges;
+    if (pSpecializationInfo) delete pSpecializationInfo;
+    FreePnextChain(pNext);
+}
+
+void safe_VkShaderCreateInfoEXT::initialize(const VkShaderCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pName) delete[] pName;
+    if (pSetLayouts) delete[] pSetLayouts;
+    if (pPushConstantRanges) delete[] pPushConstantRanges;
+    if (pSpecializationInfo) delete pSpecializationInfo;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    stage = in_struct->stage;
+    nextStage = in_struct->nextStage;
+    codeType = in_struct->codeType;
+    codeSize = in_struct->codeSize;
+    pCode = in_struct->pCode;
+    setLayoutCount = in_struct->setLayoutCount;
+    pSetLayouts = nullptr;
+    pushConstantRangeCount = in_struct->pushConstantRangeCount;
+    pPushConstantRanges = nullptr;
+    pSpecializationInfo = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    pName = SafeStringCopy(in_struct->pName);
+    if (setLayoutCount && in_struct->pSetLayouts) {
+        pSetLayouts = new VkDescriptorSetLayout[setLayoutCount];
+        for (uint32_t i = 0; i < setLayoutCount; ++i) {
+            pSetLayouts[i] = in_struct->pSetLayouts[i];
+        }
+    }
+
+    if (in_struct->pPushConstantRanges) {
+        pPushConstantRanges = new VkPushConstantRange[in_struct->pushConstantRangeCount];
+        memcpy((void*)pPushConstantRanges, (void*)in_struct->pPushConstantRanges,
+               sizeof(VkPushConstantRange) * in_struct->pushConstantRangeCount);
+    }
+    if (in_struct->pSpecializationInfo) pSpecializationInfo = new safe_VkSpecializationInfo(in_struct->pSpecializationInfo);
+}
+
+void safe_VkShaderCreateInfoEXT::initialize(const safe_VkShaderCreateInfoEXT* copy_src,
+                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    stage = copy_src->stage;
+    nextStage = copy_src->nextStage;
+    codeType = copy_src->codeType;
+    codeSize = copy_src->codeSize;
+    pCode = copy_src->pCode;
+    setLayoutCount = copy_src->setLayoutCount;
+    pSetLayouts = nullptr;
+    pushConstantRangeCount = copy_src->pushConstantRangeCount;
+    pPushConstantRanges = nullptr;
+    pSpecializationInfo = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    pName = SafeStringCopy(copy_src->pName);
+    if (setLayoutCount && copy_src->pSetLayouts) {
+        pSetLayouts = new VkDescriptorSetLayout[setLayoutCount];
+        for (uint32_t i = 0; i < setLayoutCount; ++i) {
+            pSetLayouts[i] = copy_src->pSetLayouts[i];
+        }
+    }
+
+    if (copy_src->pPushConstantRanges) {
+        pPushConstantRanges = new VkPushConstantRange[copy_src->pushConstantRangeCount];
+        memcpy((void*)pPushConstantRanges, (void*)copy_src->pPushConstantRanges,
+               sizeof(VkPushConstantRange) * copy_src->pushConstantRangeCount);
+    }
+    if (copy_src->pSpecializationInfo) pSpecializationInfo = new safe_VkSpecializationInfo(*copy_src->pSpecializationInfo);
+}
+
+safe_VkLayerSettingEXT::safe_VkLayerSettingEXT(const VkLayerSettingEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state)
+    : type(in_struct->type), valueCount(in_struct->valueCount), pValues(in_struct->pValues) {
+    pLayerName = SafeStringCopy(in_struct->pLayerName);
+    pSettingName = SafeStringCopy(in_struct->pSettingName);
+}
+
+safe_VkLayerSettingEXT::safe_VkLayerSettingEXT()
+    : pLayerName(nullptr), pSettingName(nullptr), type(), valueCount(), pValues(nullptr) {}
+
+safe_VkLayerSettingEXT::safe_VkLayerSettingEXT(const safe_VkLayerSettingEXT& copy_src) {
+    type = copy_src.type;
+    valueCount = copy_src.valueCount;
+    pValues = copy_src.pValues;
+    pLayerName = SafeStringCopy(copy_src.pLayerName);
+    pSettingName = SafeStringCopy(copy_src.pSettingName);
+}
+
+safe_VkLayerSettingEXT& safe_VkLayerSettingEXT::operator=(const safe_VkLayerSettingEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pLayerName) delete[] pLayerName;
+    if (pSettingName) delete[] pSettingName;
+
+    type = copy_src.type;
+    valueCount = copy_src.valueCount;
+    pValues = copy_src.pValues;
+    pLayerName = SafeStringCopy(copy_src.pLayerName);
+    pSettingName = SafeStringCopy(copy_src.pSettingName);
+
+    return *this;
+}
+
+safe_VkLayerSettingEXT::~safe_VkLayerSettingEXT() {
+    if (pLayerName) delete[] pLayerName;
+    if (pSettingName) delete[] pSettingName;
+}
+
+void safe_VkLayerSettingEXT::initialize(const VkLayerSettingEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pLayerName) delete[] pLayerName;
+    if (pSettingName) delete[] pSettingName;
+    type = in_struct->type;
+    valueCount = in_struct->valueCount;
+    pValues = in_struct->pValues;
+    pLayerName = SafeStringCopy(in_struct->pLayerName);
+    pSettingName = SafeStringCopy(in_struct->pSettingName);
+}
+
+void safe_VkLayerSettingEXT::initialize(const safe_VkLayerSettingEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    type = copy_src->type;
+    valueCount = copy_src->valueCount;
+    pValues = copy_src->pValues;
+    pLayerName = SafeStringCopy(copy_src->pLayerName);
+    pSettingName = SafeStringCopy(copy_src->pSettingName);
+}
+
+safe_VkLayerSettingsCreateInfoEXT::safe_VkLayerSettingsCreateInfoEXT(const VkLayerSettingsCreateInfoEXT* in_struct,
+                                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), settingCount(in_struct->settingCount), pSettings(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (settingCount && in_struct->pSettings) {
+        pSettings = new safe_VkLayerSettingEXT[settingCount];
+        for (uint32_t i = 0; i < settingCount; ++i) {
+            pSettings[i].initialize(&in_struct->pSettings[i]);
+        }
+    }
+}
+
+safe_VkLayerSettingsCreateInfoEXT::safe_VkLayerSettingsCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT), pNext(nullptr), settingCount(), pSettings(nullptr) {}
+
+safe_VkLayerSettingsCreateInfoEXT::safe_VkLayerSettingsCreateInfoEXT(const safe_VkLayerSettingsCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    settingCount = copy_src.settingCount;
+    pSettings = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (settingCount && copy_src.pSettings) {
+        pSettings = new safe_VkLayerSettingEXT[settingCount];
+        for (uint32_t i = 0; i < settingCount; ++i) {
+            pSettings[i].initialize(&copy_src.pSettings[i]);
+        }
+    }
+}
+
+safe_VkLayerSettingsCreateInfoEXT& safe_VkLayerSettingsCreateInfoEXT::operator=(const safe_VkLayerSettingsCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pSettings) delete[] pSettings;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    settingCount = copy_src.settingCount;
+    pSettings = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (settingCount && copy_src.pSettings) {
+        pSettings = new safe_VkLayerSettingEXT[settingCount];
+        for (uint32_t i = 0; i < settingCount; ++i) {
+            pSettings[i].initialize(&copy_src.pSettings[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkLayerSettingsCreateInfoEXT::~safe_VkLayerSettingsCreateInfoEXT() {
+    if (pSettings) delete[] pSettings;
+    FreePnextChain(pNext);
+}
+
+void safe_VkLayerSettingsCreateInfoEXT::initialize(const VkLayerSettingsCreateInfoEXT* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pSettings) delete[] pSettings;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    settingCount = in_struct->settingCount;
+    pSettings = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (settingCount && in_struct->pSettings) {
+        pSettings = new safe_VkLayerSettingEXT[settingCount];
+        for (uint32_t i = 0; i < settingCount; ++i) {
+            pSettings[i].initialize(&in_struct->pSettings[i]);
+        }
+    }
+}
+
+void safe_VkLayerSettingsCreateInfoEXT::initialize(const safe_VkLayerSettingsCreateInfoEXT* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    settingCount = copy_src->settingCount;
+    pSettings = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (settingCount && copy_src->pSettings) {
+        pSettings = new safe_VkLayerSettingEXT[settingCount];
+        for (uint32_t i = 0; i < settingCount; ++i) {
+            pSettings[i].initialize(&copy_src->pSettings[i]);
+        }
+    }
+}
+
+safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT::safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
+    const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), pipelineLibraryGroupHandles(in_struct->pipelineLibraryGroupHandles) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT::safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT),
+      pNext(nullptr),
+      pipelineLibraryGroupHandles() {}
+
+safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT::safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
+    const safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    pipelineLibraryGroupHandles = copy_src.pipelineLibraryGroupHandles;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT& safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT::operator=(
+    const safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pipelineLibraryGroupHandles = copy_src.pipelineLibraryGroupHandles;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT::~safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT::initialize(
+    const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pipelineLibraryGroupHandles = in_struct->pipelineLibraryGroupHandles;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT::initialize(
+    const safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pipelineLibraryGroupHandles = copy_src->pipelineLibraryGroupHandles;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT::
+    safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(
+        const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+        bool copy_pnext)
+    : sType(in_struct->sType), dynamicRenderingUnusedAttachments(in_struct->dynamicRenderingUnusedAttachments) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT::
+    safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT),
+      pNext(nullptr),
+      dynamicRenderingUnusedAttachments() {}
+
+safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT::
+    safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(
+        const safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    dynamicRenderingUnusedAttachments = copy_src.dynamicRenderingUnusedAttachments;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT&
+safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    dynamicRenderingUnusedAttachments = copy_src.dynamicRenderingUnusedAttachments;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT::
+    ~safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT::initialize(
+    const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    dynamicRenderingUnusedAttachments = in_struct->dynamicRenderingUnusedAttachments;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* copy_src,
+    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    dynamicRenderingUnusedAttachments = copy_src->dynamicRenderingUnusedAttachments;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT::
+    safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+        const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+        bool copy_pnext)
+    : sType(in_struct->sType), attachmentFeedbackLoopDynamicState(in_struct->attachmentFeedbackLoopDynamicState) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT::
+    safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT),
+      pNext(nullptr),
+      attachmentFeedbackLoopDynamicState() {}
+
+safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT::
+    safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+        const safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    attachmentFeedbackLoopDynamicState = copy_src.attachmentFeedbackLoopDynamicState;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT&
+safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    attachmentFeedbackLoopDynamicState = copy_src.attachmentFeedbackLoopDynamicState;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT::
+    ~safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT::initialize(
+    const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    attachmentFeedbackLoopDynamicState = in_struct->attachmentFeedbackLoopDynamicState;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* copy_src,
+    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    attachmentFeedbackLoopDynamicState = copy_src->attachmentFeedbackLoopDynamicState;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceMeshShaderFeaturesEXT::safe_VkPhysicalDeviceMeshShaderFeaturesEXT(
+    const VkPhysicalDeviceMeshShaderFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      taskShader(in_struct->taskShader),
+      meshShader(in_struct->meshShader),
+      multiviewMeshShader(in_struct->multiviewMeshShader),
+      primitiveFragmentShadingRateMeshShader(in_struct->primitiveFragmentShadingRateMeshShader),
+      meshShaderQueries(in_struct->meshShaderQueries) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMeshShaderFeaturesEXT::safe_VkPhysicalDeviceMeshShaderFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT),
+      pNext(nullptr),
+      taskShader(),
+      meshShader(),
+      multiviewMeshShader(),
+      primitiveFragmentShadingRateMeshShader(),
+      meshShaderQueries() {}
+
+safe_VkPhysicalDeviceMeshShaderFeaturesEXT::safe_VkPhysicalDeviceMeshShaderFeaturesEXT(
+    const safe_VkPhysicalDeviceMeshShaderFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    taskShader = copy_src.taskShader;
+    meshShader = copy_src.meshShader;
+    multiviewMeshShader = copy_src.multiviewMeshShader;
+    primitiveFragmentShadingRateMeshShader = copy_src.primitiveFragmentShadingRateMeshShader;
+    meshShaderQueries = copy_src.meshShaderQueries;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMeshShaderFeaturesEXT& safe_VkPhysicalDeviceMeshShaderFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceMeshShaderFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    taskShader = copy_src.taskShader;
+    meshShader = copy_src.meshShader;
+    multiviewMeshShader = copy_src.multiviewMeshShader;
+    primitiveFragmentShadingRateMeshShader = copy_src.primitiveFragmentShadingRateMeshShader;
+    meshShaderQueries = copy_src.meshShaderQueries;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMeshShaderFeaturesEXT::~safe_VkPhysicalDeviceMeshShaderFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceMeshShaderFeaturesEXT::initialize(const VkPhysicalDeviceMeshShaderFeaturesEXT* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    taskShader = in_struct->taskShader;
+    meshShader = in_struct->meshShader;
+    multiviewMeshShader = in_struct->multiviewMeshShader;
+    primitiveFragmentShadingRateMeshShader = in_struct->primitiveFragmentShadingRateMeshShader;
+    meshShaderQueries = in_struct->meshShaderQueries;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMeshShaderFeaturesEXT::initialize(const safe_VkPhysicalDeviceMeshShaderFeaturesEXT* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    taskShader = copy_src->taskShader;
+    meshShader = copy_src->meshShader;
+    multiviewMeshShader = copy_src->multiviewMeshShader;
+    primitiveFragmentShadingRateMeshShader = copy_src->primitiveFragmentShadingRateMeshShader;
+    meshShaderQueries = copy_src->meshShaderQueries;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceMeshShaderPropertiesEXT::safe_VkPhysicalDeviceMeshShaderPropertiesEXT(
+    const VkPhysicalDeviceMeshShaderPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      maxTaskWorkGroupTotalCount(in_struct->maxTaskWorkGroupTotalCount),
+      maxTaskWorkGroupInvocations(in_struct->maxTaskWorkGroupInvocations),
+      maxTaskPayloadSize(in_struct->maxTaskPayloadSize),
+      maxTaskSharedMemorySize(in_struct->maxTaskSharedMemorySize),
+      maxTaskPayloadAndSharedMemorySize(in_struct->maxTaskPayloadAndSharedMemorySize),
+      maxMeshWorkGroupTotalCount(in_struct->maxMeshWorkGroupTotalCount),
+      maxMeshWorkGroupInvocations(in_struct->maxMeshWorkGroupInvocations),
+      maxMeshSharedMemorySize(in_struct->maxMeshSharedMemorySize),
+      maxMeshPayloadAndSharedMemorySize(in_struct->maxMeshPayloadAndSharedMemorySize),
+      maxMeshOutputMemorySize(in_struct->maxMeshOutputMemorySize),
+      maxMeshPayloadAndOutputMemorySize(in_struct->maxMeshPayloadAndOutputMemorySize),
+      maxMeshOutputComponents(in_struct->maxMeshOutputComponents),
+      maxMeshOutputVertices(in_struct->maxMeshOutputVertices),
+      maxMeshOutputPrimitives(in_struct->maxMeshOutputPrimitives),
+      maxMeshOutputLayers(in_struct->maxMeshOutputLayers),
+      maxMeshMultiviewViewCount(in_struct->maxMeshMultiviewViewCount),
+      meshOutputPerVertexGranularity(in_struct->meshOutputPerVertexGranularity),
+      meshOutputPerPrimitiveGranularity(in_struct->meshOutputPerPrimitiveGranularity),
+      maxPreferredTaskWorkGroupInvocations(in_struct->maxPreferredTaskWorkGroupInvocations),
+      maxPreferredMeshWorkGroupInvocations(in_struct->maxPreferredMeshWorkGroupInvocations),
+      prefersLocalInvocationVertexOutput(in_struct->prefersLocalInvocationVertexOutput),
+      prefersLocalInvocationPrimitiveOutput(in_struct->prefersLocalInvocationPrimitiveOutput),
+      prefersCompactVertexOutput(in_struct->prefersCompactVertexOutput),
+      prefersCompactPrimitiveOutput(in_struct->prefersCompactPrimitiveOutput) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxTaskWorkGroupCount[i] = in_struct->maxTaskWorkGroupCount[i];
+    }
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxTaskWorkGroupSize[i] = in_struct->maxTaskWorkGroupSize[i];
+    }
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxMeshWorkGroupCount[i] = in_struct->maxMeshWorkGroupCount[i];
+    }
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxMeshWorkGroupSize[i] = in_struct->maxMeshWorkGroupSize[i];
+    }
+}
+
+safe_VkPhysicalDeviceMeshShaderPropertiesEXT::safe_VkPhysicalDeviceMeshShaderPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT),
+      pNext(nullptr),
+      maxTaskWorkGroupTotalCount(),
+      maxTaskWorkGroupInvocations(),
+      maxTaskPayloadSize(),
+      maxTaskSharedMemorySize(),
+      maxTaskPayloadAndSharedMemorySize(),
+      maxMeshWorkGroupTotalCount(),
+      maxMeshWorkGroupInvocations(),
+      maxMeshSharedMemorySize(),
+      maxMeshPayloadAndSharedMemorySize(),
+      maxMeshOutputMemorySize(),
+      maxMeshPayloadAndOutputMemorySize(),
+      maxMeshOutputComponents(),
+      maxMeshOutputVertices(),
+      maxMeshOutputPrimitives(),
+      maxMeshOutputLayers(),
+      maxMeshMultiviewViewCount(),
+      meshOutputPerVertexGranularity(),
+      meshOutputPerPrimitiveGranularity(),
+      maxPreferredTaskWorkGroupInvocations(),
+      maxPreferredMeshWorkGroupInvocations(),
+      prefersLocalInvocationVertexOutput(),
+      prefersLocalInvocationPrimitiveOutput(),
+      prefersCompactVertexOutput(),
+      prefersCompactPrimitiveOutput() {}
+
+safe_VkPhysicalDeviceMeshShaderPropertiesEXT::safe_VkPhysicalDeviceMeshShaderPropertiesEXT(
+    const safe_VkPhysicalDeviceMeshShaderPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    maxTaskWorkGroupTotalCount = copy_src.maxTaskWorkGroupTotalCount;
+    maxTaskWorkGroupInvocations = copy_src.maxTaskWorkGroupInvocations;
+    maxTaskPayloadSize = copy_src.maxTaskPayloadSize;
+    maxTaskSharedMemorySize = copy_src.maxTaskSharedMemorySize;
+    maxTaskPayloadAndSharedMemorySize = copy_src.maxTaskPayloadAndSharedMemorySize;
+    maxMeshWorkGroupTotalCount = copy_src.maxMeshWorkGroupTotalCount;
+    maxMeshWorkGroupInvocations = copy_src.maxMeshWorkGroupInvocations;
+    maxMeshSharedMemorySize = copy_src.maxMeshSharedMemorySize;
+    maxMeshPayloadAndSharedMemorySize = copy_src.maxMeshPayloadAndSharedMemorySize;
+    maxMeshOutputMemorySize = copy_src.maxMeshOutputMemorySize;
+    maxMeshPayloadAndOutputMemorySize = copy_src.maxMeshPayloadAndOutputMemorySize;
+    maxMeshOutputComponents = copy_src.maxMeshOutputComponents;
+    maxMeshOutputVertices = copy_src.maxMeshOutputVertices;
+    maxMeshOutputPrimitives = copy_src.maxMeshOutputPrimitives;
+    maxMeshOutputLayers = copy_src.maxMeshOutputLayers;
+    maxMeshMultiviewViewCount = copy_src.maxMeshMultiviewViewCount;
+    meshOutputPerVertexGranularity = copy_src.meshOutputPerVertexGranularity;
+    meshOutputPerPrimitiveGranularity = copy_src.meshOutputPerPrimitiveGranularity;
+    maxPreferredTaskWorkGroupInvocations = copy_src.maxPreferredTaskWorkGroupInvocations;
+    maxPreferredMeshWorkGroupInvocations = copy_src.maxPreferredMeshWorkGroupInvocations;
+    prefersLocalInvocationVertexOutput = copy_src.prefersLocalInvocationVertexOutput;
+    prefersLocalInvocationPrimitiveOutput = copy_src.prefersLocalInvocationPrimitiveOutput;
+    prefersCompactVertexOutput = copy_src.prefersCompactVertexOutput;
+    prefersCompactPrimitiveOutput = copy_src.prefersCompactPrimitiveOutput;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxTaskWorkGroupCount[i] = copy_src.maxTaskWorkGroupCount[i];
+    }
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxTaskWorkGroupSize[i] = copy_src.maxTaskWorkGroupSize[i];
+    }
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxMeshWorkGroupCount[i] = copy_src.maxMeshWorkGroupCount[i];
+    }
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxMeshWorkGroupSize[i] = copy_src.maxMeshWorkGroupSize[i];
+    }
+}
+
+safe_VkPhysicalDeviceMeshShaderPropertiesEXT& safe_VkPhysicalDeviceMeshShaderPropertiesEXT::operator=(
+    const safe_VkPhysicalDeviceMeshShaderPropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxTaskWorkGroupTotalCount = copy_src.maxTaskWorkGroupTotalCount;
+    maxTaskWorkGroupInvocations = copy_src.maxTaskWorkGroupInvocations;
+    maxTaskPayloadSize = copy_src.maxTaskPayloadSize;
+    maxTaskSharedMemorySize = copy_src.maxTaskSharedMemorySize;
+    maxTaskPayloadAndSharedMemorySize = copy_src.maxTaskPayloadAndSharedMemorySize;
+    maxMeshWorkGroupTotalCount = copy_src.maxMeshWorkGroupTotalCount;
+    maxMeshWorkGroupInvocations = copy_src.maxMeshWorkGroupInvocations;
+    maxMeshSharedMemorySize = copy_src.maxMeshSharedMemorySize;
+    maxMeshPayloadAndSharedMemorySize = copy_src.maxMeshPayloadAndSharedMemorySize;
+    maxMeshOutputMemorySize = copy_src.maxMeshOutputMemorySize;
+    maxMeshPayloadAndOutputMemorySize = copy_src.maxMeshPayloadAndOutputMemorySize;
+    maxMeshOutputComponents = copy_src.maxMeshOutputComponents;
+    maxMeshOutputVertices = copy_src.maxMeshOutputVertices;
+    maxMeshOutputPrimitives = copy_src.maxMeshOutputPrimitives;
+    maxMeshOutputLayers = copy_src.maxMeshOutputLayers;
+    maxMeshMultiviewViewCount = copy_src.maxMeshMultiviewViewCount;
+    meshOutputPerVertexGranularity = copy_src.meshOutputPerVertexGranularity;
+    meshOutputPerPrimitiveGranularity = copy_src.meshOutputPerPrimitiveGranularity;
+    maxPreferredTaskWorkGroupInvocations = copy_src.maxPreferredTaskWorkGroupInvocations;
+    maxPreferredMeshWorkGroupInvocations = copy_src.maxPreferredMeshWorkGroupInvocations;
+    prefersLocalInvocationVertexOutput = copy_src.prefersLocalInvocationVertexOutput;
+    prefersLocalInvocationPrimitiveOutput = copy_src.prefersLocalInvocationPrimitiveOutput;
+    prefersCompactVertexOutput = copy_src.prefersCompactVertexOutput;
+    prefersCompactPrimitiveOutput = copy_src.prefersCompactPrimitiveOutput;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxTaskWorkGroupCount[i] = copy_src.maxTaskWorkGroupCount[i];
+    }
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxTaskWorkGroupSize[i] = copy_src.maxTaskWorkGroupSize[i];
+    }
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxMeshWorkGroupCount[i] = copy_src.maxMeshWorkGroupCount[i];
+    }
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxMeshWorkGroupSize[i] = copy_src.maxMeshWorkGroupSize[i];
+    }
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMeshShaderPropertiesEXT::~safe_VkPhysicalDeviceMeshShaderPropertiesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceMeshShaderPropertiesEXT::initialize(const VkPhysicalDeviceMeshShaderPropertiesEXT* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxTaskWorkGroupTotalCount = in_struct->maxTaskWorkGroupTotalCount;
+    maxTaskWorkGroupInvocations = in_struct->maxTaskWorkGroupInvocations;
+    maxTaskPayloadSize = in_struct->maxTaskPayloadSize;
+    maxTaskSharedMemorySize = in_struct->maxTaskSharedMemorySize;
+    maxTaskPayloadAndSharedMemorySize = in_struct->maxTaskPayloadAndSharedMemorySize;
+    maxMeshWorkGroupTotalCount = in_struct->maxMeshWorkGroupTotalCount;
+    maxMeshWorkGroupInvocations = in_struct->maxMeshWorkGroupInvocations;
+    maxMeshSharedMemorySize = in_struct->maxMeshSharedMemorySize;
+    maxMeshPayloadAndSharedMemorySize = in_struct->maxMeshPayloadAndSharedMemorySize;
+    maxMeshOutputMemorySize = in_struct->maxMeshOutputMemorySize;
+    maxMeshPayloadAndOutputMemorySize = in_struct->maxMeshPayloadAndOutputMemorySize;
+    maxMeshOutputComponents = in_struct->maxMeshOutputComponents;
+    maxMeshOutputVertices = in_struct->maxMeshOutputVertices;
+    maxMeshOutputPrimitives = in_struct->maxMeshOutputPrimitives;
+    maxMeshOutputLayers = in_struct->maxMeshOutputLayers;
+    maxMeshMultiviewViewCount = in_struct->maxMeshMultiviewViewCount;
+    meshOutputPerVertexGranularity = in_struct->meshOutputPerVertexGranularity;
+    meshOutputPerPrimitiveGranularity = in_struct->meshOutputPerPrimitiveGranularity;
+    maxPreferredTaskWorkGroupInvocations = in_struct->maxPreferredTaskWorkGroupInvocations;
+    maxPreferredMeshWorkGroupInvocations = in_struct->maxPreferredMeshWorkGroupInvocations;
+    prefersLocalInvocationVertexOutput = in_struct->prefersLocalInvocationVertexOutput;
+    prefersLocalInvocationPrimitiveOutput = in_struct->prefersLocalInvocationPrimitiveOutput;
+    prefersCompactVertexOutput = in_struct->prefersCompactVertexOutput;
+    prefersCompactPrimitiveOutput = in_struct->prefersCompactPrimitiveOutput;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxTaskWorkGroupCount[i] = in_struct->maxTaskWorkGroupCount[i];
+    }
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxTaskWorkGroupSize[i] = in_struct->maxTaskWorkGroupSize[i];
+    }
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxMeshWorkGroupCount[i] = in_struct->maxMeshWorkGroupCount[i];
+    }
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxMeshWorkGroupSize[i] = in_struct->maxMeshWorkGroupSize[i];
+    }
+}
+
+void safe_VkPhysicalDeviceMeshShaderPropertiesEXT::initialize(const safe_VkPhysicalDeviceMeshShaderPropertiesEXT* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxTaskWorkGroupTotalCount = copy_src->maxTaskWorkGroupTotalCount;
+    maxTaskWorkGroupInvocations = copy_src->maxTaskWorkGroupInvocations;
+    maxTaskPayloadSize = copy_src->maxTaskPayloadSize;
+    maxTaskSharedMemorySize = copy_src->maxTaskSharedMemorySize;
+    maxTaskPayloadAndSharedMemorySize = copy_src->maxTaskPayloadAndSharedMemorySize;
+    maxMeshWorkGroupTotalCount = copy_src->maxMeshWorkGroupTotalCount;
+    maxMeshWorkGroupInvocations = copy_src->maxMeshWorkGroupInvocations;
+    maxMeshSharedMemorySize = copy_src->maxMeshSharedMemorySize;
+    maxMeshPayloadAndSharedMemorySize = copy_src->maxMeshPayloadAndSharedMemorySize;
+    maxMeshOutputMemorySize = copy_src->maxMeshOutputMemorySize;
+    maxMeshPayloadAndOutputMemorySize = copy_src->maxMeshPayloadAndOutputMemorySize;
+    maxMeshOutputComponents = copy_src->maxMeshOutputComponents;
+    maxMeshOutputVertices = copy_src->maxMeshOutputVertices;
+    maxMeshOutputPrimitives = copy_src->maxMeshOutputPrimitives;
+    maxMeshOutputLayers = copy_src->maxMeshOutputLayers;
+    maxMeshMultiviewViewCount = copy_src->maxMeshMultiviewViewCount;
+    meshOutputPerVertexGranularity = copy_src->meshOutputPerVertexGranularity;
+    meshOutputPerPrimitiveGranularity = copy_src->meshOutputPerPrimitiveGranularity;
+    maxPreferredTaskWorkGroupInvocations = copy_src->maxPreferredTaskWorkGroupInvocations;
+    maxPreferredMeshWorkGroupInvocations = copy_src->maxPreferredMeshWorkGroupInvocations;
+    prefersLocalInvocationVertexOutput = copy_src->prefersLocalInvocationVertexOutput;
+    prefersLocalInvocationPrimitiveOutput = copy_src->prefersLocalInvocationPrimitiveOutput;
+    prefersCompactVertexOutput = copy_src->prefersCompactVertexOutput;
+    prefersCompactPrimitiveOutput = copy_src->prefersCompactPrimitiveOutput;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxTaskWorkGroupCount[i] = copy_src->maxTaskWorkGroupCount[i];
+    }
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxTaskWorkGroupSize[i] = copy_src->maxTaskWorkGroupSize[i];
+    }
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxMeshWorkGroupCount[i] = copy_src->maxMeshWorkGroupCount[i];
+    }
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxMeshWorkGroupSize[i] = copy_src->maxMeshWorkGroupSize[i];
+    }
+}
+
+}  // namespace vku
+
+// NOLINTEND
diff --git a/src/vulkan/vk_safe_struct_khr.cpp b/src/vulkan/vk_safe_struct_khr.cpp
new file mode 100644
index 0000000..d3bf001
--- /dev/null
+++ b/src/vulkan/vk_safe_struct_khr.cpp
@@ -0,0 +1,15627 @@
+// *** THIS FILE IS GENERATED - DO NOT EDIT ***
+// See safe_struct_generator.py for modifications
+
+/***************************************************************************
+ *
+ * Copyright (c) 2015-2024 The Khronos Group Inc.
+ * Copyright (c) 2015-2024 Valve Corporation
+ * Copyright (c) 2015-2024 LunarG, Inc.
+ * Copyright (c) 2015-2024 Google Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ ****************************************************************************/
+
+// NOLINTBEGIN
+
+#include <vulkan/utility/vk_safe_struct.hpp>
+#include <vulkan/utility/vk_struct_helper.hpp>
+
+#include <cstring>
+
+namespace vku {
+
+safe_VkSwapchainCreateInfoKHR::safe_VkSwapchainCreateInfoKHR(const VkSwapchainCreateInfoKHR* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      surface(in_struct->surface),
+      minImageCount(in_struct->minImageCount),
+      imageFormat(in_struct->imageFormat),
+      imageColorSpace(in_struct->imageColorSpace),
+      imageExtent(in_struct->imageExtent),
+      imageArrayLayers(in_struct->imageArrayLayers),
+      imageUsage(in_struct->imageUsage),
+      imageSharingMode(in_struct->imageSharingMode),
+      queueFamilyIndexCount(0),
+      pQueueFamilyIndices(nullptr),
+      preTransform(in_struct->preTransform),
+      compositeAlpha(in_struct->compositeAlpha),
+      presentMode(in_struct->presentMode),
+      clipped(in_struct->clipped),
+      oldSwapchain(in_struct->oldSwapchain) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if ((in_struct->imageSharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->pQueueFamilyIndices) {
+        pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
+        memcpy((void*)pQueueFamilyIndices, (void*)in_struct->pQueueFamilyIndices,
+               sizeof(uint32_t) * in_struct->queueFamilyIndexCount);
+        queueFamilyIndexCount = in_struct->queueFamilyIndexCount;
+    } else {
+        queueFamilyIndexCount = 0;
+    }
+}
+
+safe_VkSwapchainCreateInfoKHR::safe_VkSwapchainCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR),
+      pNext(nullptr),
+      flags(),
+      surface(),
+      minImageCount(),
+      imageFormat(),
+      imageColorSpace(),
+      imageExtent(),
+      imageArrayLayers(),
+      imageUsage(),
+      imageSharingMode(),
+      queueFamilyIndexCount(),
+      pQueueFamilyIndices(nullptr),
+      preTransform(),
+      compositeAlpha(),
+      presentMode(),
+      clipped(),
+      oldSwapchain() {}
+
+safe_VkSwapchainCreateInfoKHR::safe_VkSwapchainCreateInfoKHR(const safe_VkSwapchainCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    surface = copy_src.surface;
+    minImageCount = copy_src.minImageCount;
+    imageFormat = copy_src.imageFormat;
+    imageColorSpace = copy_src.imageColorSpace;
+    imageExtent = copy_src.imageExtent;
+    imageArrayLayers = copy_src.imageArrayLayers;
+    imageUsage = copy_src.imageUsage;
+    imageSharingMode = copy_src.imageSharingMode;
+    pQueueFamilyIndices = nullptr;
+    preTransform = copy_src.preTransform;
+    compositeAlpha = copy_src.compositeAlpha;
+    presentMode = copy_src.presentMode;
+    clipped = copy_src.clipped;
+    oldSwapchain = copy_src.oldSwapchain;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if ((copy_src.imageSharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src.pQueueFamilyIndices) {
+        pQueueFamilyIndices = new uint32_t[copy_src.queueFamilyIndexCount];
+        memcpy((void*)pQueueFamilyIndices, (void*)copy_src.pQueueFamilyIndices, sizeof(uint32_t) * copy_src.queueFamilyIndexCount);
+        queueFamilyIndexCount = copy_src.queueFamilyIndexCount;
+    } else {
+        queueFamilyIndexCount = 0;
+    }
+}
+
+safe_VkSwapchainCreateInfoKHR& safe_VkSwapchainCreateInfoKHR::operator=(const safe_VkSwapchainCreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pQueueFamilyIndices) delete[] pQueueFamilyIndices;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    surface = copy_src.surface;
+    minImageCount = copy_src.minImageCount;
+    imageFormat = copy_src.imageFormat;
+    imageColorSpace = copy_src.imageColorSpace;
+    imageExtent = copy_src.imageExtent;
+    imageArrayLayers = copy_src.imageArrayLayers;
+    imageUsage = copy_src.imageUsage;
+    imageSharingMode = copy_src.imageSharingMode;
+    pQueueFamilyIndices = nullptr;
+    preTransform = copy_src.preTransform;
+    compositeAlpha = copy_src.compositeAlpha;
+    presentMode = copy_src.presentMode;
+    clipped = copy_src.clipped;
+    oldSwapchain = copy_src.oldSwapchain;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if ((copy_src.imageSharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src.pQueueFamilyIndices) {
+        pQueueFamilyIndices = new uint32_t[copy_src.queueFamilyIndexCount];
+        memcpy((void*)pQueueFamilyIndices, (void*)copy_src.pQueueFamilyIndices, sizeof(uint32_t) * copy_src.queueFamilyIndexCount);
+        queueFamilyIndexCount = copy_src.queueFamilyIndexCount;
+    } else {
+        queueFamilyIndexCount = 0;
+    }
+
+    return *this;
+}
+
+safe_VkSwapchainCreateInfoKHR::~safe_VkSwapchainCreateInfoKHR() {
+    if (pQueueFamilyIndices) delete[] pQueueFamilyIndices;
+    FreePnextChain(pNext);
+}
+
+void safe_VkSwapchainCreateInfoKHR::initialize(const VkSwapchainCreateInfoKHR* in_struct,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pQueueFamilyIndices) delete[] pQueueFamilyIndices;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    surface = in_struct->surface;
+    minImageCount = in_struct->minImageCount;
+    imageFormat = in_struct->imageFormat;
+    imageColorSpace = in_struct->imageColorSpace;
+    imageExtent = in_struct->imageExtent;
+    imageArrayLayers = in_struct->imageArrayLayers;
+    imageUsage = in_struct->imageUsage;
+    imageSharingMode = in_struct->imageSharingMode;
+    pQueueFamilyIndices = nullptr;
+    preTransform = in_struct->preTransform;
+    compositeAlpha = in_struct->compositeAlpha;
+    presentMode = in_struct->presentMode;
+    clipped = in_struct->clipped;
+    oldSwapchain = in_struct->oldSwapchain;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if ((in_struct->imageSharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->pQueueFamilyIndices) {
+        pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
+        memcpy((void*)pQueueFamilyIndices, (void*)in_struct->pQueueFamilyIndices,
+               sizeof(uint32_t) * in_struct->queueFamilyIndexCount);
+        queueFamilyIndexCount = in_struct->queueFamilyIndexCount;
+    } else {
+        queueFamilyIndexCount = 0;
+    }
+}
+
+void safe_VkSwapchainCreateInfoKHR::initialize(const safe_VkSwapchainCreateInfoKHR* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    surface = copy_src->surface;
+    minImageCount = copy_src->minImageCount;
+    imageFormat = copy_src->imageFormat;
+    imageColorSpace = copy_src->imageColorSpace;
+    imageExtent = copy_src->imageExtent;
+    imageArrayLayers = copy_src->imageArrayLayers;
+    imageUsage = copy_src->imageUsage;
+    imageSharingMode = copy_src->imageSharingMode;
+    pQueueFamilyIndices = nullptr;
+    preTransform = copy_src->preTransform;
+    compositeAlpha = copy_src->compositeAlpha;
+    presentMode = copy_src->presentMode;
+    clipped = copy_src->clipped;
+    oldSwapchain = copy_src->oldSwapchain;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if ((copy_src->imageSharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src->pQueueFamilyIndices) {
+        pQueueFamilyIndices = new uint32_t[copy_src->queueFamilyIndexCount];
+        memcpy((void*)pQueueFamilyIndices, (void*)copy_src->pQueueFamilyIndices,
+               sizeof(uint32_t) * copy_src->queueFamilyIndexCount);
+        queueFamilyIndexCount = copy_src->queueFamilyIndexCount;
+    } else {
+        queueFamilyIndexCount = 0;
+    }
+}
+
+safe_VkPresentInfoKHR::safe_VkPresentInfoKHR(const VkPresentInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                             bool copy_pnext)
+    : sType(in_struct->sType),
+      waitSemaphoreCount(in_struct->waitSemaphoreCount),
+      pWaitSemaphores(nullptr),
+      swapchainCount(in_struct->swapchainCount),
+      pSwapchains(nullptr),
+      pImageIndices(nullptr),
+      pResults(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (waitSemaphoreCount && in_struct->pWaitSemaphores) {
+        pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
+            pWaitSemaphores[i] = in_struct->pWaitSemaphores[i];
+        }
+    }
+    if (swapchainCount && in_struct->pSwapchains) {
+        pSwapchains = new VkSwapchainKHR[swapchainCount];
+        for (uint32_t i = 0; i < swapchainCount; ++i) {
+            pSwapchains[i] = in_struct->pSwapchains[i];
+        }
+    }
+
+    if (in_struct->pImageIndices) {
+        pImageIndices = new uint32_t[in_struct->swapchainCount];
+        memcpy((void*)pImageIndices, (void*)in_struct->pImageIndices, sizeof(uint32_t) * in_struct->swapchainCount);
+    }
+
+    if (in_struct->pResults) {
+        pResults = new VkResult[in_struct->swapchainCount];
+        memcpy((void*)pResults, (void*)in_struct->pResults, sizeof(VkResult) * in_struct->swapchainCount);
+    }
+}
+
+safe_VkPresentInfoKHR::safe_VkPresentInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_PRESENT_INFO_KHR),
+      pNext(nullptr),
+      waitSemaphoreCount(),
+      pWaitSemaphores(nullptr),
+      swapchainCount(),
+      pSwapchains(nullptr),
+      pImageIndices(nullptr),
+      pResults(nullptr) {}
+
+safe_VkPresentInfoKHR::safe_VkPresentInfoKHR(const safe_VkPresentInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    waitSemaphoreCount = copy_src.waitSemaphoreCount;
+    pWaitSemaphores = nullptr;
+    swapchainCount = copy_src.swapchainCount;
+    pSwapchains = nullptr;
+    pImageIndices = nullptr;
+    pResults = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (waitSemaphoreCount && copy_src.pWaitSemaphores) {
+        pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
+            pWaitSemaphores[i] = copy_src.pWaitSemaphores[i];
+        }
+    }
+    if (swapchainCount && copy_src.pSwapchains) {
+        pSwapchains = new VkSwapchainKHR[swapchainCount];
+        for (uint32_t i = 0; i < swapchainCount; ++i) {
+            pSwapchains[i] = copy_src.pSwapchains[i];
+        }
+    }
+
+    if (copy_src.pImageIndices) {
+        pImageIndices = new uint32_t[copy_src.swapchainCount];
+        memcpy((void*)pImageIndices, (void*)copy_src.pImageIndices, sizeof(uint32_t) * copy_src.swapchainCount);
+    }
+
+    if (copy_src.pResults) {
+        pResults = new VkResult[copy_src.swapchainCount];
+        memcpy((void*)pResults, (void*)copy_src.pResults, sizeof(VkResult) * copy_src.swapchainCount);
+    }
+}
+
+safe_VkPresentInfoKHR& safe_VkPresentInfoKHR::operator=(const safe_VkPresentInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pWaitSemaphores) delete[] pWaitSemaphores;
+    if (pSwapchains) delete[] pSwapchains;
+    if (pImageIndices) delete[] pImageIndices;
+    if (pResults) delete[] pResults;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    waitSemaphoreCount = copy_src.waitSemaphoreCount;
+    pWaitSemaphores = nullptr;
+    swapchainCount = copy_src.swapchainCount;
+    pSwapchains = nullptr;
+    pImageIndices = nullptr;
+    pResults = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (waitSemaphoreCount && copy_src.pWaitSemaphores) {
+        pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
+            pWaitSemaphores[i] = copy_src.pWaitSemaphores[i];
+        }
+    }
+    if (swapchainCount && copy_src.pSwapchains) {
+        pSwapchains = new VkSwapchainKHR[swapchainCount];
+        for (uint32_t i = 0; i < swapchainCount; ++i) {
+            pSwapchains[i] = copy_src.pSwapchains[i];
+        }
+    }
+
+    if (copy_src.pImageIndices) {
+        pImageIndices = new uint32_t[copy_src.swapchainCount];
+        memcpy((void*)pImageIndices, (void*)copy_src.pImageIndices, sizeof(uint32_t) * copy_src.swapchainCount);
+    }
+
+    if (copy_src.pResults) {
+        pResults = new VkResult[copy_src.swapchainCount];
+        memcpy((void*)pResults, (void*)copy_src.pResults, sizeof(VkResult) * copy_src.swapchainCount);
+    }
+
+    return *this;
+}
+
+safe_VkPresentInfoKHR::~safe_VkPresentInfoKHR() {
+    if (pWaitSemaphores) delete[] pWaitSemaphores;
+    if (pSwapchains) delete[] pSwapchains;
+    if (pImageIndices) delete[] pImageIndices;
+    if (pResults) delete[] pResults;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPresentInfoKHR::initialize(const VkPresentInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pWaitSemaphores) delete[] pWaitSemaphores;
+    if (pSwapchains) delete[] pSwapchains;
+    if (pImageIndices) delete[] pImageIndices;
+    if (pResults) delete[] pResults;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    waitSemaphoreCount = in_struct->waitSemaphoreCount;
+    pWaitSemaphores = nullptr;
+    swapchainCount = in_struct->swapchainCount;
+    pSwapchains = nullptr;
+    pImageIndices = nullptr;
+    pResults = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (waitSemaphoreCount && in_struct->pWaitSemaphores) {
+        pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
+            pWaitSemaphores[i] = in_struct->pWaitSemaphores[i];
+        }
+    }
+    if (swapchainCount && in_struct->pSwapchains) {
+        pSwapchains = new VkSwapchainKHR[swapchainCount];
+        for (uint32_t i = 0; i < swapchainCount; ++i) {
+            pSwapchains[i] = in_struct->pSwapchains[i];
+        }
+    }
+
+    if (in_struct->pImageIndices) {
+        pImageIndices = new uint32_t[in_struct->swapchainCount];
+        memcpy((void*)pImageIndices, (void*)in_struct->pImageIndices, sizeof(uint32_t) * in_struct->swapchainCount);
+    }
+
+    if (in_struct->pResults) {
+        pResults = new VkResult[in_struct->swapchainCount];
+        memcpy((void*)pResults, (void*)in_struct->pResults, sizeof(VkResult) * in_struct->swapchainCount);
+    }
+}
+
+void safe_VkPresentInfoKHR::initialize(const safe_VkPresentInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    waitSemaphoreCount = copy_src->waitSemaphoreCount;
+    pWaitSemaphores = nullptr;
+    swapchainCount = copy_src->swapchainCount;
+    pSwapchains = nullptr;
+    pImageIndices = nullptr;
+    pResults = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (waitSemaphoreCount && copy_src->pWaitSemaphores) {
+        pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
+            pWaitSemaphores[i] = copy_src->pWaitSemaphores[i];
+        }
+    }
+    if (swapchainCount && copy_src->pSwapchains) {
+        pSwapchains = new VkSwapchainKHR[swapchainCount];
+        for (uint32_t i = 0; i < swapchainCount; ++i) {
+            pSwapchains[i] = copy_src->pSwapchains[i];
+        }
+    }
+
+    if (copy_src->pImageIndices) {
+        pImageIndices = new uint32_t[copy_src->swapchainCount];
+        memcpy((void*)pImageIndices, (void*)copy_src->pImageIndices, sizeof(uint32_t) * copy_src->swapchainCount);
+    }
+
+    if (copy_src->pResults) {
+        pResults = new VkResult[copy_src->swapchainCount];
+        memcpy((void*)pResults, (void*)copy_src->pResults, sizeof(VkResult) * copy_src->swapchainCount);
+    }
+}
+
+safe_VkImageSwapchainCreateInfoKHR::safe_VkImageSwapchainCreateInfoKHR(const VkImageSwapchainCreateInfoKHR* in_struct,
+                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), swapchain(in_struct->swapchain) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImageSwapchainCreateInfoKHR::safe_VkImageSwapchainCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR), pNext(nullptr), swapchain() {}
+
+safe_VkImageSwapchainCreateInfoKHR::safe_VkImageSwapchainCreateInfoKHR(const safe_VkImageSwapchainCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    swapchain = copy_src.swapchain;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImageSwapchainCreateInfoKHR& safe_VkImageSwapchainCreateInfoKHR::operator=(
+    const safe_VkImageSwapchainCreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    swapchain = copy_src.swapchain;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImageSwapchainCreateInfoKHR::~safe_VkImageSwapchainCreateInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkImageSwapchainCreateInfoKHR::initialize(const VkImageSwapchainCreateInfoKHR* in_struct,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    swapchain = in_struct->swapchain;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImageSwapchainCreateInfoKHR::initialize(const safe_VkImageSwapchainCreateInfoKHR* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    swapchain = copy_src->swapchain;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkBindImageMemorySwapchainInfoKHR::safe_VkBindImageMemorySwapchainInfoKHR(const VkBindImageMemorySwapchainInfoKHR* in_struct,
+                                                                               [[maybe_unused]] PNextCopyState* copy_state,
+                                                                               bool copy_pnext)
+    : sType(in_struct->sType), swapchain(in_struct->swapchain), imageIndex(in_struct->imageIndex) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkBindImageMemorySwapchainInfoKHR::safe_VkBindImageMemorySwapchainInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR), pNext(nullptr), swapchain(), imageIndex() {}
+
+safe_VkBindImageMemorySwapchainInfoKHR::safe_VkBindImageMemorySwapchainInfoKHR(
+    const safe_VkBindImageMemorySwapchainInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    swapchain = copy_src.swapchain;
+    imageIndex = copy_src.imageIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBindImageMemorySwapchainInfoKHR& safe_VkBindImageMemorySwapchainInfoKHR::operator=(
+    const safe_VkBindImageMemorySwapchainInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    swapchain = copy_src.swapchain;
+    imageIndex = copy_src.imageIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkBindImageMemorySwapchainInfoKHR::~safe_VkBindImageMemorySwapchainInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkBindImageMemorySwapchainInfoKHR::initialize(const VkBindImageMemorySwapchainInfoKHR* in_struct,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    swapchain = in_struct->swapchain;
+    imageIndex = in_struct->imageIndex;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkBindImageMemorySwapchainInfoKHR::initialize(const safe_VkBindImageMemorySwapchainInfoKHR* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    swapchain = copy_src->swapchain;
+    imageIndex = copy_src->imageIndex;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkAcquireNextImageInfoKHR::safe_VkAcquireNextImageInfoKHR(const VkAcquireNextImageInfoKHR* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      swapchain(in_struct->swapchain),
+      timeout(in_struct->timeout),
+      semaphore(in_struct->semaphore),
+      fence(in_struct->fence),
+      deviceMask(in_struct->deviceMask) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkAcquireNextImageInfoKHR::safe_VkAcquireNextImageInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR),
+      pNext(nullptr),
+      swapchain(),
+      timeout(),
+      semaphore(),
+      fence(),
+      deviceMask() {}
+
+safe_VkAcquireNextImageInfoKHR::safe_VkAcquireNextImageInfoKHR(const safe_VkAcquireNextImageInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    swapchain = copy_src.swapchain;
+    timeout = copy_src.timeout;
+    semaphore = copy_src.semaphore;
+    fence = copy_src.fence;
+    deviceMask = copy_src.deviceMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkAcquireNextImageInfoKHR& safe_VkAcquireNextImageInfoKHR::operator=(const safe_VkAcquireNextImageInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    swapchain = copy_src.swapchain;
+    timeout = copy_src.timeout;
+    semaphore = copy_src.semaphore;
+    fence = copy_src.fence;
+    deviceMask = copy_src.deviceMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkAcquireNextImageInfoKHR::~safe_VkAcquireNextImageInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkAcquireNextImageInfoKHR::initialize(const VkAcquireNextImageInfoKHR* in_struct,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    swapchain = in_struct->swapchain;
+    timeout = in_struct->timeout;
+    semaphore = in_struct->semaphore;
+    fence = in_struct->fence;
+    deviceMask = in_struct->deviceMask;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkAcquireNextImageInfoKHR::initialize(const safe_VkAcquireNextImageInfoKHR* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    swapchain = copy_src->swapchain;
+    timeout = copy_src->timeout;
+    semaphore = copy_src->semaphore;
+    fence = copy_src->fence;
+    deviceMask = copy_src->deviceMask;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDeviceGroupPresentCapabilitiesKHR::safe_VkDeviceGroupPresentCapabilitiesKHR(
+    const VkDeviceGroupPresentCapabilitiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), modes(in_struct->modes) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
+        presentMask[i] = in_struct->presentMask[i];
+    }
+}
+
+safe_VkDeviceGroupPresentCapabilitiesKHR::safe_VkDeviceGroupPresentCapabilitiesKHR()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR), pNext(nullptr), modes() {}
+
+safe_VkDeviceGroupPresentCapabilitiesKHR::safe_VkDeviceGroupPresentCapabilitiesKHR(
+    const safe_VkDeviceGroupPresentCapabilitiesKHR& copy_src) {
+    sType = copy_src.sType;
+    modes = copy_src.modes;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
+        presentMask[i] = copy_src.presentMask[i];
+    }
+}
+
+safe_VkDeviceGroupPresentCapabilitiesKHR& safe_VkDeviceGroupPresentCapabilitiesKHR::operator=(
+    const safe_VkDeviceGroupPresentCapabilitiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    modes = copy_src.modes;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
+        presentMask[i] = copy_src.presentMask[i];
+    }
+
+    return *this;
+}
+
+safe_VkDeviceGroupPresentCapabilitiesKHR::~safe_VkDeviceGroupPresentCapabilitiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkDeviceGroupPresentCapabilitiesKHR::initialize(const VkDeviceGroupPresentCapabilitiesKHR* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    modes = in_struct->modes;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
+        presentMask[i] = in_struct->presentMask[i];
+    }
+}
+
+void safe_VkDeviceGroupPresentCapabilitiesKHR::initialize(const safe_VkDeviceGroupPresentCapabilitiesKHR* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    modes = copy_src->modes;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
+        presentMask[i] = copy_src->presentMask[i];
+    }
+}
+
+safe_VkDeviceGroupPresentInfoKHR::safe_VkDeviceGroupPresentInfoKHR(const VkDeviceGroupPresentInfoKHR* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), swapchainCount(in_struct->swapchainCount), pDeviceMasks(nullptr), mode(in_struct->mode) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pDeviceMasks) {
+        pDeviceMasks = new uint32_t[in_struct->swapchainCount];
+        memcpy((void*)pDeviceMasks, (void*)in_struct->pDeviceMasks, sizeof(uint32_t) * in_struct->swapchainCount);
+    }
+}
+
+safe_VkDeviceGroupPresentInfoKHR::safe_VkDeviceGroupPresentInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR), pNext(nullptr), swapchainCount(), pDeviceMasks(nullptr), mode() {}
+
+safe_VkDeviceGroupPresentInfoKHR::safe_VkDeviceGroupPresentInfoKHR(const safe_VkDeviceGroupPresentInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    swapchainCount = copy_src.swapchainCount;
+    pDeviceMasks = nullptr;
+    mode = copy_src.mode;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDeviceMasks) {
+        pDeviceMasks = new uint32_t[copy_src.swapchainCount];
+        memcpy((void*)pDeviceMasks, (void*)copy_src.pDeviceMasks, sizeof(uint32_t) * copy_src.swapchainCount);
+    }
+}
+
+safe_VkDeviceGroupPresentInfoKHR& safe_VkDeviceGroupPresentInfoKHR::operator=(const safe_VkDeviceGroupPresentInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pDeviceMasks) delete[] pDeviceMasks;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    swapchainCount = copy_src.swapchainCount;
+    pDeviceMasks = nullptr;
+    mode = copy_src.mode;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDeviceMasks) {
+        pDeviceMasks = new uint32_t[copy_src.swapchainCount];
+        memcpy((void*)pDeviceMasks, (void*)copy_src.pDeviceMasks, sizeof(uint32_t) * copy_src.swapchainCount);
+    }
+
+    return *this;
+}
+
+safe_VkDeviceGroupPresentInfoKHR::~safe_VkDeviceGroupPresentInfoKHR() {
+    if (pDeviceMasks) delete[] pDeviceMasks;
+    FreePnextChain(pNext);
+}
+
+void safe_VkDeviceGroupPresentInfoKHR::initialize(const VkDeviceGroupPresentInfoKHR* in_struct,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pDeviceMasks) delete[] pDeviceMasks;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    swapchainCount = in_struct->swapchainCount;
+    pDeviceMasks = nullptr;
+    mode = in_struct->mode;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pDeviceMasks) {
+        pDeviceMasks = new uint32_t[in_struct->swapchainCount];
+        memcpy((void*)pDeviceMasks, (void*)in_struct->pDeviceMasks, sizeof(uint32_t) * in_struct->swapchainCount);
+    }
+}
+
+void safe_VkDeviceGroupPresentInfoKHR::initialize(const safe_VkDeviceGroupPresentInfoKHR* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    swapchainCount = copy_src->swapchainCount;
+    pDeviceMasks = nullptr;
+    mode = copy_src->mode;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pDeviceMasks) {
+        pDeviceMasks = new uint32_t[copy_src->swapchainCount];
+        memcpy((void*)pDeviceMasks, (void*)copy_src->pDeviceMasks, sizeof(uint32_t) * copy_src->swapchainCount);
+    }
+}
+
+safe_VkDeviceGroupSwapchainCreateInfoKHR::safe_VkDeviceGroupSwapchainCreateInfoKHR(
+    const VkDeviceGroupSwapchainCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), modes(in_struct->modes) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDeviceGroupSwapchainCreateInfoKHR::safe_VkDeviceGroupSwapchainCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR), pNext(nullptr), modes() {}
+
+safe_VkDeviceGroupSwapchainCreateInfoKHR::safe_VkDeviceGroupSwapchainCreateInfoKHR(
+    const safe_VkDeviceGroupSwapchainCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    modes = copy_src.modes;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDeviceGroupSwapchainCreateInfoKHR& safe_VkDeviceGroupSwapchainCreateInfoKHR::operator=(
+    const safe_VkDeviceGroupSwapchainCreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    modes = copy_src.modes;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDeviceGroupSwapchainCreateInfoKHR::~safe_VkDeviceGroupSwapchainCreateInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkDeviceGroupSwapchainCreateInfoKHR::initialize(const VkDeviceGroupSwapchainCreateInfoKHR* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    modes = in_struct->modes;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDeviceGroupSwapchainCreateInfoKHR::initialize(const safe_VkDeviceGroupSwapchainCreateInfoKHR* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    modes = copy_src->modes;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDisplayModeCreateInfoKHR::safe_VkDisplayModeCreateInfoKHR(const VkDisplayModeCreateInfoKHR* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags), parameters(in_struct->parameters) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDisplayModeCreateInfoKHR::safe_VkDisplayModeCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR), pNext(nullptr), flags(), parameters() {}
+
+safe_VkDisplayModeCreateInfoKHR::safe_VkDisplayModeCreateInfoKHR(const safe_VkDisplayModeCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    parameters = copy_src.parameters;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDisplayModeCreateInfoKHR& safe_VkDisplayModeCreateInfoKHR::operator=(const safe_VkDisplayModeCreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    parameters = copy_src.parameters;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDisplayModeCreateInfoKHR::~safe_VkDisplayModeCreateInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkDisplayModeCreateInfoKHR::initialize(const VkDisplayModeCreateInfoKHR* in_struct,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    parameters = in_struct->parameters;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDisplayModeCreateInfoKHR::initialize(const safe_VkDisplayModeCreateInfoKHR* copy_src,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    parameters = copy_src->parameters;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDisplayPropertiesKHR::safe_VkDisplayPropertiesKHR(const VkDisplayPropertiesKHR* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state)
+    : display(in_struct->display),
+      physicalDimensions(in_struct->physicalDimensions),
+      physicalResolution(in_struct->physicalResolution),
+      supportedTransforms(in_struct->supportedTransforms),
+      planeReorderPossible(in_struct->planeReorderPossible),
+      persistentContent(in_struct->persistentContent) {
+    displayName = SafeStringCopy(in_struct->displayName);
+}
+
+safe_VkDisplayPropertiesKHR::safe_VkDisplayPropertiesKHR()
+    : display(),
+      displayName(nullptr),
+      physicalDimensions(),
+      physicalResolution(),
+      supportedTransforms(),
+      planeReorderPossible(),
+      persistentContent() {}
+
+safe_VkDisplayPropertiesKHR::safe_VkDisplayPropertiesKHR(const safe_VkDisplayPropertiesKHR& copy_src) {
+    display = copy_src.display;
+    physicalDimensions = copy_src.physicalDimensions;
+    physicalResolution = copy_src.physicalResolution;
+    supportedTransforms = copy_src.supportedTransforms;
+    planeReorderPossible = copy_src.planeReorderPossible;
+    persistentContent = copy_src.persistentContent;
+    displayName = SafeStringCopy(copy_src.displayName);
+}
+
+safe_VkDisplayPropertiesKHR& safe_VkDisplayPropertiesKHR::operator=(const safe_VkDisplayPropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (displayName) delete[] displayName;
+
+    display = copy_src.display;
+    physicalDimensions = copy_src.physicalDimensions;
+    physicalResolution = copy_src.physicalResolution;
+    supportedTransforms = copy_src.supportedTransforms;
+    planeReorderPossible = copy_src.planeReorderPossible;
+    persistentContent = copy_src.persistentContent;
+    displayName = SafeStringCopy(copy_src.displayName);
+
+    return *this;
+}
+
+safe_VkDisplayPropertiesKHR::~safe_VkDisplayPropertiesKHR() {
+    if (displayName) delete[] displayName;
+}
+
+void safe_VkDisplayPropertiesKHR::initialize(const VkDisplayPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (displayName) delete[] displayName;
+    display = in_struct->display;
+    physicalDimensions = in_struct->physicalDimensions;
+    physicalResolution = in_struct->physicalResolution;
+    supportedTransforms = in_struct->supportedTransforms;
+    planeReorderPossible = in_struct->planeReorderPossible;
+    persistentContent = in_struct->persistentContent;
+    displayName = SafeStringCopy(in_struct->displayName);
+}
+
+void safe_VkDisplayPropertiesKHR::initialize(const safe_VkDisplayPropertiesKHR* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    display = copy_src->display;
+    physicalDimensions = copy_src->physicalDimensions;
+    physicalResolution = copy_src->physicalResolution;
+    supportedTransforms = copy_src->supportedTransforms;
+    planeReorderPossible = copy_src->planeReorderPossible;
+    persistentContent = copy_src->persistentContent;
+    displayName = SafeStringCopy(copy_src->displayName);
+}
+
+safe_VkDisplaySurfaceCreateInfoKHR::safe_VkDisplaySurfaceCreateInfoKHR(const VkDisplaySurfaceCreateInfoKHR* in_struct,
+                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      displayMode(in_struct->displayMode),
+      planeIndex(in_struct->planeIndex),
+      planeStackIndex(in_struct->planeStackIndex),
+      transform(in_struct->transform),
+      globalAlpha(in_struct->globalAlpha),
+      alphaMode(in_struct->alphaMode),
+      imageExtent(in_struct->imageExtent) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDisplaySurfaceCreateInfoKHR::safe_VkDisplaySurfaceCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR),
+      pNext(nullptr),
+      flags(),
+      displayMode(),
+      planeIndex(),
+      planeStackIndex(),
+      transform(),
+      globalAlpha(),
+      alphaMode(),
+      imageExtent() {}
+
+safe_VkDisplaySurfaceCreateInfoKHR::safe_VkDisplaySurfaceCreateInfoKHR(const safe_VkDisplaySurfaceCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    displayMode = copy_src.displayMode;
+    planeIndex = copy_src.planeIndex;
+    planeStackIndex = copy_src.planeStackIndex;
+    transform = copy_src.transform;
+    globalAlpha = copy_src.globalAlpha;
+    alphaMode = copy_src.alphaMode;
+    imageExtent = copy_src.imageExtent;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDisplaySurfaceCreateInfoKHR& safe_VkDisplaySurfaceCreateInfoKHR::operator=(
+    const safe_VkDisplaySurfaceCreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    displayMode = copy_src.displayMode;
+    planeIndex = copy_src.planeIndex;
+    planeStackIndex = copy_src.planeStackIndex;
+    transform = copy_src.transform;
+    globalAlpha = copy_src.globalAlpha;
+    alphaMode = copy_src.alphaMode;
+    imageExtent = copy_src.imageExtent;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDisplaySurfaceCreateInfoKHR::~safe_VkDisplaySurfaceCreateInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkDisplaySurfaceCreateInfoKHR::initialize(const VkDisplaySurfaceCreateInfoKHR* in_struct,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    displayMode = in_struct->displayMode;
+    planeIndex = in_struct->planeIndex;
+    planeStackIndex = in_struct->planeStackIndex;
+    transform = in_struct->transform;
+    globalAlpha = in_struct->globalAlpha;
+    alphaMode = in_struct->alphaMode;
+    imageExtent = in_struct->imageExtent;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDisplaySurfaceCreateInfoKHR::initialize(const safe_VkDisplaySurfaceCreateInfoKHR* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    displayMode = copy_src->displayMode;
+    planeIndex = copy_src->planeIndex;
+    planeStackIndex = copy_src->planeStackIndex;
+    transform = copy_src->transform;
+    globalAlpha = copy_src->globalAlpha;
+    alphaMode = copy_src->alphaMode;
+    imageExtent = copy_src->imageExtent;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDisplayPresentInfoKHR::safe_VkDisplayPresentInfoKHR(const VkDisplayPresentInfoKHR* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), srcRect(in_struct->srcRect), dstRect(in_struct->dstRect), persistent(in_struct->persistent) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDisplayPresentInfoKHR::safe_VkDisplayPresentInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR), pNext(nullptr), srcRect(), dstRect(), persistent() {}
+
+safe_VkDisplayPresentInfoKHR::safe_VkDisplayPresentInfoKHR(const safe_VkDisplayPresentInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    srcRect = copy_src.srcRect;
+    dstRect = copy_src.dstRect;
+    persistent = copy_src.persistent;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDisplayPresentInfoKHR& safe_VkDisplayPresentInfoKHR::operator=(const safe_VkDisplayPresentInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    srcRect = copy_src.srcRect;
+    dstRect = copy_src.dstRect;
+    persistent = copy_src.persistent;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDisplayPresentInfoKHR::~safe_VkDisplayPresentInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkDisplayPresentInfoKHR::initialize(const VkDisplayPresentInfoKHR* in_struct,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    srcRect = in_struct->srcRect;
+    dstRect = in_struct->dstRect;
+    persistent = in_struct->persistent;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDisplayPresentInfoKHR::initialize(const safe_VkDisplayPresentInfoKHR* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    srcRect = copy_src->srcRect;
+    dstRect = copy_src->dstRect;
+    persistent = copy_src->persistent;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkQueueFamilyQueryResultStatusPropertiesKHR::safe_VkQueueFamilyQueryResultStatusPropertiesKHR(
+    const VkQueueFamilyQueryResultStatusPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), queryResultStatusSupport(in_struct->queryResultStatusSupport) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkQueueFamilyQueryResultStatusPropertiesKHR::safe_VkQueueFamilyQueryResultStatusPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR), pNext(nullptr), queryResultStatusSupport() {}
+
+safe_VkQueueFamilyQueryResultStatusPropertiesKHR::safe_VkQueueFamilyQueryResultStatusPropertiesKHR(
+    const safe_VkQueueFamilyQueryResultStatusPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    queryResultStatusSupport = copy_src.queryResultStatusSupport;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkQueueFamilyQueryResultStatusPropertiesKHR& safe_VkQueueFamilyQueryResultStatusPropertiesKHR::operator=(
+    const safe_VkQueueFamilyQueryResultStatusPropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    queryResultStatusSupport = copy_src.queryResultStatusSupport;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkQueueFamilyQueryResultStatusPropertiesKHR::~safe_VkQueueFamilyQueryResultStatusPropertiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkQueueFamilyQueryResultStatusPropertiesKHR::initialize(const VkQueueFamilyQueryResultStatusPropertiesKHR* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    queryResultStatusSupport = in_struct->queryResultStatusSupport;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkQueueFamilyQueryResultStatusPropertiesKHR::initialize(const safe_VkQueueFamilyQueryResultStatusPropertiesKHR* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    queryResultStatusSupport = copy_src->queryResultStatusSupport;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkQueueFamilyVideoPropertiesKHR::safe_VkQueueFamilyVideoPropertiesKHR(const VkQueueFamilyVideoPropertiesKHR* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), videoCodecOperations(in_struct->videoCodecOperations) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkQueueFamilyVideoPropertiesKHR::safe_VkQueueFamilyVideoPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR), pNext(nullptr), videoCodecOperations() {}
+
+safe_VkQueueFamilyVideoPropertiesKHR::safe_VkQueueFamilyVideoPropertiesKHR(const safe_VkQueueFamilyVideoPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    videoCodecOperations = copy_src.videoCodecOperations;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkQueueFamilyVideoPropertiesKHR& safe_VkQueueFamilyVideoPropertiesKHR::operator=(
+    const safe_VkQueueFamilyVideoPropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    videoCodecOperations = copy_src.videoCodecOperations;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkQueueFamilyVideoPropertiesKHR::~safe_VkQueueFamilyVideoPropertiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkQueueFamilyVideoPropertiesKHR::initialize(const VkQueueFamilyVideoPropertiesKHR* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    videoCodecOperations = in_struct->videoCodecOperations;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkQueueFamilyVideoPropertiesKHR::initialize(const safe_VkQueueFamilyVideoPropertiesKHR* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    videoCodecOperations = copy_src->videoCodecOperations;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoProfileInfoKHR::safe_VkVideoProfileInfoKHR(const VkVideoProfileInfoKHR* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      videoCodecOperation(in_struct->videoCodecOperation),
+      chromaSubsampling(in_struct->chromaSubsampling),
+      lumaBitDepth(in_struct->lumaBitDepth),
+      chromaBitDepth(in_struct->chromaBitDepth) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoProfileInfoKHR::safe_VkVideoProfileInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR),
+      pNext(nullptr),
+      videoCodecOperation(),
+      chromaSubsampling(),
+      lumaBitDepth(),
+      chromaBitDepth() {}
+
+safe_VkVideoProfileInfoKHR::safe_VkVideoProfileInfoKHR(const safe_VkVideoProfileInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    videoCodecOperation = copy_src.videoCodecOperation;
+    chromaSubsampling = copy_src.chromaSubsampling;
+    lumaBitDepth = copy_src.lumaBitDepth;
+    chromaBitDepth = copy_src.chromaBitDepth;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoProfileInfoKHR& safe_VkVideoProfileInfoKHR::operator=(const safe_VkVideoProfileInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    videoCodecOperation = copy_src.videoCodecOperation;
+    chromaSubsampling = copy_src.chromaSubsampling;
+    lumaBitDepth = copy_src.lumaBitDepth;
+    chromaBitDepth = copy_src.chromaBitDepth;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoProfileInfoKHR::~safe_VkVideoProfileInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoProfileInfoKHR::initialize(const VkVideoProfileInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    videoCodecOperation = in_struct->videoCodecOperation;
+    chromaSubsampling = in_struct->chromaSubsampling;
+    lumaBitDepth = in_struct->lumaBitDepth;
+    chromaBitDepth = in_struct->chromaBitDepth;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoProfileInfoKHR::initialize(const safe_VkVideoProfileInfoKHR* copy_src,
+                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    videoCodecOperation = copy_src->videoCodecOperation;
+    chromaSubsampling = copy_src->chromaSubsampling;
+    lumaBitDepth = copy_src->lumaBitDepth;
+    chromaBitDepth = copy_src->chromaBitDepth;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoProfileListInfoKHR::safe_VkVideoProfileListInfoKHR(const VkVideoProfileListInfoKHR* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), profileCount(in_struct->profileCount), pProfiles(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (profileCount && in_struct->pProfiles) {
+        pProfiles = new safe_VkVideoProfileInfoKHR[profileCount];
+        for (uint32_t i = 0; i < profileCount; ++i) {
+            pProfiles[i].initialize(&in_struct->pProfiles[i]);
+        }
+    }
+}
+
+safe_VkVideoProfileListInfoKHR::safe_VkVideoProfileListInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR), pNext(nullptr), profileCount(), pProfiles(nullptr) {}
+
+safe_VkVideoProfileListInfoKHR::safe_VkVideoProfileListInfoKHR(const safe_VkVideoProfileListInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    profileCount = copy_src.profileCount;
+    pProfiles = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (profileCount && copy_src.pProfiles) {
+        pProfiles = new safe_VkVideoProfileInfoKHR[profileCount];
+        for (uint32_t i = 0; i < profileCount; ++i) {
+            pProfiles[i].initialize(&copy_src.pProfiles[i]);
+        }
+    }
+}
+
+safe_VkVideoProfileListInfoKHR& safe_VkVideoProfileListInfoKHR::operator=(const safe_VkVideoProfileListInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pProfiles) delete[] pProfiles;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    profileCount = copy_src.profileCount;
+    pProfiles = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (profileCount && copy_src.pProfiles) {
+        pProfiles = new safe_VkVideoProfileInfoKHR[profileCount];
+        for (uint32_t i = 0; i < profileCount; ++i) {
+            pProfiles[i].initialize(&copy_src.pProfiles[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkVideoProfileListInfoKHR::~safe_VkVideoProfileListInfoKHR() {
+    if (pProfiles) delete[] pProfiles;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoProfileListInfoKHR::initialize(const VkVideoProfileListInfoKHR* in_struct,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pProfiles) delete[] pProfiles;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    profileCount = in_struct->profileCount;
+    pProfiles = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (profileCount && in_struct->pProfiles) {
+        pProfiles = new safe_VkVideoProfileInfoKHR[profileCount];
+        for (uint32_t i = 0; i < profileCount; ++i) {
+            pProfiles[i].initialize(&in_struct->pProfiles[i]);
+        }
+    }
+}
+
+void safe_VkVideoProfileListInfoKHR::initialize(const safe_VkVideoProfileListInfoKHR* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    profileCount = copy_src->profileCount;
+    pProfiles = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (profileCount && copy_src->pProfiles) {
+        pProfiles = new safe_VkVideoProfileInfoKHR[profileCount];
+        for (uint32_t i = 0; i < profileCount; ++i) {
+            pProfiles[i].initialize(&copy_src->pProfiles[i]);
+        }
+    }
+}
+
+safe_VkVideoCapabilitiesKHR::safe_VkVideoCapabilitiesKHR(const VkVideoCapabilitiesKHR* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      minBitstreamBufferOffsetAlignment(in_struct->minBitstreamBufferOffsetAlignment),
+      minBitstreamBufferSizeAlignment(in_struct->minBitstreamBufferSizeAlignment),
+      pictureAccessGranularity(in_struct->pictureAccessGranularity),
+      minCodedExtent(in_struct->minCodedExtent),
+      maxCodedExtent(in_struct->maxCodedExtent),
+      maxDpbSlots(in_struct->maxDpbSlots),
+      maxActiveReferencePictures(in_struct->maxActiveReferencePictures),
+      stdHeaderVersion(in_struct->stdHeaderVersion) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoCapabilitiesKHR::safe_VkVideoCapabilitiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR),
+      pNext(nullptr),
+      flags(),
+      minBitstreamBufferOffsetAlignment(),
+      minBitstreamBufferSizeAlignment(),
+      pictureAccessGranularity(),
+      minCodedExtent(),
+      maxCodedExtent(),
+      maxDpbSlots(),
+      maxActiveReferencePictures(),
+      stdHeaderVersion() {}
+
+safe_VkVideoCapabilitiesKHR::safe_VkVideoCapabilitiesKHR(const safe_VkVideoCapabilitiesKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    minBitstreamBufferOffsetAlignment = copy_src.minBitstreamBufferOffsetAlignment;
+    minBitstreamBufferSizeAlignment = copy_src.minBitstreamBufferSizeAlignment;
+    pictureAccessGranularity = copy_src.pictureAccessGranularity;
+    minCodedExtent = copy_src.minCodedExtent;
+    maxCodedExtent = copy_src.maxCodedExtent;
+    maxDpbSlots = copy_src.maxDpbSlots;
+    maxActiveReferencePictures = copy_src.maxActiveReferencePictures;
+    stdHeaderVersion = copy_src.stdHeaderVersion;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoCapabilitiesKHR& safe_VkVideoCapabilitiesKHR::operator=(const safe_VkVideoCapabilitiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    minBitstreamBufferOffsetAlignment = copy_src.minBitstreamBufferOffsetAlignment;
+    minBitstreamBufferSizeAlignment = copy_src.minBitstreamBufferSizeAlignment;
+    pictureAccessGranularity = copy_src.pictureAccessGranularity;
+    minCodedExtent = copy_src.minCodedExtent;
+    maxCodedExtent = copy_src.maxCodedExtent;
+    maxDpbSlots = copy_src.maxDpbSlots;
+    maxActiveReferencePictures = copy_src.maxActiveReferencePictures;
+    stdHeaderVersion = copy_src.stdHeaderVersion;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoCapabilitiesKHR::~safe_VkVideoCapabilitiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoCapabilitiesKHR::initialize(const VkVideoCapabilitiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    minBitstreamBufferOffsetAlignment = in_struct->minBitstreamBufferOffsetAlignment;
+    minBitstreamBufferSizeAlignment = in_struct->minBitstreamBufferSizeAlignment;
+    pictureAccessGranularity = in_struct->pictureAccessGranularity;
+    minCodedExtent = in_struct->minCodedExtent;
+    maxCodedExtent = in_struct->maxCodedExtent;
+    maxDpbSlots = in_struct->maxDpbSlots;
+    maxActiveReferencePictures = in_struct->maxActiveReferencePictures;
+    stdHeaderVersion = in_struct->stdHeaderVersion;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoCapabilitiesKHR::initialize(const safe_VkVideoCapabilitiesKHR* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    minBitstreamBufferOffsetAlignment = copy_src->minBitstreamBufferOffsetAlignment;
+    minBitstreamBufferSizeAlignment = copy_src->minBitstreamBufferSizeAlignment;
+    pictureAccessGranularity = copy_src->pictureAccessGranularity;
+    minCodedExtent = copy_src->minCodedExtent;
+    maxCodedExtent = copy_src->maxCodedExtent;
+    maxDpbSlots = copy_src->maxDpbSlots;
+    maxActiveReferencePictures = copy_src->maxActiveReferencePictures;
+    stdHeaderVersion = copy_src->stdHeaderVersion;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceVideoFormatInfoKHR::safe_VkPhysicalDeviceVideoFormatInfoKHR(
+    const VkPhysicalDeviceVideoFormatInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), imageUsage(in_struct->imageUsage) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceVideoFormatInfoKHR::safe_VkPhysicalDeviceVideoFormatInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR), pNext(nullptr), imageUsage() {}
+
+safe_VkPhysicalDeviceVideoFormatInfoKHR::safe_VkPhysicalDeviceVideoFormatInfoKHR(
+    const safe_VkPhysicalDeviceVideoFormatInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    imageUsage = copy_src.imageUsage;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceVideoFormatInfoKHR& safe_VkPhysicalDeviceVideoFormatInfoKHR::operator=(
+    const safe_VkPhysicalDeviceVideoFormatInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    imageUsage = copy_src.imageUsage;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceVideoFormatInfoKHR::~safe_VkPhysicalDeviceVideoFormatInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceVideoFormatInfoKHR::initialize(const VkPhysicalDeviceVideoFormatInfoKHR* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    imageUsage = in_struct->imageUsage;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceVideoFormatInfoKHR::initialize(const safe_VkPhysicalDeviceVideoFormatInfoKHR* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imageUsage = copy_src->imageUsage;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoFormatPropertiesKHR::safe_VkVideoFormatPropertiesKHR(const VkVideoFormatPropertiesKHR* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      format(in_struct->format),
+      componentMapping(in_struct->componentMapping),
+      imageCreateFlags(in_struct->imageCreateFlags),
+      imageType(in_struct->imageType),
+      imageTiling(in_struct->imageTiling),
+      imageUsageFlags(in_struct->imageUsageFlags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoFormatPropertiesKHR::safe_VkVideoFormatPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR),
+      pNext(nullptr),
+      format(),
+      componentMapping(),
+      imageCreateFlags(),
+      imageType(),
+      imageTiling(),
+      imageUsageFlags() {}
+
+safe_VkVideoFormatPropertiesKHR::safe_VkVideoFormatPropertiesKHR(const safe_VkVideoFormatPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    format = copy_src.format;
+    componentMapping = copy_src.componentMapping;
+    imageCreateFlags = copy_src.imageCreateFlags;
+    imageType = copy_src.imageType;
+    imageTiling = copy_src.imageTiling;
+    imageUsageFlags = copy_src.imageUsageFlags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoFormatPropertiesKHR& safe_VkVideoFormatPropertiesKHR::operator=(const safe_VkVideoFormatPropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    format = copy_src.format;
+    componentMapping = copy_src.componentMapping;
+    imageCreateFlags = copy_src.imageCreateFlags;
+    imageType = copy_src.imageType;
+    imageTiling = copy_src.imageTiling;
+    imageUsageFlags = copy_src.imageUsageFlags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoFormatPropertiesKHR::~safe_VkVideoFormatPropertiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoFormatPropertiesKHR::initialize(const VkVideoFormatPropertiesKHR* in_struct,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    format = in_struct->format;
+    componentMapping = in_struct->componentMapping;
+    imageCreateFlags = in_struct->imageCreateFlags;
+    imageType = in_struct->imageType;
+    imageTiling = in_struct->imageTiling;
+    imageUsageFlags = in_struct->imageUsageFlags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoFormatPropertiesKHR::initialize(const safe_VkVideoFormatPropertiesKHR* copy_src,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    format = copy_src->format;
+    componentMapping = copy_src->componentMapping;
+    imageCreateFlags = copy_src->imageCreateFlags;
+    imageType = copy_src->imageType;
+    imageTiling = copy_src->imageTiling;
+    imageUsageFlags = copy_src->imageUsageFlags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoPictureResourceInfoKHR::safe_VkVideoPictureResourceInfoKHR(const VkVideoPictureResourceInfoKHR* in_struct,
+                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      codedOffset(in_struct->codedOffset),
+      codedExtent(in_struct->codedExtent),
+      baseArrayLayer(in_struct->baseArrayLayer),
+      imageViewBinding(in_struct->imageViewBinding) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoPictureResourceInfoKHR::safe_VkVideoPictureResourceInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR),
+      pNext(nullptr),
+      codedOffset(),
+      codedExtent(),
+      baseArrayLayer(),
+      imageViewBinding() {}
+
+safe_VkVideoPictureResourceInfoKHR::safe_VkVideoPictureResourceInfoKHR(const safe_VkVideoPictureResourceInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    codedOffset = copy_src.codedOffset;
+    codedExtent = copy_src.codedExtent;
+    baseArrayLayer = copy_src.baseArrayLayer;
+    imageViewBinding = copy_src.imageViewBinding;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoPictureResourceInfoKHR& safe_VkVideoPictureResourceInfoKHR::operator=(
+    const safe_VkVideoPictureResourceInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    codedOffset = copy_src.codedOffset;
+    codedExtent = copy_src.codedExtent;
+    baseArrayLayer = copy_src.baseArrayLayer;
+    imageViewBinding = copy_src.imageViewBinding;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoPictureResourceInfoKHR::~safe_VkVideoPictureResourceInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoPictureResourceInfoKHR::initialize(const VkVideoPictureResourceInfoKHR* in_struct,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    codedOffset = in_struct->codedOffset;
+    codedExtent = in_struct->codedExtent;
+    baseArrayLayer = in_struct->baseArrayLayer;
+    imageViewBinding = in_struct->imageViewBinding;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoPictureResourceInfoKHR::initialize(const safe_VkVideoPictureResourceInfoKHR* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    codedOffset = copy_src->codedOffset;
+    codedExtent = copy_src->codedExtent;
+    baseArrayLayer = copy_src->baseArrayLayer;
+    imageViewBinding = copy_src->imageViewBinding;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoReferenceSlotInfoKHR::safe_VkVideoReferenceSlotInfoKHR(const VkVideoReferenceSlotInfoKHR* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), slotIndex(in_struct->slotIndex), pPictureResource(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pPictureResource) pPictureResource = new safe_VkVideoPictureResourceInfoKHR(in_struct->pPictureResource);
+}
+
+safe_VkVideoReferenceSlotInfoKHR::safe_VkVideoReferenceSlotInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR), pNext(nullptr), slotIndex(), pPictureResource(nullptr) {}
+
+safe_VkVideoReferenceSlotInfoKHR::safe_VkVideoReferenceSlotInfoKHR(const safe_VkVideoReferenceSlotInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    slotIndex = copy_src.slotIndex;
+    pPictureResource = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pPictureResource) pPictureResource = new safe_VkVideoPictureResourceInfoKHR(*copy_src.pPictureResource);
+}
+
+safe_VkVideoReferenceSlotInfoKHR& safe_VkVideoReferenceSlotInfoKHR::operator=(const safe_VkVideoReferenceSlotInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pPictureResource) delete pPictureResource;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    slotIndex = copy_src.slotIndex;
+    pPictureResource = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pPictureResource) pPictureResource = new safe_VkVideoPictureResourceInfoKHR(*copy_src.pPictureResource);
+
+    return *this;
+}
+
+safe_VkVideoReferenceSlotInfoKHR::~safe_VkVideoReferenceSlotInfoKHR() {
+    if (pPictureResource) delete pPictureResource;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoReferenceSlotInfoKHR::initialize(const VkVideoReferenceSlotInfoKHR* in_struct,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pPictureResource) delete pPictureResource;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    slotIndex = in_struct->slotIndex;
+    pPictureResource = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (in_struct->pPictureResource) pPictureResource = new safe_VkVideoPictureResourceInfoKHR(in_struct->pPictureResource);
+}
+
+void safe_VkVideoReferenceSlotInfoKHR::initialize(const safe_VkVideoReferenceSlotInfoKHR* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    slotIndex = copy_src->slotIndex;
+    pPictureResource = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (copy_src->pPictureResource) pPictureResource = new safe_VkVideoPictureResourceInfoKHR(*copy_src->pPictureResource);
+}
+
+safe_VkVideoSessionMemoryRequirementsKHR::safe_VkVideoSessionMemoryRequirementsKHR(
+    const VkVideoSessionMemoryRequirementsKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), memoryBindIndex(in_struct->memoryBindIndex), memoryRequirements(in_struct->memoryRequirements) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoSessionMemoryRequirementsKHR::safe_VkVideoSessionMemoryRequirementsKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR), pNext(nullptr), memoryBindIndex(), memoryRequirements() {}
+
+safe_VkVideoSessionMemoryRequirementsKHR::safe_VkVideoSessionMemoryRequirementsKHR(
+    const safe_VkVideoSessionMemoryRequirementsKHR& copy_src) {
+    sType = copy_src.sType;
+    memoryBindIndex = copy_src.memoryBindIndex;
+    memoryRequirements = copy_src.memoryRequirements;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoSessionMemoryRequirementsKHR& safe_VkVideoSessionMemoryRequirementsKHR::operator=(
+    const safe_VkVideoSessionMemoryRequirementsKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    memoryBindIndex = copy_src.memoryBindIndex;
+    memoryRequirements = copy_src.memoryRequirements;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoSessionMemoryRequirementsKHR::~safe_VkVideoSessionMemoryRequirementsKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoSessionMemoryRequirementsKHR::initialize(const VkVideoSessionMemoryRequirementsKHR* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    memoryBindIndex = in_struct->memoryBindIndex;
+    memoryRequirements = in_struct->memoryRequirements;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoSessionMemoryRequirementsKHR::initialize(const safe_VkVideoSessionMemoryRequirementsKHR* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memoryBindIndex = copy_src->memoryBindIndex;
+    memoryRequirements = copy_src->memoryRequirements;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkBindVideoSessionMemoryInfoKHR::safe_VkBindVideoSessionMemoryInfoKHR(const VkBindVideoSessionMemoryInfoKHR* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType),
+      memoryBindIndex(in_struct->memoryBindIndex),
+      memory(in_struct->memory),
+      memoryOffset(in_struct->memoryOffset),
+      memorySize(in_struct->memorySize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkBindVideoSessionMemoryInfoKHR::safe_VkBindVideoSessionMemoryInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR),
+      pNext(nullptr),
+      memoryBindIndex(),
+      memory(),
+      memoryOffset(),
+      memorySize() {}
+
+safe_VkBindVideoSessionMemoryInfoKHR::safe_VkBindVideoSessionMemoryInfoKHR(const safe_VkBindVideoSessionMemoryInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    memoryBindIndex = copy_src.memoryBindIndex;
+    memory = copy_src.memory;
+    memoryOffset = copy_src.memoryOffset;
+    memorySize = copy_src.memorySize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBindVideoSessionMemoryInfoKHR& safe_VkBindVideoSessionMemoryInfoKHR::operator=(
+    const safe_VkBindVideoSessionMemoryInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    memoryBindIndex = copy_src.memoryBindIndex;
+    memory = copy_src.memory;
+    memoryOffset = copy_src.memoryOffset;
+    memorySize = copy_src.memorySize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkBindVideoSessionMemoryInfoKHR::~safe_VkBindVideoSessionMemoryInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkBindVideoSessionMemoryInfoKHR::initialize(const VkBindVideoSessionMemoryInfoKHR* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    memoryBindIndex = in_struct->memoryBindIndex;
+    memory = in_struct->memory;
+    memoryOffset = in_struct->memoryOffset;
+    memorySize = in_struct->memorySize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkBindVideoSessionMemoryInfoKHR::initialize(const safe_VkBindVideoSessionMemoryInfoKHR* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memoryBindIndex = copy_src->memoryBindIndex;
+    memory = copy_src->memory;
+    memoryOffset = copy_src->memoryOffset;
+    memorySize = copy_src->memorySize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoSessionCreateInfoKHR::safe_VkVideoSessionCreateInfoKHR(const VkVideoSessionCreateInfoKHR* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      queueFamilyIndex(in_struct->queueFamilyIndex),
+      flags(in_struct->flags),
+      pVideoProfile(nullptr),
+      pictureFormat(in_struct->pictureFormat),
+      maxCodedExtent(in_struct->maxCodedExtent),
+      referencePictureFormat(in_struct->referencePictureFormat),
+      maxDpbSlots(in_struct->maxDpbSlots),
+      maxActiveReferencePictures(in_struct->maxActiveReferencePictures),
+      pStdHeaderVersion(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pVideoProfile) pVideoProfile = new safe_VkVideoProfileInfoKHR(in_struct->pVideoProfile);
+
+    if (in_struct->pStdHeaderVersion) {
+        pStdHeaderVersion = new VkExtensionProperties(*in_struct->pStdHeaderVersion);
+    }
+}
+
+safe_VkVideoSessionCreateInfoKHR::safe_VkVideoSessionCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR),
+      pNext(nullptr),
+      queueFamilyIndex(),
+      flags(),
+      pVideoProfile(nullptr),
+      pictureFormat(),
+      maxCodedExtent(),
+      referencePictureFormat(),
+      maxDpbSlots(),
+      maxActiveReferencePictures(),
+      pStdHeaderVersion(nullptr) {}
+
+safe_VkVideoSessionCreateInfoKHR::safe_VkVideoSessionCreateInfoKHR(const safe_VkVideoSessionCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    queueFamilyIndex = copy_src.queueFamilyIndex;
+    flags = copy_src.flags;
+    pVideoProfile = nullptr;
+    pictureFormat = copy_src.pictureFormat;
+    maxCodedExtent = copy_src.maxCodedExtent;
+    referencePictureFormat = copy_src.referencePictureFormat;
+    maxDpbSlots = copy_src.maxDpbSlots;
+    maxActiveReferencePictures = copy_src.maxActiveReferencePictures;
+    pStdHeaderVersion = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pVideoProfile) pVideoProfile = new safe_VkVideoProfileInfoKHR(*copy_src.pVideoProfile);
+
+    if (copy_src.pStdHeaderVersion) {
+        pStdHeaderVersion = new VkExtensionProperties(*copy_src.pStdHeaderVersion);
+    }
+}
+
+safe_VkVideoSessionCreateInfoKHR& safe_VkVideoSessionCreateInfoKHR::operator=(const safe_VkVideoSessionCreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pVideoProfile) delete pVideoProfile;
+    if (pStdHeaderVersion) delete pStdHeaderVersion;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    queueFamilyIndex = copy_src.queueFamilyIndex;
+    flags = copy_src.flags;
+    pVideoProfile = nullptr;
+    pictureFormat = copy_src.pictureFormat;
+    maxCodedExtent = copy_src.maxCodedExtent;
+    referencePictureFormat = copy_src.referencePictureFormat;
+    maxDpbSlots = copy_src.maxDpbSlots;
+    maxActiveReferencePictures = copy_src.maxActiveReferencePictures;
+    pStdHeaderVersion = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pVideoProfile) pVideoProfile = new safe_VkVideoProfileInfoKHR(*copy_src.pVideoProfile);
+
+    if (copy_src.pStdHeaderVersion) {
+        pStdHeaderVersion = new VkExtensionProperties(*copy_src.pStdHeaderVersion);
+    }
+
+    return *this;
+}
+
+safe_VkVideoSessionCreateInfoKHR::~safe_VkVideoSessionCreateInfoKHR() {
+    if (pVideoProfile) delete pVideoProfile;
+    if (pStdHeaderVersion) delete pStdHeaderVersion;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoSessionCreateInfoKHR::initialize(const VkVideoSessionCreateInfoKHR* in_struct,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pVideoProfile) delete pVideoProfile;
+    if (pStdHeaderVersion) delete pStdHeaderVersion;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    queueFamilyIndex = in_struct->queueFamilyIndex;
+    flags = in_struct->flags;
+    pVideoProfile = nullptr;
+    pictureFormat = in_struct->pictureFormat;
+    maxCodedExtent = in_struct->maxCodedExtent;
+    referencePictureFormat = in_struct->referencePictureFormat;
+    maxDpbSlots = in_struct->maxDpbSlots;
+    maxActiveReferencePictures = in_struct->maxActiveReferencePictures;
+    pStdHeaderVersion = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (in_struct->pVideoProfile) pVideoProfile = new safe_VkVideoProfileInfoKHR(in_struct->pVideoProfile);
+
+    if (in_struct->pStdHeaderVersion) {
+        pStdHeaderVersion = new VkExtensionProperties(*in_struct->pStdHeaderVersion);
+    }
+}
+
+void safe_VkVideoSessionCreateInfoKHR::initialize(const safe_VkVideoSessionCreateInfoKHR* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    queueFamilyIndex = copy_src->queueFamilyIndex;
+    flags = copy_src->flags;
+    pVideoProfile = nullptr;
+    pictureFormat = copy_src->pictureFormat;
+    maxCodedExtent = copy_src->maxCodedExtent;
+    referencePictureFormat = copy_src->referencePictureFormat;
+    maxDpbSlots = copy_src->maxDpbSlots;
+    maxActiveReferencePictures = copy_src->maxActiveReferencePictures;
+    pStdHeaderVersion = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (copy_src->pVideoProfile) pVideoProfile = new safe_VkVideoProfileInfoKHR(*copy_src->pVideoProfile);
+
+    if (copy_src->pStdHeaderVersion) {
+        pStdHeaderVersion = new VkExtensionProperties(*copy_src->pStdHeaderVersion);
+    }
+}
+
+safe_VkVideoSessionParametersCreateInfoKHR::safe_VkVideoSessionParametersCreateInfoKHR(
+    const VkVideoSessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      videoSessionParametersTemplate(in_struct->videoSessionParametersTemplate),
+      videoSession(in_struct->videoSession) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoSessionParametersCreateInfoKHR::safe_VkVideoSessionParametersCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR),
+      pNext(nullptr),
+      flags(),
+      videoSessionParametersTemplate(),
+      videoSession() {}
+
+safe_VkVideoSessionParametersCreateInfoKHR::safe_VkVideoSessionParametersCreateInfoKHR(
+    const safe_VkVideoSessionParametersCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    videoSessionParametersTemplate = copy_src.videoSessionParametersTemplate;
+    videoSession = copy_src.videoSession;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoSessionParametersCreateInfoKHR& safe_VkVideoSessionParametersCreateInfoKHR::operator=(
+    const safe_VkVideoSessionParametersCreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    videoSessionParametersTemplate = copy_src.videoSessionParametersTemplate;
+    videoSession = copy_src.videoSession;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoSessionParametersCreateInfoKHR::~safe_VkVideoSessionParametersCreateInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoSessionParametersCreateInfoKHR::initialize(const VkVideoSessionParametersCreateInfoKHR* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    videoSessionParametersTemplate = in_struct->videoSessionParametersTemplate;
+    videoSession = in_struct->videoSession;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoSessionParametersCreateInfoKHR::initialize(const safe_VkVideoSessionParametersCreateInfoKHR* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    videoSessionParametersTemplate = copy_src->videoSessionParametersTemplate;
+    videoSession = copy_src->videoSession;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoSessionParametersUpdateInfoKHR::safe_VkVideoSessionParametersUpdateInfoKHR(
+    const VkVideoSessionParametersUpdateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), updateSequenceCount(in_struct->updateSequenceCount) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoSessionParametersUpdateInfoKHR::safe_VkVideoSessionParametersUpdateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR), pNext(nullptr), updateSequenceCount() {}
+
+safe_VkVideoSessionParametersUpdateInfoKHR::safe_VkVideoSessionParametersUpdateInfoKHR(
+    const safe_VkVideoSessionParametersUpdateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    updateSequenceCount = copy_src.updateSequenceCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoSessionParametersUpdateInfoKHR& safe_VkVideoSessionParametersUpdateInfoKHR::operator=(
+    const safe_VkVideoSessionParametersUpdateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    updateSequenceCount = copy_src.updateSequenceCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoSessionParametersUpdateInfoKHR::~safe_VkVideoSessionParametersUpdateInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoSessionParametersUpdateInfoKHR::initialize(const VkVideoSessionParametersUpdateInfoKHR* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    updateSequenceCount = in_struct->updateSequenceCount;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoSessionParametersUpdateInfoKHR::initialize(const safe_VkVideoSessionParametersUpdateInfoKHR* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    updateSequenceCount = copy_src->updateSequenceCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoBeginCodingInfoKHR::safe_VkVideoBeginCodingInfoKHR(const VkVideoBeginCodingInfoKHR* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      videoSession(in_struct->videoSession),
+      videoSessionParameters(in_struct->videoSessionParameters),
+      referenceSlotCount(in_struct->referenceSlotCount),
+      pReferenceSlots(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (referenceSlotCount && in_struct->pReferenceSlots) {
+        pReferenceSlots = new safe_VkVideoReferenceSlotInfoKHR[referenceSlotCount];
+        for (uint32_t i = 0; i < referenceSlotCount; ++i) {
+            pReferenceSlots[i].initialize(&in_struct->pReferenceSlots[i]);
+        }
+    }
+}
+
+safe_VkVideoBeginCodingInfoKHR::safe_VkVideoBeginCodingInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR),
+      pNext(nullptr),
+      flags(),
+      videoSession(),
+      videoSessionParameters(),
+      referenceSlotCount(),
+      pReferenceSlots(nullptr) {}
+
+safe_VkVideoBeginCodingInfoKHR::safe_VkVideoBeginCodingInfoKHR(const safe_VkVideoBeginCodingInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    videoSession = copy_src.videoSession;
+    videoSessionParameters = copy_src.videoSessionParameters;
+    referenceSlotCount = copy_src.referenceSlotCount;
+    pReferenceSlots = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (referenceSlotCount && copy_src.pReferenceSlots) {
+        pReferenceSlots = new safe_VkVideoReferenceSlotInfoKHR[referenceSlotCount];
+        for (uint32_t i = 0; i < referenceSlotCount; ++i) {
+            pReferenceSlots[i].initialize(&copy_src.pReferenceSlots[i]);
+        }
+    }
+}
+
+safe_VkVideoBeginCodingInfoKHR& safe_VkVideoBeginCodingInfoKHR::operator=(const safe_VkVideoBeginCodingInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pReferenceSlots) delete[] pReferenceSlots;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    videoSession = copy_src.videoSession;
+    videoSessionParameters = copy_src.videoSessionParameters;
+    referenceSlotCount = copy_src.referenceSlotCount;
+    pReferenceSlots = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (referenceSlotCount && copy_src.pReferenceSlots) {
+        pReferenceSlots = new safe_VkVideoReferenceSlotInfoKHR[referenceSlotCount];
+        for (uint32_t i = 0; i < referenceSlotCount; ++i) {
+            pReferenceSlots[i].initialize(&copy_src.pReferenceSlots[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkVideoBeginCodingInfoKHR::~safe_VkVideoBeginCodingInfoKHR() {
+    if (pReferenceSlots) delete[] pReferenceSlots;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoBeginCodingInfoKHR::initialize(const VkVideoBeginCodingInfoKHR* in_struct,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pReferenceSlots) delete[] pReferenceSlots;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    videoSession = in_struct->videoSession;
+    videoSessionParameters = in_struct->videoSessionParameters;
+    referenceSlotCount = in_struct->referenceSlotCount;
+    pReferenceSlots = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (referenceSlotCount && in_struct->pReferenceSlots) {
+        pReferenceSlots = new safe_VkVideoReferenceSlotInfoKHR[referenceSlotCount];
+        for (uint32_t i = 0; i < referenceSlotCount; ++i) {
+            pReferenceSlots[i].initialize(&in_struct->pReferenceSlots[i]);
+        }
+    }
+}
+
+void safe_VkVideoBeginCodingInfoKHR::initialize(const safe_VkVideoBeginCodingInfoKHR* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    videoSession = copy_src->videoSession;
+    videoSessionParameters = copy_src->videoSessionParameters;
+    referenceSlotCount = copy_src->referenceSlotCount;
+    pReferenceSlots = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (referenceSlotCount && copy_src->pReferenceSlots) {
+        pReferenceSlots = new safe_VkVideoReferenceSlotInfoKHR[referenceSlotCount];
+        for (uint32_t i = 0; i < referenceSlotCount; ++i) {
+            pReferenceSlots[i].initialize(&copy_src->pReferenceSlots[i]);
+        }
+    }
+}
+
+safe_VkVideoEndCodingInfoKHR::safe_VkVideoEndCodingInfoKHR(const VkVideoEndCodingInfoKHR* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEndCodingInfoKHR::safe_VkVideoEndCodingInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR), pNext(nullptr), flags() {}
+
+safe_VkVideoEndCodingInfoKHR::safe_VkVideoEndCodingInfoKHR(const safe_VkVideoEndCodingInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEndCodingInfoKHR& safe_VkVideoEndCodingInfoKHR::operator=(const safe_VkVideoEndCodingInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEndCodingInfoKHR::~safe_VkVideoEndCodingInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEndCodingInfoKHR::initialize(const VkVideoEndCodingInfoKHR* in_struct,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEndCodingInfoKHR::initialize(const safe_VkVideoEndCodingInfoKHR* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoCodingControlInfoKHR::safe_VkVideoCodingControlInfoKHR(const VkVideoCodingControlInfoKHR* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoCodingControlInfoKHR::safe_VkVideoCodingControlInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR), pNext(nullptr), flags() {}
+
+safe_VkVideoCodingControlInfoKHR::safe_VkVideoCodingControlInfoKHR(const safe_VkVideoCodingControlInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoCodingControlInfoKHR& safe_VkVideoCodingControlInfoKHR::operator=(const safe_VkVideoCodingControlInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoCodingControlInfoKHR::~safe_VkVideoCodingControlInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoCodingControlInfoKHR::initialize(const VkVideoCodingControlInfoKHR* in_struct,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoCodingControlInfoKHR::initialize(const safe_VkVideoCodingControlInfoKHR* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoDecodeCapabilitiesKHR::safe_VkVideoDecodeCapabilitiesKHR(const VkVideoDecodeCapabilitiesKHR* in_struct,
+                                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoDecodeCapabilitiesKHR::safe_VkVideoDecodeCapabilitiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR), pNext(nullptr), flags() {}
+
+safe_VkVideoDecodeCapabilitiesKHR::safe_VkVideoDecodeCapabilitiesKHR(const safe_VkVideoDecodeCapabilitiesKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoDecodeCapabilitiesKHR& safe_VkVideoDecodeCapabilitiesKHR::operator=(const safe_VkVideoDecodeCapabilitiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoDecodeCapabilitiesKHR::~safe_VkVideoDecodeCapabilitiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoDecodeCapabilitiesKHR::initialize(const VkVideoDecodeCapabilitiesKHR* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoDecodeCapabilitiesKHR::initialize(const safe_VkVideoDecodeCapabilitiesKHR* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoDecodeUsageInfoKHR::safe_VkVideoDecodeUsageInfoKHR(const VkVideoDecodeUsageInfoKHR* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), videoUsageHints(in_struct->videoUsageHints) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoDecodeUsageInfoKHR::safe_VkVideoDecodeUsageInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR), pNext(nullptr), videoUsageHints() {}
+
+safe_VkVideoDecodeUsageInfoKHR::safe_VkVideoDecodeUsageInfoKHR(const safe_VkVideoDecodeUsageInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    videoUsageHints = copy_src.videoUsageHints;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoDecodeUsageInfoKHR& safe_VkVideoDecodeUsageInfoKHR::operator=(const safe_VkVideoDecodeUsageInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    videoUsageHints = copy_src.videoUsageHints;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoDecodeUsageInfoKHR::~safe_VkVideoDecodeUsageInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoDecodeUsageInfoKHR::initialize(const VkVideoDecodeUsageInfoKHR* in_struct,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    videoUsageHints = in_struct->videoUsageHints;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoDecodeUsageInfoKHR::initialize(const safe_VkVideoDecodeUsageInfoKHR* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    videoUsageHints = copy_src->videoUsageHints;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoDecodeInfoKHR::safe_VkVideoDecodeInfoKHR(const VkVideoDecodeInfoKHR* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      srcBuffer(in_struct->srcBuffer),
+      srcBufferOffset(in_struct->srcBufferOffset),
+      srcBufferRange(in_struct->srcBufferRange),
+      dstPictureResource(&in_struct->dstPictureResource),
+      pSetupReferenceSlot(nullptr),
+      referenceSlotCount(in_struct->referenceSlotCount),
+      pReferenceSlots(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pSetupReferenceSlot) pSetupReferenceSlot = new safe_VkVideoReferenceSlotInfoKHR(in_struct->pSetupReferenceSlot);
+    if (referenceSlotCount && in_struct->pReferenceSlots) {
+        pReferenceSlots = new safe_VkVideoReferenceSlotInfoKHR[referenceSlotCount];
+        for (uint32_t i = 0; i < referenceSlotCount; ++i) {
+            pReferenceSlots[i].initialize(&in_struct->pReferenceSlots[i]);
+        }
+    }
+}
+
+safe_VkVideoDecodeInfoKHR::safe_VkVideoDecodeInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR),
+      pNext(nullptr),
+      flags(),
+      srcBuffer(),
+      srcBufferOffset(),
+      srcBufferRange(),
+      pSetupReferenceSlot(nullptr),
+      referenceSlotCount(),
+      pReferenceSlots(nullptr) {}
+
+safe_VkVideoDecodeInfoKHR::safe_VkVideoDecodeInfoKHR(const safe_VkVideoDecodeInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    srcBuffer = copy_src.srcBuffer;
+    srcBufferOffset = copy_src.srcBufferOffset;
+    srcBufferRange = copy_src.srcBufferRange;
+    dstPictureResource.initialize(&copy_src.dstPictureResource);
+    pSetupReferenceSlot = nullptr;
+    referenceSlotCount = copy_src.referenceSlotCount;
+    pReferenceSlots = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pSetupReferenceSlot) pSetupReferenceSlot = new safe_VkVideoReferenceSlotInfoKHR(*copy_src.pSetupReferenceSlot);
+    if (referenceSlotCount && copy_src.pReferenceSlots) {
+        pReferenceSlots = new safe_VkVideoReferenceSlotInfoKHR[referenceSlotCount];
+        for (uint32_t i = 0; i < referenceSlotCount; ++i) {
+            pReferenceSlots[i].initialize(&copy_src.pReferenceSlots[i]);
+        }
+    }
+}
+
+safe_VkVideoDecodeInfoKHR& safe_VkVideoDecodeInfoKHR::operator=(const safe_VkVideoDecodeInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pSetupReferenceSlot) delete pSetupReferenceSlot;
+    if (pReferenceSlots) delete[] pReferenceSlots;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    srcBuffer = copy_src.srcBuffer;
+    srcBufferOffset = copy_src.srcBufferOffset;
+    srcBufferRange = copy_src.srcBufferRange;
+    dstPictureResource.initialize(&copy_src.dstPictureResource);
+    pSetupReferenceSlot = nullptr;
+    referenceSlotCount = copy_src.referenceSlotCount;
+    pReferenceSlots = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pSetupReferenceSlot) pSetupReferenceSlot = new safe_VkVideoReferenceSlotInfoKHR(*copy_src.pSetupReferenceSlot);
+    if (referenceSlotCount && copy_src.pReferenceSlots) {
+        pReferenceSlots = new safe_VkVideoReferenceSlotInfoKHR[referenceSlotCount];
+        for (uint32_t i = 0; i < referenceSlotCount; ++i) {
+            pReferenceSlots[i].initialize(&copy_src.pReferenceSlots[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkVideoDecodeInfoKHR::~safe_VkVideoDecodeInfoKHR() {
+    if (pSetupReferenceSlot) delete pSetupReferenceSlot;
+    if (pReferenceSlots) delete[] pReferenceSlots;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoDecodeInfoKHR::initialize(const VkVideoDecodeInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pSetupReferenceSlot) delete pSetupReferenceSlot;
+    if (pReferenceSlots) delete[] pReferenceSlots;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    srcBuffer = in_struct->srcBuffer;
+    srcBufferOffset = in_struct->srcBufferOffset;
+    srcBufferRange = in_struct->srcBufferRange;
+    dstPictureResource.initialize(&in_struct->dstPictureResource);
+    pSetupReferenceSlot = nullptr;
+    referenceSlotCount = in_struct->referenceSlotCount;
+    pReferenceSlots = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (in_struct->pSetupReferenceSlot) pSetupReferenceSlot = new safe_VkVideoReferenceSlotInfoKHR(in_struct->pSetupReferenceSlot);
+    if (referenceSlotCount && in_struct->pReferenceSlots) {
+        pReferenceSlots = new safe_VkVideoReferenceSlotInfoKHR[referenceSlotCount];
+        for (uint32_t i = 0; i < referenceSlotCount; ++i) {
+            pReferenceSlots[i].initialize(&in_struct->pReferenceSlots[i]);
+        }
+    }
+}
+
+void safe_VkVideoDecodeInfoKHR::initialize(const safe_VkVideoDecodeInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    srcBuffer = copy_src->srcBuffer;
+    srcBufferOffset = copy_src->srcBufferOffset;
+    srcBufferRange = copy_src->srcBufferRange;
+    dstPictureResource.initialize(&copy_src->dstPictureResource);
+    pSetupReferenceSlot = nullptr;
+    referenceSlotCount = copy_src->referenceSlotCount;
+    pReferenceSlots = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (copy_src->pSetupReferenceSlot) pSetupReferenceSlot = new safe_VkVideoReferenceSlotInfoKHR(*copy_src->pSetupReferenceSlot);
+    if (referenceSlotCount && copy_src->pReferenceSlots) {
+        pReferenceSlots = new safe_VkVideoReferenceSlotInfoKHR[referenceSlotCount];
+        for (uint32_t i = 0; i < referenceSlotCount; ++i) {
+            pReferenceSlots[i].initialize(&copy_src->pReferenceSlots[i]);
+        }
+    }
+}
+
+safe_VkVideoEncodeH264CapabilitiesKHR::safe_VkVideoEncodeH264CapabilitiesKHR(const VkVideoEncodeH264CapabilitiesKHR* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      maxLevelIdc(in_struct->maxLevelIdc),
+      maxSliceCount(in_struct->maxSliceCount),
+      maxPPictureL0ReferenceCount(in_struct->maxPPictureL0ReferenceCount),
+      maxBPictureL0ReferenceCount(in_struct->maxBPictureL0ReferenceCount),
+      maxL1ReferenceCount(in_struct->maxL1ReferenceCount),
+      maxTemporalLayerCount(in_struct->maxTemporalLayerCount),
+      expectDyadicTemporalLayerPattern(in_struct->expectDyadicTemporalLayerPattern),
+      minQp(in_struct->minQp),
+      maxQp(in_struct->maxQp),
+      prefersGopRemainingFrames(in_struct->prefersGopRemainingFrames),
+      requiresGopRemainingFrames(in_struct->requiresGopRemainingFrames),
+      stdSyntaxFlags(in_struct->stdSyntaxFlags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeH264CapabilitiesKHR::safe_VkVideoEncodeH264CapabilitiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR),
+      pNext(nullptr),
+      flags(),
+      maxLevelIdc(),
+      maxSliceCount(),
+      maxPPictureL0ReferenceCount(),
+      maxBPictureL0ReferenceCount(),
+      maxL1ReferenceCount(),
+      maxTemporalLayerCount(),
+      expectDyadicTemporalLayerPattern(),
+      minQp(),
+      maxQp(),
+      prefersGopRemainingFrames(),
+      requiresGopRemainingFrames(),
+      stdSyntaxFlags() {}
+
+safe_VkVideoEncodeH264CapabilitiesKHR::safe_VkVideoEncodeH264CapabilitiesKHR(
+    const safe_VkVideoEncodeH264CapabilitiesKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    maxLevelIdc = copy_src.maxLevelIdc;
+    maxSliceCount = copy_src.maxSliceCount;
+    maxPPictureL0ReferenceCount = copy_src.maxPPictureL0ReferenceCount;
+    maxBPictureL0ReferenceCount = copy_src.maxBPictureL0ReferenceCount;
+    maxL1ReferenceCount = copy_src.maxL1ReferenceCount;
+    maxTemporalLayerCount = copy_src.maxTemporalLayerCount;
+    expectDyadicTemporalLayerPattern = copy_src.expectDyadicTemporalLayerPattern;
+    minQp = copy_src.minQp;
+    maxQp = copy_src.maxQp;
+    prefersGopRemainingFrames = copy_src.prefersGopRemainingFrames;
+    requiresGopRemainingFrames = copy_src.requiresGopRemainingFrames;
+    stdSyntaxFlags = copy_src.stdSyntaxFlags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeH264CapabilitiesKHR& safe_VkVideoEncodeH264CapabilitiesKHR::operator=(
+    const safe_VkVideoEncodeH264CapabilitiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    maxLevelIdc = copy_src.maxLevelIdc;
+    maxSliceCount = copy_src.maxSliceCount;
+    maxPPictureL0ReferenceCount = copy_src.maxPPictureL0ReferenceCount;
+    maxBPictureL0ReferenceCount = copy_src.maxBPictureL0ReferenceCount;
+    maxL1ReferenceCount = copy_src.maxL1ReferenceCount;
+    maxTemporalLayerCount = copy_src.maxTemporalLayerCount;
+    expectDyadicTemporalLayerPattern = copy_src.expectDyadicTemporalLayerPattern;
+    minQp = copy_src.minQp;
+    maxQp = copy_src.maxQp;
+    prefersGopRemainingFrames = copy_src.prefersGopRemainingFrames;
+    requiresGopRemainingFrames = copy_src.requiresGopRemainingFrames;
+    stdSyntaxFlags = copy_src.stdSyntaxFlags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeH264CapabilitiesKHR::~safe_VkVideoEncodeH264CapabilitiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeH264CapabilitiesKHR::initialize(const VkVideoEncodeH264CapabilitiesKHR* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    maxLevelIdc = in_struct->maxLevelIdc;
+    maxSliceCount = in_struct->maxSliceCount;
+    maxPPictureL0ReferenceCount = in_struct->maxPPictureL0ReferenceCount;
+    maxBPictureL0ReferenceCount = in_struct->maxBPictureL0ReferenceCount;
+    maxL1ReferenceCount = in_struct->maxL1ReferenceCount;
+    maxTemporalLayerCount = in_struct->maxTemporalLayerCount;
+    expectDyadicTemporalLayerPattern = in_struct->expectDyadicTemporalLayerPattern;
+    minQp = in_struct->minQp;
+    maxQp = in_struct->maxQp;
+    prefersGopRemainingFrames = in_struct->prefersGopRemainingFrames;
+    requiresGopRemainingFrames = in_struct->requiresGopRemainingFrames;
+    stdSyntaxFlags = in_struct->stdSyntaxFlags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeH264CapabilitiesKHR::initialize(const safe_VkVideoEncodeH264CapabilitiesKHR* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    maxLevelIdc = copy_src->maxLevelIdc;
+    maxSliceCount = copy_src->maxSliceCount;
+    maxPPictureL0ReferenceCount = copy_src->maxPPictureL0ReferenceCount;
+    maxBPictureL0ReferenceCount = copy_src->maxBPictureL0ReferenceCount;
+    maxL1ReferenceCount = copy_src->maxL1ReferenceCount;
+    maxTemporalLayerCount = copy_src->maxTemporalLayerCount;
+    expectDyadicTemporalLayerPattern = copy_src->expectDyadicTemporalLayerPattern;
+    minQp = copy_src->minQp;
+    maxQp = copy_src->maxQp;
+    prefersGopRemainingFrames = copy_src->prefersGopRemainingFrames;
+    requiresGopRemainingFrames = copy_src->requiresGopRemainingFrames;
+    stdSyntaxFlags = copy_src->stdSyntaxFlags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeH264QualityLevelPropertiesKHR::safe_VkVideoEncodeH264QualityLevelPropertiesKHR(
+    const VkVideoEncodeH264QualityLevelPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      preferredRateControlFlags(in_struct->preferredRateControlFlags),
+      preferredGopFrameCount(in_struct->preferredGopFrameCount),
+      preferredIdrPeriod(in_struct->preferredIdrPeriod),
+      preferredConsecutiveBFrameCount(in_struct->preferredConsecutiveBFrameCount),
+      preferredTemporalLayerCount(in_struct->preferredTemporalLayerCount),
+      preferredConstantQp(in_struct->preferredConstantQp),
+      preferredMaxL0ReferenceCount(in_struct->preferredMaxL0ReferenceCount),
+      preferredMaxL1ReferenceCount(in_struct->preferredMaxL1ReferenceCount),
+      preferredStdEntropyCodingModeFlag(in_struct->preferredStdEntropyCodingModeFlag) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeH264QualityLevelPropertiesKHR::safe_VkVideoEncodeH264QualityLevelPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR),
+      pNext(nullptr),
+      preferredRateControlFlags(),
+      preferredGopFrameCount(),
+      preferredIdrPeriod(),
+      preferredConsecutiveBFrameCount(),
+      preferredTemporalLayerCount(),
+      preferredConstantQp(),
+      preferredMaxL0ReferenceCount(),
+      preferredMaxL1ReferenceCount(),
+      preferredStdEntropyCodingModeFlag() {}
+
+safe_VkVideoEncodeH264QualityLevelPropertiesKHR::safe_VkVideoEncodeH264QualityLevelPropertiesKHR(
+    const safe_VkVideoEncodeH264QualityLevelPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    preferredRateControlFlags = copy_src.preferredRateControlFlags;
+    preferredGopFrameCount = copy_src.preferredGopFrameCount;
+    preferredIdrPeriod = copy_src.preferredIdrPeriod;
+    preferredConsecutiveBFrameCount = copy_src.preferredConsecutiveBFrameCount;
+    preferredTemporalLayerCount = copy_src.preferredTemporalLayerCount;
+    preferredConstantQp = copy_src.preferredConstantQp;
+    preferredMaxL0ReferenceCount = copy_src.preferredMaxL0ReferenceCount;
+    preferredMaxL1ReferenceCount = copy_src.preferredMaxL1ReferenceCount;
+    preferredStdEntropyCodingModeFlag = copy_src.preferredStdEntropyCodingModeFlag;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeH264QualityLevelPropertiesKHR& safe_VkVideoEncodeH264QualityLevelPropertiesKHR::operator=(
+    const safe_VkVideoEncodeH264QualityLevelPropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    preferredRateControlFlags = copy_src.preferredRateControlFlags;
+    preferredGopFrameCount = copy_src.preferredGopFrameCount;
+    preferredIdrPeriod = copy_src.preferredIdrPeriod;
+    preferredConsecutiveBFrameCount = copy_src.preferredConsecutiveBFrameCount;
+    preferredTemporalLayerCount = copy_src.preferredTemporalLayerCount;
+    preferredConstantQp = copy_src.preferredConstantQp;
+    preferredMaxL0ReferenceCount = copy_src.preferredMaxL0ReferenceCount;
+    preferredMaxL1ReferenceCount = copy_src.preferredMaxL1ReferenceCount;
+    preferredStdEntropyCodingModeFlag = copy_src.preferredStdEntropyCodingModeFlag;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeH264QualityLevelPropertiesKHR::~safe_VkVideoEncodeH264QualityLevelPropertiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeH264QualityLevelPropertiesKHR::initialize(const VkVideoEncodeH264QualityLevelPropertiesKHR* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    preferredRateControlFlags = in_struct->preferredRateControlFlags;
+    preferredGopFrameCount = in_struct->preferredGopFrameCount;
+    preferredIdrPeriod = in_struct->preferredIdrPeriod;
+    preferredConsecutiveBFrameCount = in_struct->preferredConsecutiveBFrameCount;
+    preferredTemporalLayerCount = in_struct->preferredTemporalLayerCount;
+    preferredConstantQp = in_struct->preferredConstantQp;
+    preferredMaxL0ReferenceCount = in_struct->preferredMaxL0ReferenceCount;
+    preferredMaxL1ReferenceCount = in_struct->preferredMaxL1ReferenceCount;
+    preferredStdEntropyCodingModeFlag = in_struct->preferredStdEntropyCodingModeFlag;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeH264QualityLevelPropertiesKHR::initialize(const safe_VkVideoEncodeH264QualityLevelPropertiesKHR* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    preferredRateControlFlags = copy_src->preferredRateControlFlags;
+    preferredGopFrameCount = copy_src->preferredGopFrameCount;
+    preferredIdrPeriod = copy_src->preferredIdrPeriod;
+    preferredConsecutiveBFrameCount = copy_src->preferredConsecutiveBFrameCount;
+    preferredTemporalLayerCount = copy_src->preferredTemporalLayerCount;
+    preferredConstantQp = copy_src->preferredConstantQp;
+    preferredMaxL0ReferenceCount = copy_src->preferredMaxL0ReferenceCount;
+    preferredMaxL1ReferenceCount = copy_src->preferredMaxL1ReferenceCount;
+    preferredStdEntropyCodingModeFlag = copy_src->preferredStdEntropyCodingModeFlag;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeH264SessionCreateInfoKHR::safe_VkVideoEncodeH264SessionCreateInfoKHR(
+    const VkVideoEncodeH264SessionCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), useMaxLevelIdc(in_struct->useMaxLevelIdc), maxLevelIdc(in_struct->maxLevelIdc) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeH264SessionCreateInfoKHR::safe_VkVideoEncodeH264SessionCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR), pNext(nullptr), useMaxLevelIdc(), maxLevelIdc() {}
+
+safe_VkVideoEncodeH264SessionCreateInfoKHR::safe_VkVideoEncodeH264SessionCreateInfoKHR(
+    const safe_VkVideoEncodeH264SessionCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    useMaxLevelIdc = copy_src.useMaxLevelIdc;
+    maxLevelIdc = copy_src.maxLevelIdc;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeH264SessionCreateInfoKHR& safe_VkVideoEncodeH264SessionCreateInfoKHR::operator=(
+    const safe_VkVideoEncodeH264SessionCreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    useMaxLevelIdc = copy_src.useMaxLevelIdc;
+    maxLevelIdc = copy_src.maxLevelIdc;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeH264SessionCreateInfoKHR::~safe_VkVideoEncodeH264SessionCreateInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeH264SessionCreateInfoKHR::initialize(const VkVideoEncodeH264SessionCreateInfoKHR* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    useMaxLevelIdc = in_struct->useMaxLevelIdc;
+    maxLevelIdc = in_struct->maxLevelIdc;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeH264SessionCreateInfoKHR::initialize(const safe_VkVideoEncodeH264SessionCreateInfoKHR* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    useMaxLevelIdc = copy_src->useMaxLevelIdc;
+    maxLevelIdc = copy_src->maxLevelIdc;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeH264SessionParametersAddInfoKHR::safe_VkVideoEncodeH264SessionParametersAddInfoKHR(
+    const VkVideoEncodeH264SessionParametersAddInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      stdSPSCount(in_struct->stdSPSCount),
+      pStdSPSs(nullptr),
+      stdPPSCount(in_struct->stdPPSCount),
+      pStdPPSs(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pStdSPSs) {
+        pStdSPSs = new StdVideoH264SequenceParameterSet[in_struct->stdSPSCount];
+        memcpy((void*)pStdSPSs, (void*)in_struct->pStdSPSs, sizeof(StdVideoH264SequenceParameterSet) * in_struct->stdSPSCount);
+    }
+
+    if (in_struct->pStdPPSs) {
+        pStdPPSs = new StdVideoH264PictureParameterSet[in_struct->stdPPSCount];
+        memcpy((void*)pStdPPSs, (void*)in_struct->pStdPPSs, sizeof(StdVideoH264PictureParameterSet) * in_struct->stdPPSCount);
+    }
+}
+
+safe_VkVideoEncodeH264SessionParametersAddInfoKHR::safe_VkVideoEncodeH264SessionParametersAddInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR),
+      pNext(nullptr),
+      stdSPSCount(),
+      pStdSPSs(nullptr),
+      stdPPSCount(),
+      pStdPPSs(nullptr) {}
+
+safe_VkVideoEncodeH264SessionParametersAddInfoKHR::safe_VkVideoEncodeH264SessionParametersAddInfoKHR(
+    const safe_VkVideoEncodeH264SessionParametersAddInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    stdSPSCount = copy_src.stdSPSCount;
+    pStdSPSs = nullptr;
+    stdPPSCount = copy_src.stdPPSCount;
+    pStdPPSs = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdSPSs) {
+        pStdSPSs = new StdVideoH264SequenceParameterSet[copy_src.stdSPSCount];
+        memcpy((void*)pStdSPSs, (void*)copy_src.pStdSPSs, sizeof(StdVideoH264SequenceParameterSet) * copy_src.stdSPSCount);
+    }
+
+    if (copy_src.pStdPPSs) {
+        pStdPPSs = new StdVideoH264PictureParameterSet[copy_src.stdPPSCount];
+        memcpy((void*)pStdPPSs, (void*)copy_src.pStdPPSs, sizeof(StdVideoH264PictureParameterSet) * copy_src.stdPPSCount);
+    }
+}
+
+safe_VkVideoEncodeH264SessionParametersAddInfoKHR& safe_VkVideoEncodeH264SessionParametersAddInfoKHR::operator=(
+    const safe_VkVideoEncodeH264SessionParametersAddInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pStdSPSs) delete[] pStdSPSs;
+    if (pStdPPSs) delete[] pStdPPSs;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    stdSPSCount = copy_src.stdSPSCount;
+    pStdSPSs = nullptr;
+    stdPPSCount = copy_src.stdPPSCount;
+    pStdPPSs = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdSPSs) {
+        pStdSPSs = new StdVideoH264SequenceParameterSet[copy_src.stdSPSCount];
+        memcpy((void*)pStdSPSs, (void*)copy_src.pStdSPSs, sizeof(StdVideoH264SequenceParameterSet) * copy_src.stdSPSCount);
+    }
+
+    if (copy_src.pStdPPSs) {
+        pStdPPSs = new StdVideoH264PictureParameterSet[copy_src.stdPPSCount];
+        memcpy((void*)pStdPPSs, (void*)copy_src.pStdPPSs, sizeof(StdVideoH264PictureParameterSet) * copy_src.stdPPSCount);
+    }
+
+    return *this;
+}
+
+safe_VkVideoEncodeH264SessionParametersAddInfoKHR::~safe_VkVideoEncodeH264SessionParametersAddInfoKHR() {
+    if (pStdSPSs) delete[] pStdSPSs;
+    if (pStdPPSs) delete[] pStdPPSs;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoEncodeH264SessionParametersAddInfoKHR::initialize(const VkVideoEncodeH264SessionParametersAddInfoKHR* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pStdSPSs) delete[] pStdSPSs;
+    if (pStdPPSs) delete[] pStdPPSs;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    stdSPSCount = in_struct->stdSPSCount;
+    pStdSPSs = nullptr;
+    stdPPSCount = in_struct->stdPPSCount;
+    pStdPPSs = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pStdSPSs) {
+        pStdSPSs = new StdVideoH264SequenceParameterSet[in_struct->stdSPSCount];
+        memcpy((void*)pStdSPSs, (void*)in_struct->pStdSPSs, sizeof(StdVideoH264SequenceParameterSet) * in_struct->stdSPSCount);
+    }
+
+    if (in_struct->pStdPPSs) {
+        pStdPPSs = new StdVideoH264PictureParameterSet[in_struct->stdPPSCount];
+        memcpy((void*)pStdPPSs, (void*)in_struct->pStdPPSs, sizeof(StdVideoH264PictureParameterSet) * in_struct->stdPPSCount);
+    }
+}
+
+void safe_VkVideoEncodeH264SessionParametersAddInfoKHR::initialize(
+    const safe_VkVideoEncodeH264SessionParametersAddInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stdSPSCount = copy_src->stdSPSCount;
+    pStdSPSs = nullptr;
+    stdPPSCount = copy_src->stdPPSCount;
+    pStdPPSs = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pStdSPSs) {
+        pStdSPSs = new StdVideoH264SequenceParameterSet[copy_src->stdSPSCount];
+        memcpy((void*)pStdSPSs, (void*)copy_src->pStdSPSs, sizeof(StdVideoH264SequenceParameterSet) * copy_src->stdSPSCount);
+    }
+
+    if (copy_src->pStdPPSs) {
+        pStdPPSs = new StdVideoH264PictureParameterSet[copy_src->stdPPSCount];
+        memcpy((void*)pStdPPSs, (void*)copy_src->pStdPPSs, sizeof(StdVideoH264PictureParameterSet) * copy_src->stdPPSCount);
+    }
+}
+
+safe_VkVideoEncodeH264SessionParametersCreateInfoKHR::safe_VkVideoEncodeH264SessionParametersCreateInfoKHR(
+    const VkVideoEncodeH264SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      maxStdSPSCount(in_struct->maxStdSPSCount),
+      maxStdPPSCount(in_struct->maxStdPPSCount),
+      pParametersAddInfo(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pParametersAddInfo)
+        pParametersAddInfo = new safe_VkVideoEncodeH264SessionParametersAddInfoKHR(in_struct->pParametersAddInfo);
+}
+
+safe_VkVideoEncodeH264SessionParametersCreateInfoKHR::safe_VkVideoEncodeH264SessionParametersCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR),
+      pNext(nullptr),
+      maxStdSPSCount(),
+      maxStdPPSCount(),
+      pParametersAddInfo(nullptr) {}
+
+safe_VkVideoEncodeH264SessionParametersCreateInfoKHR::safe_VkVideoEncodeH264SessionParametersCreateInfoKHR(
+    const safe_VkVideoEncodeH264SessionParametersCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    maxStdSPSCount = copy_src.maxStdSPSCount;
+    maxStdPPSCount = copy_src.maxStdPPSCount;
+    pParametersAddInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pParametersAddInfo)
+        pParametersAddInfo = new safe_VkVideoEncodeH264SessionParametersAddInfoKHR(*copy_src.pParametersAddInfo);
+}
+
+safe_VkVideoEncodeH264SessionParametersCreateInfoKHR& safe_VkVideoEncodeH264SessionParametersCreateInfoKHR::operator=(
+    const safe_VkVideoEncodeH264SessionParametersCreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pParametersAddInfo) delete pParametersAddInfo;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxStdSPSCount = copy_src.maxStdSPSCount;
+    maxStdPPSCount = copy_src.maxStdPPSCount;
+    pParametersAddInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pParametersAddInfo)
+        pParametersAddInfo = new safe_VkVideoEncodeH264SessionParametersAddInfoKHR(*copy_src.pParametersAddInfo);
+
+    return *this;
+}
+
+safe_VkVideoEncodeH264SessionParametersCreateInfoKHR::~safe_VkVideoEncodeH264SessionParametersCreateInfoKHR() {
+    if (pParametersAddInfo) delete pParametersAddInfo;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoEncodeH264SessionParametersCreateInfoKHR::initialize(
+    const VkVideoEncodeH264SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pParametersAddInfo) delete pParametersAddInfo;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxStdSPSCount = in_struct->maxStdSPSCount;
+    maxStdPPSCount = in_struct->maxStdPPSCount;
+    pParametersAddInfo = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (in_struct->pParametersAddInfo)
+        pParametersAddInfo = new safe_VkVideoEncodeH264SessionParametersAddInfoKHR(in_struct->pParametersAddInfo);
+}
+
+void safe_VkVideoEncodeH264SessionParametersCreateInfoKHR::initialize(
+    const safe_VkVideoEncodeH264SessionParametersCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxStdSPSCount = copy_src->maxStdSPSCount;
+    maxStdPPSCount = copy_src->maxStdPPSCount;
+    pParametersAddInfo = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (copy_src->pParametersAddInfo)
+        pParametersAddInfo = new safe_VkVideoEncodeH264SessionParametersAddInfoKHR(*copy_src->pParametersAddInfo);
+}
+
+safe_VkVideoEncodeH264SessionParametersGetInfoKHR::safe_VkVideoEncodeH264SessionParametersGetInfoKHR(
+    const VkVideoEncodeH264SessionParametersGetInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      writeStdSPS(in_struct->writeStdSPS),
+      writeStdPPS(in_struct->writeStdPPS),
+      stdSPSId(in_struct->stdSPSId),
+      stdPPSId(in_struct->stdPPSId) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeH264SessionParametersGetInfoKHR::safe_VkVideoEncodeH264SessionParametersGetInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR),
+      pNext(nullptr),
+      writeStdSPS(),
+      writeStdPPS(),
+      stdSPSId(),
+      stdPPSId() {}
+
+safe_VkVideoEncodeH264SessionParametersGetInfoKHR::safe_VkVideoEncodeH264SessionParametersGetInfoKHR(
+    const safe_VkVideoEncodeH264SessionParametersGetInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    writeStdSPS = copy_src.writeStdSPS;
+    writeStdPPS = copy_src.writeStdPPS;
+    stdSPSId = copy_src.stdSPSId;
+    stdPPSId = copy_src.stdPPSId;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeH264SessionParametersGetInfoKHR& safe_VkVideoEncodeH264SessionParametersGetInfoKHR::operator=(
+    const safe_VkVideoEncodeH264SessionParametersGetInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    writeStdSPS = copy_src.writeStdSPS;
+    writeStdPPS = copy_src.writeStdPPS;
+    stdSPSId = copy_src.stdSPSId;
+    stdPPSId = copy_src.stdPPSId;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeH264SessionParametersGetInfoKHR::~safe_VkVideoEncodeH264SessionParametersGetInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeH264SessionParametersGetInfoKHR::initialize(const VkVideoEncodeH264SessionParametersGetInfoKHR* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    writeStdSPS = in_struct->writeStdSPS;
+    writeStdPPS = in_struct->writeStdPPS;
+    stdSPSId = in_struct->stdSPSId;
+    stdPPSId = in_struct->stdPPSId;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeH264SessionParametersGetInfoKHR::initialize(
+    const safe_VkVideoEncodeH264SessionParametersGetInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    writeStdSPS = copy_src->writeStdSPS;
+    writeStdPPS = copy_src->writeStdPPS;
+    stdSPSId = copy_src->stdSPSId;
+    stdPPSId = copy_src->stdPPSId;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR::safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR(
+    const VkVideoEncodeH264SessionParametersFeedbackInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      hasStdSPSOverrides(in_struct->hasStdSPSOverrides),
+      hasStdPPSOverrides(in_struct->hasStdPPSOverrides) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR::safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR),
+      pNext(nullptr),
+      hasStdSPSOverrides(),
+      hasStdPPSOverrides() {}
+
+safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR::safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR(
+    const safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    hasStdSPSOverrides = copy_src.hasStdSPSOverrides;
+    hasStdPPSOverrides = copy_src.hasStdPPSOverrides;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR& safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR::operator=(
+    const safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    hasStdSPSOverrides = copy_src.hasStdSPSOverrides;
+    hasStdPPSOverrides = copy_src.hasStdPPSOverrides;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR::~safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR::initialize(
+    const VkVideoEncodeH264SessionParametersFeedbackInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    hasStdSPSOverrides = in_struct->hasStdSPSOverrides;
+    hasStdPPSOverrides = in_struct->hasStdPPSOverrides;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR::initialize(
+    const safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    hasStdSPSOverrides = copy_src->hasStdSPSOverrides;
+    hasStdPPSOverrides = copy_src->hasStdPPSOverrides;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeH264NaluSliceInfoKHR::safe_VkVideoEncodeH264NaluSliceInfoKHR(const VkVideoEncodeH264NaluSliceInfoKHR* in_struct,
+                                                                               [[maybe_unused]] PNextCopyState* copy_state,
+                                                                               bool copy_pnext)
+    : sType(in_struct->sType), constantQp(in_struct->constantQp), pStdSliceHeader(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pStdSliceHeader) {
+        pStdSliceHeader = new StdVideoEncodeH264SliceHeader(*in_struct->pStdSliceHeader);
+    }
+}
+
+safe_VkVideoEncodeH264NaluSliceInfoKHR::safe_VkVideoEncodeH264NaluSliceInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR), pNext(nullptr), constantQp(), pStdSliceHeader(nullptr) {}
+
+safe_VkVideoEncodeH264NaluSliceInfoKHR::safe_VkVideoEncodeH264NaluSliceInfoKHR(
+    const safe_VkVideoEncodeH264NaluSliceInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    constantQp = copy_src.constantQp;
+    pStdSliceHeader = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdSliceHeader) {
+        pStdSliceHeader = new StdVideoEncodeH264SliceHeader(*copy_src.pStdSliceHeader);
+    }
+}
+
+safe_VkVideoEncodeH264NaluSliceInfoKHR& safe_VkVideoEncodeH264NaluSliceInfoKHR::operator=(
+    const safe_VkVideoEncodeH264NaluSliceInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pStdSliceHeader) delete pStdSliceHeader;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    constantQp = copy_src.constantQp;
+    pStdSliceHeader = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdSliceHeader) {
+        pStdSliceHeader = new StdVideoEncodeH264SliceHeader(*copy_src.pStdSliceHeader);
+    }
+
+    return *this;
+}
+
+safe_VkVideoEncodeH264NaluSliceInfoKHR::~safe_VkVideoEncodeH264NaluSliceInfoKHR() {
+    if (pStdSliceHeader) delete pStdSliceHeader;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoEncodeH264NaluSliceInfoKHR::initialize(const VkVideoEncodeH264NaluSliceInfoKHR* in_struct,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pStdSliceHeader) delete pStdSliceHeader;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    constantQp = in_struct->constantQp;
+    pStdSliceHeader = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pStdSliceHeader) {
+        pStdSliceHeader = new StdVideoEncodeH264SliceHeader(*in_struct->pStdSliceHeader);
+    }
+}
+
+void safe_VkVideoEncodeH264NaluSliceInfoKHR::initialize(const safe_VkVideoEncodeH264NaluSliceInfoKHR* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    constantQp = copy_src->constantQp;
+    pStdSliceHeader = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pStdSliceHeader) {
+        pStdSliceHeader = new StdVideoEncodeH264SliceHeader(*copy_src->pStdSliceHeader);
+    }
+}
+
+safe_VkVideoEncodeH264PictureInfoKHR::safe_VkVideoEncodeH264PictureInfoKHR(const VkVideoEncodeH264PictureInfoKHR* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType),
+      naluSliceEntryCount(in_struct->naluSliceEntryCount),
+      pNaluSliceEntries(nullptr),
+      pStdPictureInfo(nullptr),
+      generatePrefixNalu(in_struct->generatePrefixNalu) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (naluSliceEntryCount && in_struct->pNaluSliceEntries) {
+        pNaluSliceEntries = new safe_VkVideoEncodeH264NaluSliceInfoKHR[naluSliceEntryCount];
+        for (uint32_t i = 0; i < naluSliceEntryCount; ++i) {
+            pNaluSliceEntries[i].initialize(&in_struct->pNaluSliceEntries[i]);
+        }
+    }
+
+    if (in_struct->pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoEncodeH264PictureInfo(*in_struct->pStdPictureInfo);
+    }
+}
+
+safe_VkVideoEncodeH264PictureInfoKHR::safe_VkVideoEncodeH264PictureInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR),
+      pNext(nullptr),
+      naluSliceEntryCount(),
+      pNaluSliceEntries(nullptr),
+      pStdPictureInfo(nullptr),
+      generatePrefixNalu() {}
+
+safe_VkVideoEncodeH264PictureInfoKHR::safe_VkVideoEncodeH264PictureInfoKHR(const safe_VkVideoEncodeH264PictureInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    naluSliceEntryCount = copy_src.naluSliceEntryCount;
+    pNaluSliceEntries = nullptr;
+    pStdPictureInfo = nullptr;
+    generatePrefixNalu = copy_src.generatePrefixNalu;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (naluSliceEntryCount && copy_src.pNaluSliceEntries) {
+        pNaluSliceEntries = new safe_VkVideoEncodeH264NaluSliceInfoKHR[naluSliceEntryCount];
+        for (uint32_t i = 0; i < naluSliceEntryCount; ++i) {
+            pNaluSliceEntries[i].initialize(&copy_src.pNaluSliceEntries[i]);
+        }
+    }
+
+    if (copy_src.pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoEncodeH264PictureInfo(*copy_src.pStdPictureInfo);
+    }
+}
+
+safe_VkVideoEncodeH264PictureInfoKHR& safe_VkVideoEncodeH264PictureInfoKHR::operator=(
+    const safe_VkVideoEncodeH264PictureInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pNaluSliceEntries) delete[] pNaluSliceEntries;
+    if (pStdPictureInfo) delete pStdPictureInfo;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    naluSliceEntryCount = copy_src.naluSliceEntryCount;
+    pNaluSliceEntries = nullptr;
+    pStdPictureInfo = nullptr;
+    generatePrefixNalu = copy_src.generatePrefixNalu;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (naluSliceEntryCount && copy_src.pNaluSliceEntries) {
+        pNaluSliceEntries = new safe_VkVideoEncodeH264NaluSliceInfoKHR[naluSliceEntryCount];
+        for (uint32_t i = 0; i < naluSliceEntryCount; ++i) {
+            pNaluSliceEntries[i].initialize(&copy_src.pNaluSliceEntries[i]);
+        }
+    }
+
+    if (copy_src.pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoEncodeH264PictureInfo(*copy_src.pStdPictureInfo);
+    }
+
+    return *this;
+}
+
+safe_VkVideoEncodeH264PictureInfoKHR::~safe_VkVideoEncodeH264PictureInfoKHR() {
+    if (pNaluSliceEntries) delete[] pNaluSliceEntries;
+    if (pStdPictureInfo) delete pStdPictureInfo;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoEncodeH264PictureInfoKHR::initialize(const VkVideoEncodeH264PictureInfoKHR* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pNaluSliceEntries) delete[] pNaluSliceEntries;
+    if (pStdPictureInfo) delete pStdPictureInfo;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    naluSliceEntryCount = in_struct->naluSliceEntryCount;
+    pNaluSliceEntries = nullptr;
+    pStdPictureInfo = nullptr;
+    generatePrefixNalu = in_struct->generatePrefixNalu;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (naluSliceEntryCount && in_struct->pNaluSliceEntries) {
+        pNaluSliceEntries = new safe_VkVideoEncodeH264NaluSliceInfoKHR[naluSliceEntryCount];
+        for (uint32_t i = 0; i < naluSliceEntryCount; ++i) {
+            pNaluSliceEntries[i].initialize(&in_struct->pNaluSliceEntries[i]);
+        }
+    }
+
+    if (in_struct->pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoEncodeH264PictureInfo(*in_struct->pStdPictureInfo);
+    }
+}
+
+void safe_VkVideoEncodeH264PictureInfoKHR::initialize(const safe_VkVideoEncodeH264PictureInfoKHR* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    naluSliceEntryCount = copy_src->naluSliceEntryCount;
+    pNaluSliceEntries = nullptr;
+    pStdPictureInfo = nullptr;
+    generatePrefixNalu = copy_src->generatePrefixNalu;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (naluSliceEntryCount && copy_src->pNaluSliceEntries) {
+        pNaluSliceEntries = new safe_VkVideoEncodeH264NaluSliceInfoKHR[naluSliceEntryCount];
+        for (uint32_t i = 0; i < naluSliceEntryCount; ++i) {
+            pNaluSliceEntries[i].initialize(&copy_src->pNaluSliceEntries[i]);
+        }
+    }
+
+    if (copy_src->pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoEncodeH264PictureInfo(*copy_src->pStdPictureInfo);
+    }
+}
+
+safe_VkVideoEncodeH264DpbSlotInfoKHR::safe_VkVideoEncodeH264DpbSlotInfoKHR(const VkVideoEncodeH264DpbSlotInfoKHR* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), pStdReferenceInfo(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoEncodeH264ReferenceInfo(*in_struct->pStdReferenceInfo);
+    }
+}
+
+safe_VkVideoEncodeH264DpbSlotInfoKHR::safe_VkVideoEncodeH264DpbSlotInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR), pNext(nullptr), pStdReferenceInfo(nullptr) {}
+
+safe_VkVideoEncodeH264DpbSlotInfoKHR::safe_VkVideoEncodeH264DpbSlotInfoKHR(const safe_VkVideoEncodeH264DpbSlotInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pStdReferenceInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoEncodeH264ReferenceInfo(*copy_src.pStdReferenceInfo);
+    }
+}
+
+safe_VkVideoEncodeH264DpbSlotInfoKHR& safe_VkVideoEncodeH264DpbSlotInfoKHR::operator=(
+    const safe_VkVideoEncodeH264DpbSlotInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pStdReferenceInfo) delete pStdReferenceInfo;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pStdReferenceInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoEncodeH264ReferenceInfo(*copy_src.pStdReferenceInfo);
+    }
+
+    return *this;
+}
+
+safe_VkVideoEncodeH264DpbSlotInfoKHR::~safe_VkVideoEncodeH264DpbSlotInfoKHR() {
+    if (pStdReferenceInfo) delete pStdReferenceInfo;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoEncodeH264DpbSlotInfoKHR::initialize(const VkVideoEncodeH264DpbSlotInfoKHR* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pStdReferenceInfo) delete pStdReferenceInfo;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pStdReferenceInfo = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoEncodeH264ReferenceInfo(*in_struct->pStdReferenceInfo);
+    }
+}
+
+void safe_VkVideoEncodeH264DpbSlotInfoKHR::initialize(const safe_VkVideoEncodeH264DpbSlotInfoKHR* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pStdReferenceInfo = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoEncodeH264ReferenceInfo(*copy_src->pStdReferenceInfo);
+    }
+}
+
+safe_VkVideoEncodeH264ProfileInfoKHR::safe_VkVideoEncodeH264ProfileInfoKHR(const VkVideoEncodeH264ProfileInfoKHR* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), stdProfileIdc(in_struct->stdProfileIdc) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeH264ProfileInfoKHR::safe_VkVideoEncodeH264ProfileInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR), pNext(nullptr), stdProfileIdc() {}
+
+safe_VkVideoEncodeH264ProfileInfoKHR::safe_VkVideoEncodeH264ProfileInfoKHR(const safe_VkVideoEncodeH264ProfileInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    stdProfileIdc = copy_src.stdProfileIdc;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeH264ProfileInfoKHR& safe_VkVideoEncodeH264ProfileInfoKHR::operator=(
+    const safe_VkVideoEncodeH264ProfileInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    stdProfileIdc = copy_src.stdProfileIdc;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeH264ProfileInfoKHR::~safe_VkVideoEncodeH264ProfileInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeH264ProfileInfoKHR::initialize(const VkVideoEncodeH264ProfileInfoKHR* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    stdProfileIdc = in_struct->stdProfileIdc;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeH264ProfileInfoKHR::initialize(const safe_VkVideoEncodeH264ProfileInfoKHR* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stdProfileIdc = copy_src->stdProfileIdc;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeH264RateControlInfoKHR::safe_VkVideoEncodeH264RateControlInfoKHR(
+    const VkVideoEncodeH264RateControlInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      gopFrameCount(in_struct->gopFrameCount),
+      idrPeriod(in_struct->idrPeriod),
+      consecutiveBFrameCount(in_struct->consecutiveBFrameCount),
+      temporalLayerCount(in_struct->temporalLayerCount) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeH264RateControlInfoKHR::safe_VkVideoEncodeH264RateControlInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR),
+      pNext(nullptr),
+      flags(),
+      gopFrameCount(),
+      idrPeriod(),
+      consecutiveBFrameCount(),
+      temporalLayerCount() {}
+
+safe_VkVideoEncodeH264RateControlInfoKHR::safe_VkVideoEncodeH264RateControlInfoKHR(
+    const safe_VkVideoEncodeH264RateControlInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    gopFrameCount = copy_src.gopFrameCount;
+    idrPeriod = copy_src.idrPeriod;
+    consecutiveBFrameCount = copy_src.consecutiveBFrameCount;
+    temporalLayerCount = copy_src.temporalLayerCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeH264RateControlInfoKHR& safe_VkVideoEncodeH264RateControlInfoKHR::operator=(
+    const safe_VkVideoEncodeH264RateControlInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    gopFrameCount = copy_src.gopFrameCount;
+    idrPeriod = copy_src.idrPeriod;
+    consecutiveBFrameCount = copy_src.consecutiveBFrameCount;
+    temporalLayerCount = copy_src.temporalLayerCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeH264RateControlInfoKHR::~safe_VkVideoEncodeH264RateControlInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeH264RateControlInfoKHR::initialize(const VkVideoEncodeH264RateControlInfoKHR* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    gopFrameCount = in_struct->gopFrameCount;
+    idrPeriod = in_struct->idrPeriod;
+    consecutiveBFrameCount = in_struct->consecutiveBFrameCount;
+    temporalLayerCount = in_struct->temporalLayerCount;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeH264RateControlInfoKHR::initialize(const safe_VkVideoEncodeH264RateControlInfoKHR* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    gopFrameCount = copy_src->gopFrameCount;
+    idrPeriod = copy_src->idrPeriod;
+    consecutiveBFrameCount = copy_src->consecutiveBFrameCount;
+    temporalLayerCount = copy_src->temporalLayerCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeH264RateControlLayerInfoKHR::safe_VkVideoEncodeH264RateControlLayerInfoKHR(
+    const VkVideoEncodeH264RateControlLayerInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      useMinQp(in_struct->useMinQp),
+      minQp(in_struct->minQp),
+      useMaxQp(in_struct->useMaxQp),
+      maxQp(in_struct->maxQp),
+      useMaxFrameSize(in_struct->useMaxFrameSize),
+      maxFrameSize(in_struct->maxFrameSize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeH264RateControlLayerInfoKHR::safe_VkVideoEncodeH264RateControlLayerInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR),
+      pNext(nullptr),
+      useMinQp(),
+      minQp(),
+      useMaxQp(),
+      maxQp(),
+      useMaxFrameSize(),
+      maxFrameSize() {}
+
+safe_VkVideoEncodeH264RateControlLayerInfoKHR::safe_VkVideoEncodeH264RateControlLayerInfoKHR(
+    const safe_VkVideoEncodeH264RateControlLayerInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    useMinQp = copy_src.useMinQp;
+    minQp = copy_src.minQp;
+    useMaxQp = copy_src.useMaxQp;
+    maxQp = copy_src.maxQp;
+    useMaxFrameSize = copy_src.useMaxFrameSize;
+    maxFrameSize = copy_src.maxFrameSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeH264RateControlLayerInfoKHR& safe_VkVideoEncodeH264RateControlLayerInfoKHR::operator=(
+    const safe_VkVideoEncodeH264RateControlLayerInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    useMinQp = copy_src.useMinQp;
+    minQp = copy_src.minQp;
+    useMaxQp = copy_src.useMaxQp;
+    maxQp = copy_src.maxQp;
+    useMaxFrameSize = copy_src.useMaxFrameSize;
+    maxFrameSize = copy_src.maxFrameSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeH264RateControlLayerInfoKHR::~safe_VkVideoEncodeH264RateControlLayerInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeH264RateControlLayerInfoKHR::initialize(const VkVideoEncodeH264RateControlLayerInfoKHR* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    useMinQp = in_struct->useMinQp;
+    minQp = in_struct->minQp;
+    useMaxQp = in_struct->useMaxQp;
+    maxQp = in_struct->maxQp;
+    useMaxFrameSize = in_struct->useMaxFrameSize;
+    maxFrameSize = in_struct->maxFrameSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeH264RateControlLayerInfoKHR::initialize(const safe_VkVideoEncodeH264RateControlLayerInfoKHR* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    useMinQp = copy_src->useMinQp;
+    minQp = copy_src->minQp;
+    useMaxQp = copy_src->useMaxQp;
+    maxQp = copy_src->maxQp;
+    useMaxFrameSize = copy_src->useMaxFrameSize;
+    maxFrameSize = copy_src->maxFrameSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeH264GopRemainingFrameInfoKHR::safe_VkVideoEncodeH264GopRemainingFrameInfoKHR(
+    const VkVideoEncodeH264GopRemainingFrameInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      useGopRemainingFrames(in_struct->useGopRemainingFrames),
+      gopRemainingI(in_struct->gopRemainingI),
+      gopRemainingP(in_struct->gopRemainingP),
+      gopRemainingB(in_struct->gopRemainingB) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeH264GopRemainingFrameInfoKHR::safe_VkVideoEncodeH264GopRemainingFrameInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR),
+      pNext(nullptr),
+      useGopRemainingFrames(),
+      gopRemainingI(),
+      gopRemainingP(),
+      gopRemainingB() {}
+
+safe_VkVideoEncodeH264GopRemainingFrameInfoKHR::safe_VkVideoEncodeH264GopRemainingFrameInfoKHR(
+    const safe_VkVideoEncodeH264GopRemainingFrameInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    useGopRemainingFrames = copy_src.useGopRemainingFrames;
+    gopRemainingI = copy_src.gopRemainingI;
+    gopRemainingP = copy_src.gopRemainingP;
+    gopRemainingB = copy_src.gopRemainingB;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeH264GopRemainingFrameInfoKHR& safe_VkVideoEncodeH264GopRemainingFrameInfoKHR::operator=(
+    const safe_VkVideoEncodeH264GopRemainingFrameInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    useGopRemainingFrames = copy_src.useGopRemainingFrames;
+    gopRemainingI = copy_src.gopRemainingI;
+    gopRemainingP = copy_src.gopRemainingP;
+    gopRemainingB = copy_src.gopRemainingB;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeH264GopRemainingFrameInfoKHR::~safe_VkVideoEncodeH264GopRemainingFrameInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeH264GopRemainingFrameInfoKHR::initialize(const VkVideoEncodeH264GopRemainingFrameInfoKHR* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    useGopRemainingFrames = in_struct->useGopRemainingFrames;
+    gopRemainingI = in_struct->gopRemainingI;
+    gopRemainingP = in_struct->gopRemainingP;
+    gopRemainingB = in_struct->gopRemainingB;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeH264GopRemainingFrameInfoKHR::initialize(const safe_VkVideoEncodeH264GopRemainingFrameInfoKHR* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    useGopRemainingFrames = copy_src->useGopRemainingFrames;
+    gopRemainingI = copy_src->gopRemainingI;
+    gopRemainingP = copy_src->gopRemainingP;
+    gopRemainingB = copy_src->gopRemainingB;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeH265CapabilitiesKHR::safe_VkVideoEncodeH265CapabilitiesKHR(const VkVideoEncodeH265CapabilitiesKHR* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      maxLevelIdc(in_struct->maxLevelIdc),
+      maxSliceSegmentCount(in_struct->maxSliceSegmentCount),
+      maxTiles(in_struct->maxTiles),
+      ctbSizes(in_struct->ctbSizes),
+      transformBlockSizes(in_struct->transformBlockSizes),
+      maxPPictureL0ReferenceCount(in_struct->maxPPictureL0ReferenceCount),
+      maxBPictureL0ReferenceCount(in_struct->maxBPictureL0ReferenceCount),
+      maxL1ReferenceCount(in_struct->maxL1ReferenceCount),
+      maxSubLayerCount(in_struct->maxSubLayerCount),
+      expectDyadicTemporalSubLayerPattern(in_struct->expectDyadicTemporalSubLayerPattern),
+      minQp(in_struct->minQp),
+      maxQp(in_struct->maxQp),
+      prefersGopRemainingFrames(in_struct->prefersGopRemainingFrames),
+      requiresGopRemainingFrames(in_struct->requiresGopRemainingFrames),
+      stdSyntaxFlags(in_struct->stdSyntaxFlags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeH265CapabilitiesKHR::safe_VkVideoEncodeH265CapabilitiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR),
+      pNext(nullptr),
+      flags(),
+      maxLevelIdc(),
+      maxSliceSegmentCount(),
+      maxTiles(),
+      ctbSizes(),
+      transformBlockSizes(),
+      maxPPictureL0ReferenceCount(),
+      maxBPictureL0ReferenceCount(),
+      maxL1ReferenceCount(),
+      maxSubLayerCount(),
+      expectDyadicTemporalSubLayerPattern(),
+      minQp(),
+      maxQp(),
+      prefersGopRemainingFrames(),
+      requiresGopRemainingFrames(),
+      stdSyntaxFlags() {}
+
+safe_VkVideoEncodeH265CapabilitiesKHR::safe_VkVideoEncodeH265CapabilitiesKHR(
+    const safe_VkVideoEncodeH265CapabilitiesKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    maxLevelIdc = copy_src.maxLevelIdc;
+    maxSliceSegmentCount = copy_src.maxSliceSegmentCount;
+    maxTiles = copy_src.maxTiles;
+    ctbSizes = copy_src.ctbSizes;
+    transformBlockSizes = copy_src.transformBlockSizes;
+    maxPPictureL0ReferenceCount = copy_src.maxPPictureL0ReferenceCount;
+    maxBPictureL0ReferenceCount = copy_src.maxBPictureL0ReferenceCount;
+    maxL1ReferenceCount = copy_src.maxL1ReferenceCount;
+    maxSubLayerCount = copy_src.maxSubLayerCount;
+    expectDyadicTemporalSubLayerPattern = copy_src.expectDyadicTemporalSubLayerPattern;
+    minQp = copy_src.minQp;
+    maxQp = copy_src.maxQp;
+    prefersGopRemainingFrames = copy_src.prefersGopRemainingFrames;
+    requiresGopRemainingFrames = copy_src.requiresGopRemainingFrames;
+    stdSyntaxFlags = copy_src.stdSyntaxFlags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeH265CapabilitiesKHR& safe_VkVideoEncodeH265CapabilitiesKHR::operator=(
+    const safe_VkVideoEncodeH265CapabilitiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    maxLevelIdc = copy_src.maxLevelIdc;
+    maxSliceSegmentCount = copy_src.maxSliceSegmentCount;
+    maxTiles = copy_src.maxTiles;
+    ctbSizes = copy_src.ctbSizes;
+    transformBlockSizes = copy_src.transformBlockSizes;
+    maxPPictureL0ReferenceCount = copy_src.maxPPictureL0ReferenceCount;
+    maxBPictureL0ReferenceCount = copy_src.maxBPictureL0ReferenceCount;
+    maxL1ReferenceCount = copy_src.maxL1ReferenceCount;
+    maxSubLayerCount = copy_src.maxSubLayerCount;
+    expectDyadicTemporalSubLayerPattern = copy_src.expectDyadicTemporalSubLayerPattern;
+    minQp = copy_src.minQp;
+    maxQp = copy_src.maxQp;
+    prefersGopRemainingFrames = copy_src.prefersGopRemainingFrames;
+    requiresGopRemainingFrames = copy_src.requiresGopRemainingFrames;
+    stdSyntaxFlags = copy_src.stdSyntaxFlags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeH265CapabilitiesKHR::~safe_VkVideoEncodeH265CapabilitiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeH265CapabilitiesKHR::initialize(const VkVideoEncodeH265CapabilitiesKHR* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    maxLevelIdc = in_struct->maxLevelIdc;
+    maxSliceSegmentCount = in_struct->maxSliceSegmentCount;
+    maxTiles = in_struct->maxTiles;
+    ctbSizes = in_struct->ctbSizes;
+    transformBlockSizes = in_struct->transformBlockSizes;
+    maxPPictureL0ReferenceCount = in_struct->maxPPictureL0ReferenceCount;
+    maxBPictureL0ReferenceCount = in_struct->maxBPictureL0ReferenceCount;
+    maxL1ReferenceCount = in_struct->maxL1ReferenceCount;
+    maxSubLayerCount = in_struct->maxSubLayerCount;
+    expectDyadicTemporalSubLayerPattern = in_struct->expectDyadicTemporalSubLayerPattern;
+    minQp = in_struct->minQp;
+    maxQp = in_struct->maxQp;
+    prefersGopRemainingFrames = in_struct->prefersGopRemainingFrames;
+    requiresGopRemainingFrames = in_struct->requiresGopRemainingFrames;
+    stdSyntaxFlags = in_struct->stdSyntaxFlags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeH265CapabilitiesKHR::initialize(const safe_VkVideoEncodeH265CapabilitiesKHR* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    maxLevelIdc = copy_src->maxLevelIdc;
+    maxSliceSegmentCount = copy_src->maxSliceSegmentCount;
+    maxTiles = copy_src->maxTiles;
+    ctbSizes = copy_src->ctbSizes;
+    transformBlockSizes = copy_src->transformBlockSizes;
+    maxPPictureL0ReferenceCount = copy_src->maxPPictureL0ReferenceCount;
+    maxBPictureL0ReferenceCount = copy_src->maxBPictureL0ReferenceCount;
+    maxL1ReferenceCount = copy_src->maxL1ReferenceCount;
+    maxSubLayerCount = copy_src->maxSubLayerCount;
+    expectDyadicTemporalSubLayerPattern = copy_src->expectDyadicTemporalSubLayerPattern;
+    minQp = copy_src->minQp;
+    maxQp = copy_src->maxQp;
+    prefersGopRemainingFrames = copy_src->prefersGopRemainingFrames;
+    requiresGopRemainingFrames = copy_src->requiresGopRemainingFrames;
+    stdSyntaxFlags = copy_src->stdSyntaxFlags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeH265SessionCreateInfoKHR::safe_VkVideoEncodeH265SessionCreateInfoKHR(
+    const VkVideoEncodeH265SessionCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), useMaxLevelIdc(in_struct->useMaxLevelIdc), maxLevelIdc(in_struct->maxLevelIdc) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeH265SessionCreateInfoKHR::safe_VkVideoEncodeH265SessionCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR), pNext(nullptr), useMaxLevelIdc(), maxLevelIdc() {}
+
+safe_VkVideoEncodeH265SessionCreateInfoKHR::safe_VkVideoEncodeH265SessionCreateInfoKHR(
+    const safe_VkVideoEncodeH265SessionCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    useMaxLevelIdc = copy_src.useMaxLevelIdc;
+    maxLevelIdc = copy_src.maxLevelIdc;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeH265SessionCreateInfoKHR& safe_VkVideoEncodeH265SessionCreateInfoKHR::operator=(
+    const safe_VkVideoEncodeH265SessionCreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    useMaxLevelIdc = copy_src.useMaxLevelIdc;
+    maxLevelIdc = copy_src.maxLevelIdc;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeH265SessionCreateInfoKHR::~safe_VkVideoEncodeH265SessionCreateInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeH265SessionCreateInfoKHR::initialize(const VkVideoEncodeH265SessionCreateInfoKHR* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    useMaxLevelIdc = in_struct->useMaxLevelIdc;
+    maxLevelIdc = in_struct->maxLevelIdc;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeH265SessionCreateInfoKHR::initialize(const safe_VkVideoEncodeH265SessionCreateInfoKHR* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    useMaxLevelIdc = copy_src->useMaxLevelIdc;
+    maxLevelIdc = copy_src->maxLevelIdc;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeH265QualityLevelPropertiesKHR::safe_VkVideoEncodeH265QualityLevelPropertiesKHR(
+    const VkVideoEncodeH265QualityLevelPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      preferredRateControlFlags(in_struct->preferredRateControlFlags),
+      preferredGopFrameCount(in_struct->preferredGopFrameCount),
+      preferredIdrPeriod(in_struct->preferredIdrPeriod),
+      preferredConsecutiveBFrameCount(in_struct->preferredConsecutiveBFrameCount),
+      preferredSubLayerCount(in_struct->preferredSubLayerCount),
+      preferredConstantQp(in_struct->preferredConstantQp),
+      preferredMaxL0ReferenceCount(in_struct->preferredMaxL0ReferenceCount),
+      preferredMaxL1ReferenceCount(in_struct->preferredMaxL1ReferenceCount) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeH265QualityLevelPropertiesKHR::safe_VkVideoEncodeH265QualityLevelPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR),
+      pNext(nullptr),
+      preferredRateControlFlags(),
+      preferredGopFrameCount(),
+      preferredIdrPeriod(),
+      preferredConsecutiveBFrameCount(),
+      preferredSubLayerCount(),
+      preferredConstantQp(),
+      preferredMaxL0ReferenceCount(),
+      preferredMaxL1ReferenceCount() {}
+
+safe_VkVideoEncodeH265QualityLevelPropertiesKHR::safe_VkVideoEncodeH265QualityLevelPropertiesKHR(
+    const safe_VkVideoEncodeH265QualityLevelPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    preferredRateControlFlags = copy_src.preferredRateControlFlags;
+    preferredGopFrameCount = copy_src.preferredGopFrameCount;
+    preferredIdrPeriod = copy_src.preferredIdrPeriod;
+    preferredConsecutiveBFrameCount = copy_src.preferredConsecutiveBFrameCount;
+    preferredSubLayerCount = copy_src.preferredSubLayerCount;
+    preferredConstantQp = copy_src.preferredConstantQp;
+    preferredMaxL0ReferenceCount = copy_src.preferredMaxL0ReferenceCount;
+    preferredMaxL1ReferenceCount = copy_src.preferredMaxL1ReferenceCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeH265QualityLevelPropertiesKHR& safe_VkVideoEncodeH265QualityLevelPropertiesKHR::operator=(
+    const safe_VkVideoEncodeH265QualityLevelPropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    preferredRateControlFlags = copy_src.preferredRateControlFlags;
+    preferredGopFrameCount = copy_src.preferredGopFrameCount;
+    preferredIdrPeriod = copy_src.preferredIdrPeriod;
+    preferredConsecutiveBFrameCount = copy_src.preferredConsecutiveBFrameCount;
+    preferredSubLayerCount = copy_src.preferredSubLayerCount;
+    preferredConstantQp = copy_src.preferredConstantQp;
+    preferredMaxL0ReferenceCount = copy_src.preferredMaxL0ReferenceCount;
+    preferredMaxL1ReferenceCount = copy_src.preferredMaxL1ReferenceCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeH265QualityLevelPropertiesKHR::~safe_VkVideoEncodeH265QualityLevelPropertiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeH265QualityLevelPropertiesKHR::initialize(const VkVideoEncodeH265QualityLevelPropertiesKHR* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    preferredRateControlFlags = in_struct->preferredRateControlFlags;
+    preferredGopFrameCount = in_struct->preferredGopFrameCount;
+    preferredIdrPeriod = in_struct->preferredIdrPeriod;
+    preferredConsecutiveBFrameCount = in_struct->preferredConsecutiveBFrameCount;
+    preferredSubLayerCount = in_struct->preferredSubLayerCount;
+    preferredConstantQp = in_struct->preferredConstantQp;
+    preferredMaxL0ReferenceCount = in_struct->preferredMaxL0ReferenceCount;
+    preferredMaxL1ReferenceCount = in_struct->preferredMaxL1ReferenceCount;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeH265QualityLevelPropertiesKHR::initialize(const safe_VkVideoEncodeH265QualityLevelPropertiesKHR* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    preferredRateControlFlags = copy_src->preferredRateControlFlags;
+    preferredGopFrameCount = copy_src->preferredGopFrameCount;
+    preferredIdrPeriod = copy_src->preferredIdrPeriod;
+    preferredConsecutiveBFrameCount = copy_src->preferredConsecutiveBFrameCount;
+    preferredSubLayerCount = copy_src->preferredSubLayerCount;
+    preferredConstantQp = copy_src->preferredConstantQp;
+    preferredMaxL0ReferenceCount = copy_src->preferredMaxL0ReferenceCount;
+    preferredMaxL1ReferenceCount = copy_src->preferredMaxL1ReferenceCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeH265SessionParametersAddInfoKHR::safe_VkVideoEncodeH265SessionParametersAddInfoKHR(
+    const VkVideoEncodeH265SessionParametersAddInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      stdVPSCount(in_struct->stdVPSCount),
+      pStdVPSs(nullptr),
+      stdSPSCount(in_struct->stdSPSCount),
+      pStdSPSs(nullptr),
+      stdPPSCount(in_struct->stdPPSCount),
+      pStdPPSs(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pStdVPSs) {
+        pStdVPSs = new StdVideoH265VideoParameterSet[in_struct->stdVPSCount];
+        memcpy((void*)pStdVPSs, (void*)in_struct->pStdVPSs, sizeof(StdVideoH265VideoParameterSet) * in_struct->stdVPSCount);
+    }
+
+    if (in_struct->pStdSPSs) {
+        pStdSPSs = new StdVideoH265SequenceParameterSet[in_struct->stdSPSCount];
+        memcpy((void*)pStdSPSs, (void*)in_struct->pStdSPSs, sizeof(StdVideoH265SequenceParameterSet) * in_struct->stdSPSCount);
+    }
+
+    if (in_struct->pStdPPSs) {
+        pStdPPSs = new StdVideoH265PictureParameterSet[in_struct->stdPPSCount];
+        memcpy((void*)pStdPPSs, (void*)in_struct->pStdPPSs, sizeof(StdVideoH265PictureParameterSet) * in_struct->stdPPSCount);
+    }
+}
+
+safe_VkVideoEncodeH265SessionParametersAddInfoKHR::safe_VkVideoEncodeH265SessionParametersAddInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR),
+      pNext(nullptr),
+      stdVPSCount(),
+      pStdVPSs(nullptr),
+      stdSPSCount(),
+      pStdSPSs(nullptr),
+      stdPPSCount(),
+      pStdPPSs(nullptr) {}
+
+safe_VkVideoEncodeH265SessionParametersAddInfoKHR::safe_VkVideoEncodeH265SessionParametersAddInfoKHR(
+    const safe_VkVideoEncodeH265SessionParametersAddInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    stdVPSCount = copy_src.stdVPSCount;
+    pStdVPSs = nullptr;
+    stdSPSCount = copy_src.stdSPSCount;
+    pStdSPSs = nullptr;
+    stdPPSCount = copy_src.stdPPSCount;
+    pStdPPSs = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdVPSs) {
+        pStdVPSs = new StdVideoH265VideoParameterSet[copy_src.stdVPSCount];
+        memcpy((void*)pStdVPSs, (void*)copy_src.pStdVPSs, sizeof(StdVideoH265VideoParameterSet) * copy_src.stdVPSCount);
+    }
+
+    if (copy_src.pStdSPSs) {
+        pStdSPSs = new StdVideoH265SequenceParameterSet[copy_src.stdSPSCount];
+        memcpy((void*)pStdSPSs, (void*)copy_src.pStdSPSs, sizeof(StdVideoH265SequenceParameterSet) * copy_src.stdSPSCount);
+    }
+
+    if (copy_src.pStdPPSs) {
+        pStdPPSs = new StdVideoH265PictureParameterSet[copy_src.stdPPSCount];
+        memcpy((void*)pStdPPSs, (void*)copy_src.pStdPPSs, sizeof(StdVideoH265PictureParameterSet) * copy_src.stdPPSCount);
+    }
+}
+
+safe_VkVideoEncodeH265SessionParametersAddInfoKHR& safe_VkVideoEncodeH265SessionParametersAddInfoKHR::operator=(
+    const safe_VkVideoEncodeH265SessionParametersAddInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pStdVPSs) delete[] pStdVPSs;
+    if (pStdSPSs) delete[] pStdSPSs;
+    if (pStdPPSs) delete[] pStdPPSs;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    stdVPSCount = copy_src.stdVPSCount;
+    pStdVPSs = nullptr;
+    stdSPSCount = copy_src.stdSPSCount;
+    pStdSPSs = nullptr;
+    stdPPSCount = copy_src.stdPPSCount;
+    pStdPPSs = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdVPSs) {
+        pStdVPSs = new StdVideoH265VideoParameterSet[copy_src.stdVPSCount];
+        memcpy((void*)pStdVPSs, (void*)copy_src.pStdVPSs, sizeof(StdVideoH265VideoParameterSet) * copy_src.stdVPSCount);
+    }
+
+    if (copy_src.pStdSPSs) {
+        pStdSPSs = new StdVideoH265SequenceParameterSet[copy_src.stdSPSCount];
+        memcpy((void*)pStdSPSs, (void*)copy_src.pStdSPSs, sizeof(StdVideoH265SequenceParameterSet) * copy_src.stdSPSCount);
+    }
+
+    if (copy_src.pStdPPSs) {
+        pStdPPSs = new StdVideoH265PictureParameterSet[copy_src.stdPPSCount];
+        memcpy((void*)pStdPPSs, (void*)copy_src.pStdPPSs, sizeof(StdVideoH265PictureParameterSet) * copy_src.stdPPSCount);
+    }
+
+    return *this;
+}
+
+safe_VkVideoEncodeH265SessionParametersAddInfoKHR::~safe_VkVideoEncodeH265SessionParametersAddInfoKHR() {
+    if (pStdVPSs) delete[] pStdVPSs;
+    if (pStdSPSs) delete[] pStdSPSs;
+    if (pStdPPSs) delete[] pStdPPSs;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoEncodeH265SessionParametersAddInfoKHR::initialize(const VkVideoEncodeH265SessionParametersAddInfoKHR* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pStdVPSs) delete[] pStdVPSs;
+    if (pStdSPSs) delete[] pStdSPSs;
+    if (pStdPPSs) delete[] pStdPPSs;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    stdVPSCount = in_struct->stdVPSCount;
+    pStdVPSs = nullptr;
+    stdSPSCount = in_struct->stdSPSCount;
+    pStdSPSs = nullptr;
+    stdPPSCount = in_struct->stdPPSCount;
+    pStdPPSs = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pStdVPSs) {
+        pStdVPSs = new StdVideoH265VideoParameterSet[in_struct->stdVPSCount];
+        memcpy((void*)pStdVPSs, (void*)in_struct->pStdVPSs, sizeof(StdVideoH265VideoParameterSet) * in_struct->stdVPSCount);
+    }
+
+    if (in_struct->pStdSPSs) {
+        pStdSPSs = new StdVideoH265SequenceParameterSet[in_struct->stdSPSCount];
+        memcpy((void*)pStdSPSs, (void*)in_struct->pStdSPSs, sizeof(StdVideoH265SequenceParameterSet) * in_struct->stdSPSCount);
+    }
+
+    if (in_struct->pStdPPSs) {
+        pStdPPSs = new StdVideoH265PictureParameterSet[in_struct->stdPPSCount];
+        memcpy((void*)pStdPPSs, (void*)in_struct->pStdPPSs, sizeof(StdVideoH265PictureParameterSet) * in_struct->stdPPSCount);
+    }
+}
+
+void safe_VkVideoEncodeH265SessionParametersAddInfoKHR::initialize(
+    const safe_VkVideoEncodeH265SessionParametersAddInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stdVPSCount = copy_src->stdVPSCount;
+    pStdVPSs = nullptr;
+    stdSPSCount = copy_src->stdSPSCount;
+    pStdSPSs = nullptr;
+    stdPPSCount = copy_src->stdPPSCount;
+    pStdPPSs = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pStdVPSs) {
+        pStdVPSs = new StdVideoH265VideoParameterSet[copy_src->stdVPSCount];
+        memcpy((void*)pStdVPSs, (void*)copy_src->pStdVPSs, sizeof(StdVideoH265VideoParameterSet) * copy_src->stdVPSCount);
+    }
+
+    if (copy_src->pStdSPSs) {
+        pStdSPSs = new StdVideoH265SequenceParameterSet[copy_src->stdSPSCount];
+        memcpy((void*)pStdSPSs, (void*)copy_src->pStdSPSs, sizeof(StdVideoH265SequenceParameterSet) * copy_src->stdSPSCount);
+    }
+
+    if (copy_src->pStdPPSs) {
+        pStdPPSs = new StdVideoH265PictureParameterSet[copy_src->stdPPSCount];
+        memcpy((void*)pStdPPSs, (void*)copy_src->pStdPPSs, sizeof(StdVideoH265PictureParameterSet) * copy_src->stdPPSCount);
+    }
+}
+
+safe_VkVideoEncodeH265SessionParametersCreateInfoKHR::safe_VkVideoEncodeH265SessionParametersCreateInfoKHR(
+    const VkVideoEncodeH265SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      maxStdVPSCount(in_struct->maxStdVPSCount),
+      maxStdSPSCount(in_struct->maxStdSPSCount),
+      maxStdPPSCount(in_struct->maxStdPPSCount),
+      pParametersAddInfo(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pParametersAddInfo)
+        pParametersAddInfo = new safe_VkVideoEncodeH265SessionParametersAddInfoKHR(in_struct->pParametersAddInfo);
+}
+
+safe_VkVideoEncodeH265SessionParametersCreateInfoKHR::safe_VkVideoEncodeH265SessionParametersCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR),
+      pNext(nullptr),
+      maxStdVPSCount(),
+      maxStdSPSCount(),
+      maxStdPPSCount(),
+      pParametersAddInfo(nullptr) {}
+
+safe_VkVideoEncodeH265SessionParametersCreateInfoKHR::safe_VkVideoEncodeH265SessionParametersCreateInfoKHR(
+    const safe_VkVideoEncodeH265SessionParametersCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    maxStdVPSCount = copy_src.maxStdVPSCount;
+    maxStdSPSCount = copy_src.maxStdSPSCount;
+    maxStdPPSCount = copy_src.maxStdPPSCount;
+    pParametersAddInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pParametersAddInfo)
+        pParametersAddInfo = new safe_VkVideoEncodeH265SessionParametersAddInfoKHR(*copy_src.pParametersAddInfo);
+}
+
+safe_VkVideoEncodeH265SessionParametersCreateInfoKHR& safe_VkVideoEncodeH265SessionParametersCreateInfoKHR::operator=(
+    const safe_VkVideoEncodeH265SessionParametersCreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pParametersAddInfo) delete pParametersAddInfo;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxStdVPSCount = copy_src.maxStdVPSCount;
+    maxStdSPSCount = copy_src.maxStdSPSCount;
+    maxStdPPSCount = copy_src.maxStdPPSCount;
+    pParametersAddInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pParametersAddInfo)
+        pParametersAddInfo = new safe_VkVideoEncodeH265SessionParametersAddInfoKHR(*copy_src.pParametersAddInfo);
+
+    return *this;
+}
+
+safe_VkVideoEncodeH265SessionParametersCreateInfoKHR::~safe_VkVideoEncodeH265SessionParametersCreateInfoKHR() {
+    if (pParametersAddInfo) delete pParametersAddInfo;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoEncodeH265SessionParametersCreateInfoKHR::initialize(
+    const VkVideoEncodeH265SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pParametersAddInfo) delete pParametersAddInfo;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxStdVPSCount = in_struct->maxStdVPSCount;
+    maxStdSPSCount = in_struct->maxStdSPSCount;
+    maxStdPPSCount = in_struct->maxStdPPSCount;
+    pParametersAddInfo = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (in_struct->pParametersAddInfo)
+        pParametersAddInfo = new safe_VkVideoEncodeH265SessionParametersAddInfoKHR(in_struct->pParametersAddInfo);
+}
+
+void safe_VkVideoEncodeH265SessionParametersCreateInfoKHR::initialize(
+    const safe_VkVideoEncodeH265SessionParametersCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxStdVPSCount = copy_src->maxStdVPSCount;
+    maxStdSPSCount = copy_src->maxStdSPSCount;
+    maxStdPPSCount = copy_src->maxStdPPSCount;
+    pParametersAddInfo = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (copy_src->pParametersAddInfo)
+        pParametersAddInfo = new safe_VkVideoEncodeH265SessionParametersAddInfoKHR(*copy_src->pParametersAddInfo);
+}
+
+safe_VkVideoEncodeH265SessionParametersGetInfoKHR::safe_VkVideoEncodeH265SessionParametersGetInfoKHR(
+    const VkVideoEncodeH265SessionParametersGetInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      writeStdVPS(in_struct->writeStdVPS),
+      writeStdSPS(in_struct->writeStdSPS),
+      writeStdPPS(in_struct->writeStdPPS),
+      stdVPSId(in_struct->stdVPSId),
+      stdSPSId(in_struct->stdSPSId),
+      stdPPSId(in_struct->stdPPSId) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeH265SessionParametersGetInfoKHR::safe_VkVideoEncodeH265SessionParametersGetInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR),
+      pNext(nullptr),
+      writeStdVPS(),
+      writeStdSPS(),
+      writeStdPPS(),
+      stdVPSId(),
+      stdSPSId(),
+      stdPPSId() {}
+
+safe_VkVideoEncodeH265SessionParametersGetInfoKHR::safe_VkVideoEncodeH265SessionParametersGetInfoKHR(
+    const safe_VkVideoEncodeH265SessionParametersGetInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    writeStdVPS = copy_src.writeStdVPS;
+    writeStdSPS = copy_src.writeStdSPS;
+    writeStdPPS = copy_src.writeStdPPS;
+    stdVPSId = copy_src.stdVPSId;
+    stdSPSId = copy_src.stdSPSId;
+    stdPPSId = copy_src.stdPPSId;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeH265SessionParametersGetInfoKHR& safe_VkVideoEncodeH265SessionParametersGetInfoKHR::operator=(
+    const safe_VkVideoEncodeH265SessionParametersGetInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    writeStdVPS = copy_src.writeStdVPS;
+    writeStdSPS = copy_src.writeStdSPS;
+    writeStdPPS = copy_src.writeStdPPS;
+    stdVPSId = copy_src.stdVPSId;
+    stdSPSId = copy_src.stdSPSId;
+    stdPPSId = copy_src.stdPPSId;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeH265SessionParametersGetInfoKHR::~safe_VkVideoEncodeH265SessionParametersGetInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeH265SessionParametersGetInfoKHR::initialize(const VkVideoEncodeH265SessionParametersGetInfoKHR* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    writeStdVPS = in_struct->writeStdVPS;
+    writeStdSPS = in_struct->writeStdSPS;
+    writeStdPPS = in_struct->writeStdPPS;
+    stdVPSId = in_struct->stdVPSId;
+    stdSPSId = in_struct->stdSPSId;
+    stdPPSId = in_struct->stdPPSId;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeH265SessionParametersGetInfoKHR::initialize(
+    const safe_VkVideoEncodeH265SessionParametersGetInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    writeStdVPS = copy_src->writeStdVPS;
+    writeStdSPS = copy_src->writeStdSPS;
+    writeStdPPS = copy_src->writeStdPPS;
+    stdVPSId = copy_src->stdVPSId;
+    stdSPSId = copy_src->stdSPSId;
+    stdPPSId = copy_src->stdPPSId;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR::safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR(
+    const VkVideoEncodeH265SessionParametersFeedbackInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      hasStdVPSOverrides(in_struct->hasStdVPSOverrides),
+      hasStdSPSOverrides(in_struct->hasStdSPSOverrides),
+      hasStdPPSOverrides(in_struct->hasStdPPSOverrides) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR::safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR),
+      pNext(nullptr),
+      hasStdVPSOverrides(),
+      hasStdSPSOverrides(),
+      hasStdPPSOverrides() {}
+
+safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR::safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR(
+    const safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    hasStdVPSOverrides = copy_src.hasStdVPSOverrides;
+    hasStdSPSOverrides = copy_src.hasStdSPSOverrides;
+    hasStdPPSOverrides = copy_src.hasStdPPSOverrides;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR& safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR::operator=(
+    const safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    hasStdVPSOverrides = copy_src.hasStdVPSOverrides;
+    hasStdSPSOverrides = copy_src.hasStdSPSOverrides;
+    hasStdPPSOverrides = copy_src.hasStdPPSOverrides;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR::~safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR::initialize(
+    const VkVideoEncodeH265SessionParametersFeedbackInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    hasStdVPSOverrides = in_struct->hasStdVPSOverrides;
+    hasStdSPSOverrides = in_struct->hasStdSPSOverrides;
+    hasStdPPSOverrides = in_struct->hasStdPPSOverrides;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR::initialize(
+    const safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    hasStdVPSOverrides = copy_src->hasStdVPSOverrides;
+    hasStdSPSOverrides = copy_src->hasStdSPSOverrides;
+    hasStdPPSOverrides = copy_src->hasStdPPSOverrides;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR::safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR(
+    const VkVideoEncodeH265NaluSliceSegmentInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), constantQp(in_struct->constantQp), pStdSliceSegmentHeader(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pStdSliceSegmentHeader) {
+        pStdSliceSegmentHeader = new StdVideoEncodeH265SliceSegmentHeader(*in_struct->pStdSliceSegmentHeader);
+    }
+}
+
+safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR::safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR),
+      pNext(nullptr),
+      constantQp(),
+      pStdSliceSegmentHeader(nullptr) {}
+
+safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR::safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR(
+    const safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    constantQp = copy_src.constantQp;
+    pStdSliceSegmentHeader = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdSliceSegmentHeader) {
+        pStdSliceSegmentHeader = new StdVideoEncodeH265SliceSegmentHeader(*copy_src.pStdSliceSegmentHeader);
+    }
+}
+
+safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR& safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR::operator=(
+    const safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pStdSliceSegmentHeader) delete pStdSliceSegmentHeader;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    constantQp = copy_src.constantQp;
+    pStdSliceSegmentHeader = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdSliceSegmentHeader) {
+        pStdSliceSegmentHeader = new StdVideoEncodeH265SliceSegmentHeader(*copy_src.pStdSliceSegmentHeader);
+    }
+
+    return *this;
+}
+
+safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR::~safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR() {
+    if (pStdSliceSegmentHeader) delete pStdSliceSegmentHeader;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR::initialize(const VkVideoEncodeH265NaluSliceSegmentInfoKHR* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pStdSliceSegmentHeader) delete pStdSliceSegmentHeader;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    constantQp = in_struct->constantQp;
+    pStdSliceSegmentHeader = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pStdSliceSegmentHeader) {
+        pStdSliceSegmentHeader = new StdVideoEncodeH265SliceSegmentHeader(*in_struct->pStdSliceSegmentHeader);
+    }
+}
+
+void safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR::initialize(const safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    constantQp = copy_src->constantQp;
+    pStdSliceSegmentHeader = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pStdSliceSegmentHeader) {
+        pStdSliceSegmentHeader = new StdVideoEncodeH265SliceSegmentHeader(*copy_src->pStdSliceSegmentHeader);
+    }
+}
+
+safe_VkVideoEncodeH265PictureInfoKHR::safe_VkVideoEncodeH265PictureInfoKHR(const VkVideoEncodeH265PictureInfoKHR* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType),
+      naluSliceSegmentEntryCount(in_struct->naluSliceSegmentEntryCount),
+      pNaluSliceSegmentEntries(nullptr),
+      pStdPictureInfo(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (naluSliceSegmentEntryCount && in_struct->pNaluSliceSegmentEntries) {
+        pNaluSliceSegmentEntries = new safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR[naluSliceSegmentEntryCount];
+        for (uint32_t i = 0; i < naluSliceSegmentEntryCount; ++i) {
+            pNaluSliceSegmentEntries[i].initialize(&in_struct->pNaluSliceSegmentEntries[i]);
+        }
+    }
+
+    if (in_struct->pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoEncodeH265PictureInfo(*in_struct->pStdPictureInfo);
+    }
+}
+
+safe_VkVideoEncodeH265PictureInfoKHR::safe_VkVideoEncodeH265PictureInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR),
+      pNext(nullptr),
+      naluSliceSegmentEntryCount(),
+      pNaluSliceSegmentEntries(nullptr),
+      pStdPictureInfo(nullptr) {}
+
+safe_VkVideoEncodeH265PictureInfoKHR::safe_VkVideoEncodeH265PictureInfoKHR(const safe_VkVideoEncodeH265PictureInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    naluSliceSegmentEntryCount = copy_src.naluSliceSegmentEntryCount;
+    pNaluSliceSegmentEntries = nullptr;
+    pStdPictureInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (naluSliceSegmentEntryCount && copy_src.pNaluSliceSegmentEntries) {
+        pNaluSliceSegmentEntries = new safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR[naluSliceSegmentEntryCount];
+        for (uint32_t i = 0; i < naluSliceSegmentEntryCount; ++i) {
+            pNaluSliceSegmentEntries[i].initialize(&copy_src.pNaluSliceSegmentEntries[i]);
+        }
+    }
+
+    if (copy_src.pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoEncodeH265PictureInfo(*copy_src.pStdPictureInfo);
+    }
+}
+
+safe_VkVideoEncodeH265PictureInfoKHR& safe_VkVideoEncodeH265PictureInfoKHR::operator=(
+    const safe_VkVideoEncodeH265PictureInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pNaluSliceSegmentEntries) delete[] pNaluSliceSegmentEntries;
+    if (pStdPictureInfo) delete pStdPictureInfo;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    naluSliceSegmentEntryCount = copy_src.naluSliceSegmentEntryCount;
+    pNaluSliceSegmentEntries = nullptr;
+    pStdPictureInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (naluSliceSegmentEntryCount && copy_src.pNaluSliceSegmentEntries) {
+        pNaluSliceSegmentEntries = new safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR[naluSliceSegmentEntryCount];
+        for (uint32_t i = 0; i < naluSliceSegmentEntryCount; ++i) {
+            pNaluSliceSegmentEntries[i].initialize(&copy_src.pNaluSliceSegmentEntries[i]);
+        }
+    }
+
+    if (copy_src.pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoEncodeH265PictureInfo(*copy_src.pStdPictureInfo);
+    }
+
+    return *this;
+}
+
+safe_VkVideoEncodeH265PictureInfoKHR::~safe_VkVideoEncodeH265PictureInfoKHR() {
+    if (pNaluSliceSegmentEntries) delete[] pNaluSliceSegmentEntries;
+    if (pStdPictureInfo) delete pStdPictureInfo;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoEncodeH265PictureInfoKHR::initialize(const VkVideoEncodeH265PictureInfoKHR* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pNaluSliceSegmentEntries) delete[] pNaluSliceSegmentEntries;
+    if (pStdPictureInfo) delete pStdPictureInfo;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    naluSliceSegmentEntryCount = in_struct->naluSliceSegmentEntryCount;
+    pNaluSliceSegmentEntries = nullptr;
+    pStdPictureInfo = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (naluSliceSegmentEntryCount && in_struct->pNaluSliceSegmentEntries) {
+        pNaluSliceSegmentEntries = new safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR[naluSliceSegmentEntryCount];
+        for (uint32_t i = 0; i < naluSliceSegmentEntryCount; ++i) {
+            pNaluSliceSegmentEntries[i].initialize(&in_struct->pNaluSliceSegmentEntries[i]);
+        }
+    }
+
+    if (in_struct->pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoEncodeH265PictureInfo(*in_struct->pStdPictureInfo);
+    }
+}
+
+void safe_VkVideoEncodeH265PictureInfoKHR::initialize(const safe_VkVideoEncodeH265PictureInfoKHR* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    naluSliceSegmentEntryCount = copy_src->naluSliceSegmentEntryCount;
+    pNaluSliceSegmentEntries = nullptr;
+    pStdPictureInfo = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (naluSliceSegmentEntryCount && copy_src->pNaluSliceSegmentEntries) {
+        pNaluSliceSegmentEntries = new safe_VkVideoEncodeH265NaluSliceSegmentInfoKHR[naluSliceSegmentEntryCount];
+        for (uint32_t i = 0; i < naluSliceSegmentEntryCount; ++i) {
+            pNaluSliceSegmentEntries[i].initialize(&copy_src->pNaluSliceSegmentEntries[i]);
+        }
+    }
+
+    if (copy_src->pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoEncodeH265PictureInfo(*copy_src->pStdPictureInfo);
+    }
+}
+
+safe_VkVideoEncodeH265DpbSlotInfoKHR::safe_VkVideoEncodeH265DpbSlotInfoKHR(const VkVideoEncodeH265DpbSlotInfoKHR* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), pStdReferenceInfo(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoEncodeH265ReferenceInfo(*in_struct->pStdReferenceInfo);
+    }
+}
+
+safe_VkVideoEncodeH265DpbSlotInfoKHR::safe_VkVideoEncodeH265DpbSlotInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR), pNext(nullptr), pStdReferenceInfo(nullptr) {}
+
+safe_VkVideoEncodeH265DpbSlotInfoKHR::safe_VkVideoEncodeH265DpbSlotInfoKHR(const safe_VkVideoEncodeH265DpbSlotInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pStdReferenceInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoEncodeH265ReferenceInfo(*copy_src.pStdReferenceInfo);
+    }
+}
+
+safe_VkVideoEncodeH265DpbSlotInfoKHR& safe_VkVideoEncodeH265DpbSlotInfoKHR::operator=(
+    const safe_VkVideoEncodeH265DpbSlotInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pStdReferenceInfo) delete pStdReferenceInfo;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pStdReferenceInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoEncodeH265ReferenceInfo(*copy_src.pStdReferenceInfo);
+    }
+
+    return *this;
+}
+
+safe_VkVideoEncodeH265DpbSlotInfoKHR::~safe_VkVideoEncodeH265DpbSlotInfoKHR() {
+    if (pStdReferenceInfo) delete pStdReferenceInfo;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoEncodeH265DpbSlotInfoKHR::initialize(const VkVideoEncodeH265DpbSlotInfoKHR* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pStdReferenceInfo) delete pStdReferenceInfo;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pStdReferenceInfo = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoEncodeH265ReferenceInfo(*in_struct->pStdReferenceInfo);
+    }
+}
+
+void safe_VkVideoEncodeH265DpbSlotInfoKHR::initialize(const safe_VkVideoEncodeH265DpbSlotInfoKHR* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pStdReferenceInfo = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoEncodeH265ReferenceInfo(*copy_src->pStdReferenceInfo);
+    }
+}
+
+safe_VkVideoEncodeH265ProfileInfoKHR::safe_VkVideoEncodeH265ProfileInfoKHR(const VkVideoEncodeH265ProfileInfoKHR* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), stdProfileIdc(in_struct->stdProfileIdc) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeH265ProfileInfoKHR::safe_VkVideoEncodeH265ProfileInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR), pNext(nullptr), stdProfileIdc() {}
+
+safe_VkVideoEncodeH265ProfileInfoKHR::safe_VkVideoEncodeH265ProfileInfoKHR(const safe_VkVideoEncodeH265ProfileInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    stdProfileIdc = copy_src.stdProfileIdc;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeH265ProfileInfoKHR& safe_VkVideoEncodeH265ProfileInfoKHR::operator=(
+    const safe_VkVideoEncodeH265ProfileInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    stdProfileIdc = copy_src.stdProfileIdc;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeH265ProfileInfoKHR::~safe_VkVideoEncodeH265ProfileInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeH265ProfileInfoKHR::initialize(const VkVideoEncodeH265ProfileInfoKHR* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    stdProfileIdc = in_struct->stdProfileIdc;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeH265ProfileInfoKHR::initialize(const safe_VkVideoEncodeH265ProfileInfoKHR* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stdProfileIdc = copy_src->stdProfileIdc;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeH265RateControlInfoKHR::safe_VkVideoEncodeH265RateControlInfoKHR(
+    const VkVideoEncodeH265RateControlInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      gopFrameCount(in_struct->gopFrameCount),
+      idrPeriod(in_struct->idrPeriod),
+      consecutiveBFrameCount(in_struct->consecutiveBFrameCount),
+      subLayerCount(in_struct->subLayerCount) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeH265RateControlInfoKHR::safe_VkVideoEncodeH265RateControlInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR),
+      pNext(nullptr),
+      flags(),
+      gopFrameCount(),
+      idrPeriod(),
+      consecutiveBFrameCount(),
+      subLayerCount() {}
+
+safe_VkVideoEncodeH265RateControlInfoKHR::safe_VkVideoEncodeH265RateControlInfoKHR(
+    const safe_VkVideoEncodeH265RateControlInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    gopFrameCount = copy_src.gopFrameCount;
+    idrPeriod = copy_src.idrPeriod;
+    consecutiveBFrameCount = copy_src.consecutiveBFrameCount;
+    subLayerCount = copy_src.subLayerCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeH265RateControlInfoKHR& safe_VkVideoEncodeH265RateControlInfoKHR::operator=(
+    const safe_VkVideoEncodeH265RateControlInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    gopFrameCount = copy_src.gopFrameCount;
+    idrPeriod = copy_src.idrPeriod;
+    consecutiveBFrameCount = copy_src.consecutiveBFrameCount;
+    subLayerCount = copy_src.subLayerCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeH265RateControlInfoKHR::~safe_VkVideoEncodeH265RateControlInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeH265RateControlInfoKHR::initialize(const VkVideoEncodeH265RateControlInfoKHR* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    gopFrameCount = in_struct->gopFrameCount;
+    idrPeriod = in_struct->idrPeriod;
+    consecutiveBFrameCount = in_struct->consecutiveBFrameCount;
+    subLayerCount = in_struct->subLayerCount;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeH265RateControlInfoKHR::initialize(const safe_VkVideoEncodeH265RateControlInfoKHR* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    gopFrameCount = copy_src->gopFrameCount;
+    idrPeriod = copy_src->idrPeriod;
+    consecutiveBFrameCount = copy_src->consecutiveBFrameCount;
+    subLayerCount = copy_src->subLayerCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeH265RateControlLayerInfoKHR::safe_VkVideoEncodeH265RateControlLayerInfoKHR(
+    const VkVideoEncodeH265RateControlLayerInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      useMinQp(in_struct->useMinQp),
+      minQp(in_struct->minQp),
+      useMaxQp(in_struct->useMaxQp),
+      maxQp(in_struct->maxQp),
+      useMaxFrameSize(in_struct->useMaxFrameSize),
+      maxFrameSize(in_struct->maxFrameSize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeH265RateControlLayerInfoKHR::safe_VkVideoEncodeH265RateControlLayerInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR),
+      pNext(nullptr),
+      useMinQp(),
+      minQp(),
+      useMaxQp(),
+      maxQp(),
+      useMaxFrameSize(),
+      maxFrameSize() {}
+
+safe_VkVideoEncodeH265RateControlLayerInfoKHR::safe_VkVideoEncodeH265RateControlLayerInfoKHR(
+    const safe_VkVideoEncodeH265RateControlLayerInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    useMinQp = copy_src.useMinQp;
+    minQp = copy_src.minQp;
+    useMaxQp = copy_src.useMaxQp;
+    maxQp = copy_src.maxQp;
+    useMaxFrameSize = copy_src.useMaxFrameSize;
+    maxFrameSize = copy_src.maxFrameSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeH265RateControlLayerInfoKHR& safe_VkVideoEncodeH265RateControlLayerInfoKHR::operator=(
+    const safe_VkVideoEncodeH265RateControlLayerInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    useMinQp = copy_src.useMinQp;
+    minQp = copy_src.minQp;
+    useMaxQp = copy_src.useMaxQp;
+    maxQp = copy_src.maxQp;
+    useMaxFrameSize = copy_src.useMaxFrameSize;
+    maxFrameSize = copy_src.maxFrameSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeH265RateControlLayerInfoKHR::~safe_VkVideoEncodeH265RateControlLayerInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeH265RateControlLayerInfoKHR::initialize(const VkVideoEncodeH265RateControlLayerInfoKHR* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    useMinQp = in_struct->useMinQp;
+    minQp = in_struct->minQp;
+    useMaxQp = in_struct->useMaxQp;
+    maxQp = in_struct->maxQp;
+    useMaxFrameSize = in_struct->useMaxFrameSize;
+    maxFrameSize = in_struct->maxFrameSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeH265RateControlLayerInfoKHR::initialize(const safe_VkVideoEncodeH265RateControlLayerInfoKHR* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    useMinQp = copy_src->useMinQp;
+    minQp = copy_src->minQp;
+    useMaxQp = copy_src->useMaxQp;
+    maxQp = copy_src->maxQp;
+    useMaxFrameSize = copy_src->useMaxFrameSize;
+    maxFrameSize = copy_src->maxFrameSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeH265GopRemainingFrameInfoKHR::safe_VkVideoEncodeH265GopRemainingFrameInfoKHR(
+    const VkVideoEncodeH265GopRemainingFrameInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      useGopRemainingFrames(in_struct->useGopRemainingFrames),
+      gopRemainingI(in_struct->gopRemainingI),
+      gopRemainingP(in_struct->gopRemainingP),
+      gopRemainingB(in_struct->gopRemainingB) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeH265GopRemainingFrameInfoKHR::safe_VkVideoEncodeH265GopRemainingFrameInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR),
+      pNext(nullptr),
+      useGopRemainingFrames(),
+      gopRemainingI(),
+      gopRemainingP(),
+      gopRemainingB() {}
+
+safe_VkVideoEncodeH265GopRemainingFrameInfoKHR::safe_VkVideoEncodeH265GopRemainingFrameInfoKHR(
+    const safe_VkVideoEncodeH265GopRemainingFrameInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    useGopRemainingFrames = copy_src.useGopRemainingFrames;
+    gopRemainingI = copy_src.gopRemainingI;
+    gopRemainingP = copy_src.gopRemainingP;
+    gopRemainingB = copy_src.gopRemainingB;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeH265GopRemainingFrameInfoKHR& safe_VkVideoEncodeH265GopRemainingFrameInfoKHR::operator=(
+    const safe_VkVideoEncodeH265GopRemainingFrameInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    useGopRemainingFrames = copy_src.useGopRemainingFrames;
+    gopRemainingI = copy_src.gopRemainingI;
+    gopRemainingP = copy_src.gopRemainingP;
+    gopRemainingB = copy_src.gopRemainingB;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeH265GopRemainingFrameInfoKHR::~safe_VkVideoEncodeH265GopRemainingFrameInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeH265GopRemainingFrameInfoKHR::initialize(const VkVideoEncodeH265GopRemainingFrameInfoKHR* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    useGopRemainingFrames = in_struct->useGopRemainingFrames;
+    gopRemainingI = in_struct->gopRemainingI;
+    gopRemainingP = in_struct->gopRemainingP;
+    gopRemainingB = in_struct->gopRemainingB;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeH265GopRemainingFrameInfoKHR::initialize(const safe_VkVideoEncodeH265GopRemainingFrameInfoKHR* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    useGopRemainingFrames = copy_src->useGopRemainingFrames;
+    gopRemainingI = copy_src->gopRemainingI;
+    gopRemainingP = copy_src->gopRemainingP;
+    gopRemainingB = copy_src->gopRemainingB;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoDecodeH264ProfileInfoKHR::safe_VkVideoDecodeH264ProfileInfoKHR(const VkVideoDecodeH264ProfileInfoKHR* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), stdProfileIdc(in_struct->stdProfileIdc), pictureLayout(in_struct->pictureLayout) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoDecodeH264ProfileInfoKHR::safe_VkVideoDecodeH264ProfileInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR), pNext(nullptr), stdProfileIdc(), pictureLayout() {}
+
+safe_VkVideoDecodeH264ProfileInfoKHR::safe_VkVideoDecodeH264ProfileInfoKHR(const safe_VkVideoDecodeH264ProfileInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    stdProfileIdc = copy_src.stdProfileIdc;
+    pictureLayout = copy_src.pictureLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoDecodeH264ProfileInfoKHR& safe_VkVideoDecodeH264ProfileInfoKHR::operator=(
+    const safe_VkVideoDecodeH264ProfileInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    stdProfileIdc = copy_src.stdProfileIdc;
+    pictureLayout = copy_src.pictureLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoDecodeH264ProfileInfoKHR::~safe_VkVideoDecodeH264ProfileInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoDecodeH264ProfileInfoKHR::initialize(const VkVideoDecodeH264ProfileInfoKHR* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    stdProfileIdc = in_struct->stdProfileIdc;
+    pictureLayout = in_struct->pictureLayout;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoDecodeH264ProfileInfoKHR::initialize(const safe_VkVideoDecodeH264ProfileInfoKHR* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stdProfileIdc = copy_src->stdProfileIdc;
+    pictureLayout = copy_src->pictureLayout;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoDecodeH264CapabilitiesKHR::safe_VkVideoDecodeH264CapabilitiesKHR(const VkVideoDecodeH264CapabilitiesKHR* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType), maxLevelIdc(in_struct->maxLevelIdc), fieldOffsetGranularity(in_struct->fieldOffsetGranularity) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoDecodeH264CapabilitiesKHR::safe_VkVideoDecodeH264CapabilitiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR), pNext(nullptr), maxLevelIdc(), fieldOffsetGranularity() {}
+
+safe_VkVideoDecodeH264CapabilitiesKHR::safe_VkVideoDecodeH264CapabilitiesKHR(
+    const safe_VkVideoDecodeH264CapabilitiesKHR& copy_src) {
+    sType = copy_src.sType;
+    maxLevelIdc = copy_src.maxLevelIdc;
+    fieldOffsetGranularity = copy_src.fieldOffsetGranularity;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoDecodeH264CapabilitiesKHR& safe_VkVideoDecodeH264CapabilitiesKHR::operator=(
+    const safe_VkVideoDecodeH264CapabilitiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxLevelIdc = copy_src.maxLevelIdc;
+    fieldOffsetGranularity = copy_src.fieldOffsetGranularity;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoDecodeH264CapabilitiesKHR::~safe_VkVideoDecodeH264CapabilitiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoDecodeH264CapabilitiesKHR::initialize(const VkVideoDecodeH264CapabilitiesKHR* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxLevelIdc = in_struct->maxLevelIdc;
+    fieldOffsetGranularity = in_struct->fieldOffsetGranularity;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoDecodeH264CapabilitiesKHR::initialize(const safe_VkVideoDecodeH264CapabilitiesKHR* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxLevelIdc = copy_src->maxLevelIdc;
+    fieldOffsetGranularity = copy_src->fieldOffsetGranularity;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoDecodeH264SessionParametersAddInfoKHR::safe_VkVideoDecodeH264SessionParametersAddInfoKHR(
+    const VkVideoDecodeH264SessionParametersAddInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      stdSPSCount(in_struct->stdSPSCount),
+      pStdSPSs(nullptr),
+      stdPPSCount(in_struct->stdPPSCount),
+      pStdPPSs(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pStdSPSs) {
+        pStdSPSs = new StdVideoH264SequenceParameterSet[in_struct->stdSPSCount];
+        memcpy((void*)pStdSPSs, (void*)in_struct->pStdSPSs, sizeof(StdVideoH264SequenceParameterSet) * in_struct->stdSPSCount);
+    }
+
+    if (in_struct->pStdPPSs) {
+        pStdPPSs = new StdVideoH264PictureParameterSet[in_struct->stdPPSCount];
+        memcpy((void*)pStdPPSs, (void*)in_struct->pStdPPSs, sizeof(StdVideoH264PictureParameterSet) * in_struct->stdPPSCount);
+    }
+}
+
+safe_VkVideoDecodeH264SessionParametersAddInfoKHR::safe_VkVideoDecodeH264SessionParametersAddInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR),
+      pNext(nullptr),
+      stdSPSCount(),
+      pStdSPSs(nullptr),
+      stdPPSCount(),
+      pStdPPSs(nullptr) {}
+
+safe_VkVideoDecodeH264SessionParametersAddInfoKHR::safe_VkVideoDecodeH264SessionParametersAddInfoKHR(
+    const safe_VkVideoDecodeH264SessionParametersAddInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    stdSPSCount = copy_src.stdSPSCount;
+    pStdSPSs = nullptr;
+    stdPPSCount = copy_src.stdPPSCount;
+    pStdPPSs = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdSPSs) {
+        pStdSPSs = new StdVideoH264SequenceParameterSet[copy_src.stdSPSCount];
+        memcpy((void*)pStdSPSs, (void*)copy_src.pStdSPSs, sizeof(StdVideoH264SequenceParameterSet) * copy_src.stdSPSCount);
+    }
+
+    if (copy_src.pStdPPSs) {
+        pStdPPSs = new StdVideoH264PictureParameterSet[copy_src.stdPPSCount];
+        memcpy((void*)pStdPPSs, (void*)copy_src.pStdPPSs, sizeof(StdVideoH264PictureParameterSet) * copy_src.stdPPSCount);
+    }
+}
+
+safe_VkVideoDecodeH264SessionParametersAddInfoKHR& safe_VkVideoDecodeH264SessionParametersAddInfoKHR::operator=(
+    const safe_VkVideoDecodeH264SessionParametersAddInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pStdSPSs) delete[] pStdSPSs;
+    if (pStdPPSs) delete[] pStdPPSs;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    stdSPSCount = copy_src.stdSPSCount;
+    pStdSPSs = nullptr;
+    stdPPSCount = copy_src.stdPPSCount;
+    pStdPPSs = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdSPSs) {
+        pStdSPSs = new StdVideoH264SequenceParameterSet[copy_src.stdSPSCount];
+        memcpy((void*)pStdSPSs, (void*)copy_src.pStdSPSs, sizeof(StdVideoH264SequenceParameterSet) * copy_src.stdSPSCount);
+    }
+
+    if (copy_src.pStdPPSs) {
+        pStdPPSs = new StdVideoH264PictureParameterSet[copy_src.stdPPSCount];
+        memcpy((void*)pStdPPSs, (void*)copy_src.pStdPPSs, sizeof(StdVideoH264PictureParameterSet) * copy_src.stdPPSCount);
+    }
+
+    return *this;
+}
+
+safe_VkVideoDecodeH264SessionParametersAddInfoKHR::~safe_VkVideoDecodeH264SessionParametersAddInfoKHR() {
+    if (pStdSPSs) delete[] pStdSPSs;
+    if (pStdPPSs) delete[] pStdPPSs;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoDecodeH264SessionParametersAddInfoKHR::initialize(const VkVideoDecodeH264SessionParametersAddInfoKHR* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pStdSPSs) delete[] pStdSPSs;
+    if (pStdPPSs) delete[] pStdPPSs;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    stdSPSCount = in_struct->stdSPSCount;
+    pStdSPSs = nullptr;
+    stdPPSCount = in_struct->stdPPSCount;
+    pStdPPSs = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pStdSPSs) {
+        pStdSPSs = new StdVideoH264SequenceParameterSet[in_struct->stdSPSCount];
+        memcpy((void*)pStdSPSs, (void*)in_struct->pStdSPSs, sizeof(StdVideoH264SequenceParameterSet) * in_struct->stdSPSCount);
+    }
+
+    if (in_struct->pStdPPSs) {
+        pStdPPSs = new StdVideoH264PictureParameterSet[in_struct->stdPPSCount];
+        memcpy((void*)pStdPPSs, (void*)in_struct->pStdPPSs, sizeof(StdVideoH264PictureParameterSet) * in_struct->stdPPSCount);
+    }
+}
+
+void safe_VkVideoDecodeH264SessionParametersAddInfoKHR::initialize(
+    const safe_VkVideoDecodeH264SessionParametersAddInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stdSPSCount = copy_src->stdSPSCount;
+    pStdSPSs = nullptr;
+    stdPPSCount = copy_src->stdPPSCount;
+    pStdPPSs = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pStdSPSs) {
+        pStdSPSs = new StdVideoH264SequenceParameterSet[copy_src->stdSPSCount];
+        memcpy((void*)pStdSPSs, (void*)copy_src->pStdSPSs, sizeof(StdVideoH264SequenceParameterSet) * copy_src->stdSPSCount);
+    }
+
+    if (copy_src->pStdPPSs) {
+        pStdPPSs = new StdVideoH264PictureParameterSet[copy_src->stdPPSCount];
+        memcpy((void*)pStdPPSs, (void*)copy_src->pStdPPSs, sizeof(StdVideoH264PictureParameterSet) * copy_src->stdPPSCount);
+    }
+}
+
+safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::safe_VkVideoDecodeH264SessionParametersCreateInfoKHR(
+    const VkVideoDecodeH264SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      maxStdSPSCount(in_struct->maxStdSPSCount),
+      maxStdPPSCount(in_struct->maxStdPPSCount),
+      pParametersAddInfo(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pParametersAddInfo)
+        pParametersAddInfo = new safe_VkVideoDecodeH264SessionParametersAddInfoKHR(in_struct->pParametersAddInfo);
+}
+
+safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::safe_VkVideoDecodeH264SessionParametersCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR),
+      pNext(nullptr),
+      maxStdSPSCount(),
+      maxStdPPSCount(),
+      pParametersAddInfo(nullptr) {}
+
+safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::safe_VkVideoDecodeH264SessionParametersCreateInfoKHR(
+    const safe_VkVideoDecodeH264SessionParametersCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    maxStdSPSCount = copy_src.maxStdSPSCount;
+    maxStdPPSCount = copy_src.maxStdPPSCount;
+    pParametersAddInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pParametersAddInfo)
+        pParametersAddInfo = new safe_VkVideoDecodeH264SessionParametersAddInfoKHR(*copy_src.pParametersAddInfo);
+}
+
+safe_VkVideoDecodeH264SessionParametersCreateInfoKHR& safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::operator=(
+    const safe_VkVideoDecodeH264SessionParametersCreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pParametersAddInfo) delete pParametersAddInfo;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxStdSPSCount = copy_src.maxStdSPSCount;
+    maxStdPPSCount = copy_src.maxStdPPSCount;
+    pParametersAddInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pParametersAddInfo)
+        pParametersAddInfo = new safe_VkVideoDecodeH264SessionParametersAddInfoKHR(*copy_src.pParametersAddInfo);
+
+    return *this;
+}
+
+safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::~safe_VkVideoDecodeH264SessionParametersCreateInfoKHR() {
+    if (pParametersAddInfo) delete pParametersAddInfo;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::initialize(
+    const VkVideoDecodeH264SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pParametersAddInfo) delete pParametersAddInfo;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxStdSPSCount = in_struct->maxStdSPSCount;
+    maxStdPPSCount = in_struct->maxStdPPSCount;
+    pParametersAddInfo = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (in_struct->pParametersAddInfo)
+        pParametersAddInfo = new safe_VkVideoDecodeH264SessionParametersAddInfoKHR(in_struct->pParametersAddInfo);
+}
+
+void safe_VkVideoDecodeH264SessionParametersCreateInfoKHR::initialize(
+    const safe_VkVideoDecodeH264SessionParametersCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxStdSPSCount = copy_src->maxStdSPSCount;
+    maxStdPPSCount = copy_src->maxStdPPSCount;
+    pParametersAddInfo = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (copy_src->pParametersAddInfo)
+        pParametersAddInfo = new safe_VkVideoDecodeH264SessionParametersAddInfoKHR(*copy_src->pParametersAddInfo);
+}
+
+safe_VkVideoDecodeH264PictureInfoKHR::safe_VkVideoDecodeH264PictureInfoKHR(const VkVideoDecodeH264PictureInfoKHR* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), pStdPictureInfo(nullptr), sliceCount(in_struct->sliceCount), pSliceOffsets(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoDecodeH264PictureInfo(*in_struct->pStdPictureInfo);
+    }
+
+    if (in_struct->pSliceOffsets) {
+        pSliceOffsets = new uint32_t[in_struct->sliceCount];
+        memcpy((void*)pSliceOffsets, (void*)in_struct->pSliceOffsets, sizeof(uint32_t) * in_struct->sliceCount);
+    }
+}
+
+safe_VkVideoDecodeH264PictureInfoKHR::safe_VkVideoDecodeH264PictureInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR),
+      pNext(nullptr),
+      pStdPictureInfo(nullptr),
+      sliceCount(),
+      pSliceOffsets(nullptr) {}
+
+safe_VkVideoDecodeH264PictureInfoKHR::safe_VkVideoDecodeH264PictureInfoKHR(const safe_VkVideoDecodeH264PictureInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pStdPictureInfo = nullptr;
+    sliceCount = copy_src.sliceCount;
+    pSliceOffsets = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoDecodeH264PictureInfo(*copy_src.pStdPictureInfo);
+    }
+
+    if (copy_src.pSliceOffsets) {
+        pSliceOffsets = new uint32_t[copy_src.sliceCount];
+        memcpy((void*)pSliceOffsets, (void*)copy_src.pSliceOffsets, sizeof(uint32_t) * copy_src.sliceCount);
+    }
+}
+
+safe_VkVideoDecodeH264PictureInfoKHR& safe_VkVideoDecodeH264PictureInfoKHR::operator=(
+    const safe_VkVideoDecodeH264PictureInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pStdPictureInfo) delete pStdPictureInfo;
+    if (pSliceOffsets) delete[] pSliceOffsets;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pStdPictureInfo = nullptr;
+    sliceCount = copy_src.sliceCount;
+    pSliceOffsets = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoDecodeH264PictureInfo(*copy_src.pStdPictureInfo);
+    }
+
+    if (copy_src.pSliceOffsets) {
+        pSliceOffsets = new uint32_t[copy_src.sliceCount];
+        memcpy((void*)pSliceOffsets, (void*)copy_src.pSliceOffsets, sizeof(uint32_t) * copy_src.sliceCount);
+    }
+
+    return *this;
+}
+
+safe_VkVideoDecodeH264PictureInfoKHR::~safe_VkVideoDecodeH264PictureInfoKHR() {
+    if (pStdPictureInfo) delete pStdPictureInfo;
+    if (pSliceOffsets) delete[] pSliceOffsets;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoDecodeH264PictureInfoKHR::initialize(const VkVideoDecodeH264PictureInfoKHR* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pStdPictureInfo) delete pStdPictureInfo;
+    if (pSliceOffsets) delete[] pSliceOffsets;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pStdPictureInfo = nullptr;
+    sliceCount = in_struct->sliceCount;
+    pSliceOffsets = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoDecodeH264PictureInfo(*in_struct->pStdPictureInfo);
+    }
+
+    if (in_struct->pSliceOffsets) {
+        pSliceOffsets = new uint32_t[in_struct->sliceCount];
+        memcpy((void*)pSliceOffsets, (void*)in_struct->pSliceOffsets, sizeof(uint32_t) * in_struct->sliceCount);
+    }
+}
+
+void safe_VkVideoDecodeH264PictureInfoKHR::initialize(const safe_VkVideoDecodeH264PictureInfoKHR* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pStdPictureInfo = nullptr;
+    sliceCount = copy_src->sliceCount;
+    pSliceOffsets = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoDecodeH264PictureInfo(*copy_src->pStdPictureInfo);
+    }
+
+    if (copy_src->pSliceOffsets) {
+        pSliceOffsets = new uint32_t[copy_src->sliceCount];
+        memcpy((void*)pSliceOffsets, (void*)copy_src->pSliceOffsets, sizeof(uint32_t) * copy_src->sliceCount);
+    }
+}
+
+safe_VkVideoDecodeH264DpbSlotInfoKHR::safe_VkVideoDecodeH264DpbSlotInfoKHR(const VkVideoDecodeH264DpbSlotInfoKHR* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), pStdReferenceInfo(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoDecodeH264ReferenceInfo(*in_struct->pStdReferenceInfo);
+    }
+}
+
+safe_VkVideoDecodeH264DpbSlotInfoKHR::safe_VkVideoDecodeH264DpbSlotInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR), pNext(nullptr), pStdReferenceInfo(nullptr) {}
+
+safe_VkVideoDecodeH264DpbSlotInfoKHR::safe_VkVideoDecodeH264DpbSlotInfoKHR(const safe_VkVideoDecodeH264DpbSlotInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pStdReferenceInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoDecodeH264ReferenceInfo(*copy_src.pStdReferenceInfo);
+    }
+}
+
+safe_VkVideoDecodeH264DpbSlotInfoKHR& safe_VkVideoDecodeH264DpbSlotInfoKHR::operator=(
+    const safe_VkVideoDecodeH264DpbSlotInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pStdReferenceInfo) delete pStdReferenceInfo;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pStdReferenceInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoDecodeH264ReferenceInfo(*copy_src.pStdReferenceInfo);
+    }
+
+    return *this;
+}
+
+safe_VkVideoDecodeH264DpbSlotInfoKHR::~safe_VkVideoDecodeH264DpbSlotInfoKHR() {
+    if (pStdReferenceInfo) delete pStdReferenceInfo;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoDecodeH264DpbSlotInfoKHR::initialize(const VkVideoDecodeH264DpbSlotInfoKHR* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pStdReferenceInfo) delete pStdReferenceInfo;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pStdReferenceInfo = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoDecodeH264ReferenceInfo(*in_struct->pStdReferenceInfo);
+    }
+}
+
+void safe_VkVideoDecodeH264DpbSlotInfoKHR::initialize(const safe_VkVideoDecodeH264DpbSlotInfoKHR* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pStdReferenceInfo = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoDecodeH264ReferenceInfo(*copy_src->pStdReferenceInfo);
+    }
+}
+
+safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::safe_VkRenderingFragmentShadingRateAttachmentInfoKHR(
+    const VkRenderingFragmentShadingRateAttachmentInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      imageView(in_struct->imageView),
+      imageLayout(in_struct->imageLayout),
+      shadingRateAttachmentTexelSize(in_struct->shadingRateAttachmentTexelSize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::safe_VkRenderingFragmentShadingRateAttachmentInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR),
+      pNext(nullptr),
+      imageView(),
+      imageLayout(),
+      shadingRateAttachmentTexelSize() {}
+
+safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::safe_VkRenderingFragmentShadingRateAttachmentInfoKHR(
+    const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    imageView = copy_src.imageView;
+    imageLayout = copy_src.imageLayout;
+    shadingRateAttachmentTexelSize = copy_src.shadingRateAttachmentTexelSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::operator=(
+    const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    imageView = copy_src.imageView;
+    imageLayout = copy_src.imageLayout;
+    shadingRateAttachmentTexelSize = copy_src.shadingRateAttachmentTexelSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::~safe_VkRenderingFragmentShadingRateAttachmentInfoKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::initialize(
+    const VkRenderingFragmentShadingRateAttachmentInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    imageView = in_struct->imageView;
+    imageLayout = in_struct->imageLayout;
+    shadingRateAttachmentTexelSize = in_struct->shadingRateAttachmentTexelSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::initialize(
+    const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imageView = copy_src->imageView;
+    imageLayout = copy_src->imageLayout;
+    shadingRateAttachmentTexelSize = copy_src->shadingRateAttachmentTexelSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+safe_VkImportMemoryWin32HandleInfoKHR::safe_VkImportMemoryWin32HandleInfoKHR(const VkImportMemoryWin32HandleInfoKHR* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType), handleType(in_struct->handleType), handle(in_struct->handle), name(in_struct->name) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImportMemoryWin32HandleInfoKHR::safe_VkImportMemoryWin32HandleInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR), pNext(nullptr), handleType(), handle(), name() {}
+
+safe_VkImportMemoryWin32HandleInfoKHR::safe_VkImportMemoryWin32HandleInfoKHR(
+    const safe_VkImportMemoryWin32HandleInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    handleType = copy_src.handleType;
+    handle = copy_src.handle;
+    name = copy_src.name;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImportMemoryWin32HandleInfoKHR& safe_VkImportMemoryWin32HandleInfoKHR::operator=(
+    const safe_VkImportMemoryWin32HandleInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    handleType = copy_src.handleType;
+    handle = copy_src.handle;
+    name = copy_src.name;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImportMemoryWin32HandleInfoKHR::~safe_VkImportMemoryWin32HandleInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkImportMemoryWin32HandleInfoKHR::initialize(const VkImportMemoryWin32HandleInfoKHR* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    handleType = in_struct->handleType;
+    handle = in_struct->handle;
+    name = in_struct->name;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImportMemoryWin32HandleInfoKHR::initialize(const safe_VkImportMemoryWin32HandleInfoKHR* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    handleType = copy_src->handleType;
+    handle = copy_src->handle;
+    name = copy_src->name;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkExportMemoryWin32HandleInfoKHR::safe_VkExportMemoryWin32HandleInfoKHR(const VkExportMemoryWin32HandleInfoKHR* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType), pAttributes(nullptr), dwAccess(in_struct->dwAccess), name(in_struct->name) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pAttributes) {
+        pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
+    }
+}
+
+safe_VkExportMemoryWin32HandleInfoKHR::safe_VkExportMemoryWin32HandleInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR), pNext(nullptr), pAttributes(nullptr), dwAccess(), name() {}
+
+safe_VkExportMemoryWin32HandleInfoKHR::safe_VkExportMemoryWin32HandleInfoKHR(
+    const safe_VkExportMemoryWin32HandleInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pAttributes = nullptr;
+    dwAccess = copy_src.dwAccess;
+    name = copy_src.name;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pAttributes) {
+        pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes);
+    }
+}
+
+safe_VkExportMemoryWin32HandleInfoKHR& safe_VkExportMemoryWin32HandleInfoKHR::operator=(
+    const safe_VkExportMemoryWin32HandleInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pAttributes) delete pAttributes;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pAttributes = nullptr;
+    dwAccess = copy_src.dwAccess;
+    name = copy_src.name;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pAttributes) {
+        pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes);
+    }
+
+    return *this;
+}
+
+safe_VkExportMemoryWin32HandleInfoKHR::~safe_VkExportMemoryWin32HandleInfoKHR() {
+    if (pAttributes) delete pAttributes;
+    FreePnextChain(pNext);
+}
+
+void safe_VkExportMemoryWin32HandleInfoKHR::initialize(const VkExportMemoryWin32HandleInfoKHR* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pAttributes) delete pAttributes;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pAttributes = nullptr;
+    dwAccess = in_struct->dwAccess;
+    name = in_struct->name;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pAttributes) {
+        pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
+    }
+}
+
+void safe_VkExportMemoryWin32HandleInfoKHR::initialize(const safe_VkExportMemoryWin32HandleInfoKHR* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pAttributes = nullptr;
+    dwAccess = copy_src->dwAccess;
+    name = copy_src->name;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pAttributes) {
+        pAttributes = new SECURITY_ATTRIBUTES(*copy_src->pAttributes);
+    }
+}
+
+safe_VkMemoryWin32HandlePropertiesKHR::safe_VkMemoryWin32HandlePropertiesKHR(const VkMemoryWin32HandlePropertiesKHR* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType), memoryTypeBits(in_struct->memoryTypeBits) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMemoryWin32HandlePropertiesKHR::safe_VkMemoryWin32HandlePropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR), pNext(nullptr), memoryTypeBits() {}
+
+safe_VkMemoryWin32HandlePropertiesKHR::safe_VkMemoryWin32HandlePropertiesKHR(
+    const safe_VkMemoryWin32HandlePropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    memoryTypeBits = copy_src.memoryTypeBits;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMemoryWin32HandlePropertiesKHR& safe_VkMemoryWin32HandlePropertiesKHR::operator=(
+    const safe_VkMemoryWin32HandlePropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    memoryTypeBits = copy_src.memoryTypeBits;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMemoryWin32HandlePropertiesKHR::~safe_VkMemoryWin32HandlePropertiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkMemoryWin32HandlePropertiesKHR::initialize(const VkMemoryWin32HandlePropertiesKHR* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    memoryTypeBits = in_struct->memoryTypeBits;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMemoryWin32HandlePropertiesKHR::initialize(const safe_VkMemoryWin32HandlePropertiesKHR* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memoryTypeBits = copy_src->memoryTypeBits;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkMemoryGetWin32HandleInfoKHR::safe_VkMemoryGetWin32HandleInfoKHR(const VkMemoryGetWin32HandleInfoKHR* in_struct,
+                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), memory(in_struct->memory), handleType(in_struct->handleType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMemoryGetWin32HandleInfoKHR::safe_VkMemoryGetWin32HandleInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR), pNext(nullptr), memory(), handleType() {}
+
+safe_VkMemoryGetWin32HandleInfoKHR::safe_VkMemoryGetWin32HandleInfoKHR(const safe_VkMemoryGetWin32HandleInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    memory = copy_src.memory;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMemoryGetWin32HandleInfoKHR& safe_VkMemoryGetWin32HandleInfoKHR::operator=(
+    const safe_VkMemoryGetWin32HandleInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    memory = copy_src.memory;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMemoryGetWin32HandleInfoKHR::~safe_VkMemoryGetWin32HandleInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkMemoryGetWin32HandleInfoKHR::initialize(const VkMemoryGetWin32HandleInfoKHR* in_struct,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    memory = in_struct->memory;
+    handleType = in_struct->handleType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMemoryGetWin32HandleInfoKHR::initialize(const safe_VkMemoryGetWin32HandleInfoKHR* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memory = copy_src->memory;
+    handleType = copy_src->handleType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+
+safe_VkImportMemoryFdInfoKHR::safe_VkImportMemoryFdInfoKHR(const VkImportMemoryFdInfoKHR* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), handleType(in_struct->handleType), fd(in_struct->fd) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImportMemoryFdInfoKHR::safe_VkImportMemoryFdInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR), pNext(nullptr), handleType(), fd() {}
+
+safe_VkImportMemoryFdInfoKHR::safe_VkImportMemoryFdInfoKHR(const safe_VkImportMemoryFdInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    handleType = copy_src.handleType;
+    fd = copy_src.fd;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImportMemoryFdInfoKHR& safe_VkImportMemoryFdInfoKHR::operator=(const safe_VkImportMemoryFdInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    handleType = copy_src.handleType;
+    fd = copy_src.fd;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImportMemoryFdInfoKHR::~safe_VkImportMemoryFdInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkImportMemoryFdInfoKHR::initialize(const VkImportMemoryFdInfoKHR* in_struct,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    handleType = in_struct->handleType;
+    fd = in_struct->fd;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImportMemoryFdInfoKHR::initialize(const safe_VkImportMemoryFdInfoKHR* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    handleType = copy_src->handleType;
+    fd = copy_src->fd;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkMemoryFdPropertiesKHR::safe_VkMemoryFdPropertiesKHR(const VkMemoryFdPropertiesKHR* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), memoryTypeBits(in_struct->memoryTypeBits) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMemoryFdPropertiesKHR::safe_VkMemoryFdPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR), pNext(nullptr), memoryTypeBits() {}
+
+safe_VkMemoryFdPropertiesKHR::safe_VkMemoryFdPropertiesKHR(const safe_VkMemoryFdPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    memoryTypeBits = copy_src.memoryTypeBits;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMemoryFdPropertiesKHR& safe_VkMemoryFdPropertiesKHR::operator=(const safe_VkMemoryFdPropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    memoryTypeBits = copy_src.memoryTypeBits;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMemoryFdPropertiesKHR::~safe_VkMemoryFdPropertiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkMemoryFdPropertiesKHR::initialize(const VkMemoryFdPropertiesKHR* in_struct,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    memoryTypeBits = in_struct->memoryTypeBits;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMemoryFdPropertiesKHR::initialize(const safe_VkMemoryFdPropertiesKHR* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memoryTypeBits = copy_src->memoryTypeBits;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkMemoryGetFdInfoKHR::safe_VkMemoryGetFdInfoKHR(const VkMemoryGetFdInfoKHR* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), memory(in_struct->memory), handleType(in_struct->handleType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMemoryGetFdInfoKHR::safe_VkMemoryGetFdInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR), pNext(nullptr), memory(), handleType() {}
+
+safe_VkMemoryGetFdInfoKHR::safe_VkMemoryGetFdInfoKHR(const safe_VkMemoryGetFdInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    memory = copy_src.memory;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMemoryGetFdInfoKHR& safe_VkMemoryGetFdInfoKHR::operator=(const safe_VkMemoryGetFdInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    memory = copy_src.memory;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMemoryGetFdInfoKHR::~safe_VkMemoryGetFdInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkMemoryGetFdInfoKHR::initialize(const VkMemoryGetFdInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    memory = in_struct->memory;
+    handleType = in_struct->handleType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMemoryGetFdInfoKHR::initialize(const safe_VkMemoryGetFdInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memory = copy_src->memory;
+    handleType = copy_src->handleType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(
+    const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      acquireCount(in_struct->acquireCount),
+      pAcquireSyncs(nullptr),
+      pAcquireKeys(nullptr),
+      pAcquireTimeouts(nullptr),
+      releaseCount(in_struct->releaseCount),
+      pReleaseSyncs(nullptr),
+      pReleaseKeys(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (acquireCount && in_struct->pAcquireSyncs) {
+        pAcquireSyncs = new VkDeviceMemory[acquireCount];
+        for (uint32_t i = 0; i < acquireCount; ++i) {
+            pAcquireSyncs[i] = in_struct->pAcquireSyncs[i];
+        }
+    }
+
+    if (in_struct->pAcquireKeys) {
+        pAcquireKeys = new uint64_t[in_struct->acquireCount];
+        memcpy((void*)pAcquireKeys, (void*)in_struct->pAcquireKeys, sizeof(uint64_t) * in_struct->acquireCount);
+    }
+
+    if (in_struct->pAcquireTimeouts) {
+        pAcquireTimeouts = new uint32_t[in_struct->acquireCount];
+        memcpy((void*)pAcquireTimeouts, (void*)in_struct->pAcquireTimeouts, sizeof(uint32_t) * in_struct->acquireCount);
+    }
+    if (releaseCount && in_struct->pReleaseSyncs) {
+        pReleaseSyncs = new VkDeviceMemory[releaseCount];
+        for (uint32_t i = 0; i < releaseCount; ++i) {
+            pReleaseSyncs[i] = in_struct->pReleaseSyncs[i];
+        }
+    }
+
+    if (in_struct->pReleaseKeys) {
+        pReleaseKeys = new uint64_t[in_struct->releaseCount];
+        memcpy((void*)pReleaseKeys, (void*)in_struct->pReleaseKeys, sizeof(uint64_t) * in_struct->releaseCount);
+    }
+}
+
+safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::safe_VkWin32KeyedMutexAcquireReleaseInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR),
+      pNext(nullptr),
+      acquireCount(),
+      pAcquireSyncs(nullptr),
+      pAcquireKeys(nullptr),
+      pAcquireTimeouts(nullptr),
+      releaseCount(),
+      pReleaseSyncs(nullptr),
+      pReleaseKeys(nullptr) {}
+
+safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(
+    const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    acquireCount = copy_src.acquireCount;
+    pAcquireSyncs = nullptr;
+    pAcquireKeys = nullptr;
+    pAcquireTimeouts = nullptr;
+    releaseCount = copy_src.releaseCount;
+    pReleaseSyncs = nullptr;
+    pReleaseKeys = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (acquireCount && copy_src.pAcquireSyncs) {
+        pAcquireSyncs = new VkDeviceMemory[acquireCount];
+        for (uint32_t i = 0; i < acquireCount; ++i) {
+            pAcquireSyncs[i] = copy_src.pAcquireSyncs[i];
+        }
+    }
+
+    if (copy_src.pAcquireKeys) {
+        pAcquireKeys = new uint64_t[copy_src.acquireCount];
+        memcpy((void*)pAcquireKeys, (void*)copy_src.pAcquireKeys, sizeof(uint64_t) * copy_src.acquireCount);
+    }
+
+    if (copy_src.pAcquireTimeouts) {
+        pAcquireTimeouts = new uint32_t[copy_src.acquireCount];
+        memcpy((void*)pAcquireTimeouts, (void*)copy_src.pAcquireTimeouts, sizeof(uint32_t) * copy_src.acquireCount);
+    }
+    if (releaseCount && copy_src.pReleaseSyncs) {
+        pReleaseSyncs = new VkDeviceMemory[releaseCount];
+        for (uint32_t i = 0; i < releaseCount; ++i) {
+            pReleaseSyncs[i] = copy_src.pReleaseSyncs[i];
+        }
+    }
+
+    if (copy_src.pReleaseKeys) {
+        pReleaseKeys = new uint64_t[copy_src.releaseCount];
+        memcpy((void*)pReleaseKeys, (void*)copy_src.pReleaseKeys, sizeof(uint64_t) * copy_src.releaseCount);
+    }
+}
+
+safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::operator=(
+    const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pAcquireSyncs) delete[] pAcquireSyncs;
+    if (pAcquireKeys) delete[] pAcquireKeys;
+    if (pAcquireTimeouts) delete[] pAcquireTimeouts;
+    if (pReleaseSyncs) delete[] pReleaseSyncs;
+    if (pReleaseKeys) delete[] pReleaseKeys;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    acquireCount = copy_src.acquireCount;
+    pAcquireSyncs = nullptr;
+    pAcquireKeys = nullptr;
+    pAcquireTimeouts = nullptr;
+    releaseCount = copy_src.releaseCount;
+    pReleaseSyncs = nullptr;
+    pReleaseKeys = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (acquireCount && copy_src.pAcquireSyncs) {
+        pAcquireSyncs = new VkDeviceMemory[acquireCount];
+        for (uint32_t i = 0; i < acquireCount; ++i) {
+            pAcquireSyncs[i] = copy_src.pAcquireSyncs[i];
+        }
+    }
+
+    if (copy_src.pAcquireKeys) {
+        pAcquireKeys = new uint64_t[copy_src.acquireCount];
+        memcpy((void*)pAcquireKeys, (void*)copy_src.pAcquireKeys, sizeof(uint64_t) * copy_src.acquireCount);
+    }
+
+    if (copy_src.pAcquireTimeouts) {
+        pAcquireTimeouts = new uint32_t[copy_src.acquireCount];
+        memcpy((void*)pAcquireTimeouts, (void*)copy_src.pAcquireTimeouts, sizeof(uint32_t) * copy_src.acquireCount);
+    }
+    if (releaseCount && copy_src.pReleaseSyncs) {
+        pReleaseSyncs = new VkDeviceMemory[releaseCount];
+        for (uint32_t i = 0; i < releaseCount; ++i) {
+            pReleaseSyncs[i] = copy_src.pReleaseSyncs[i];
+        }
+    }
+
+    if (copy_src.pReleaseKeys) {
+        pReleaseKeys = new uint64_t[copy_src.releaseCount];
+        memcpy((void*)pReleaseKeys, (void*)copy_src.pReleaseKeys, sizeof(uint64_t) * copy_src.releaseCount);
+    }
+
+    return *this;
+}
+
+safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::~safe_VkWin32KeyedMutexAcquireReleaseInfoKHR() {
+    if (pAcquireSyncs) delete[] pAcquireSyncs;
+    if (pAcquireKeys) delete[] pAcquireKeys;
+    if (pAcquireTimeouts) delete[] pAcquireTimeouts;
+    if (pReleaseSyncs) delete[] pReleaseSyncs;
+    if (pReleaseKeys) delete[] pReleaseKeys;
+    FreePnextChain(pNext);
+}
+
+void safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::initialize(const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pAcquireSyncs) delete[] pAcquireSyncs;
+    if (pAcquireKeys) delete[] pAcquireKeys;
+    if (pAcquireTimeouts) delete[] pAcquireTimeouts;
+    if (pReleaseSyncs) delete[] pReleaseSyncs;
+    if (pReleaseKeys) delete[] pReleaseKeys;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    acquireCount = in_struct->acquireCount;
+    pAcquireSyncs = nullptr;
+    pAcquireKeys = nullptr;
+    pAcquireTimeouts = nullptr;
+    releaseCount = in_struct->releaseCount;
+    pReleaseSyncs = nullptr;
+    pReleaseKeys = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (acquireCount && in_struct->pAcquireSyncs) {
+        pAcquireSyncs = new VkDeviceMemory[acquireCount];
+        for (uint32_t i = 0; i < acquireCount; ++i) {
+            pAcquireSyncs[i] = in_struct->pAcquireSyncs[i];
+        }
+    }
+
+    if (in_struct->pAcquireKeys) {
+        pAcquireKeys = new uint64_t[in_struct->acquireCount];
+        memcpy((void*)pAcquireKeys, (void*)in_struct->pAcquireKeys, sizeof(uint64_t) * in_struct->acquireCount);
+    }
+
+    if (in_struct->pAcquireTimeouts) {
+        pAcquireTimeouts = new uint32_t[in_struct->acquireCount];
+        memcpy((void*)pAcquireTimeouts, (void*)in_struct->pAcquireTimeouts, sizeof(uint32_t) * in_struct->acquireCount);
+    }
+    if (releaseCount && in_struct->pReleaseSyncs) {
+        pReleaseSyncs = new VkDeviceMemory[releaseCount];
+        for (uint32_t i = 0; i < releaseCount; ++i) {
+            pReleaseSyncs[i] = in_struct->pReleaseSyncs[i];
+        }
+    }
+
+    if (in_struct->pReleaseKeys) {
+        pReleaseKeys = new uint64_t[in_struct->releaseCount];
+        memcpy((void*)pReleaseKeys, (void*)in_struct->pReleaseKeys, sizeof(uint64_t) * in_struct->releaseCount);
+    }
+}
+
+void safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::initialize(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    acquireCount = copy_src->acquireCount;
+    pAcquireSyncs = nullptr;
+    pAcquireKeys = nullptr;
+    pAcquireTimeouts = nullptr;
+    releaseCount = copy_src->releaseCount;
+    pReleaseSyncs = nullptr;
+    pReleaseKeys = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (acquireCount && copy_src->pAcquireSyncs) {
+        pAcquireSyncs = new VkDeviceMemory[acquireCount];
+        for (uint32_t i = 0; i < acquireCount; ++i) {
+            pAcquireSyncs[i] = copy_src->pAcquireSyncs[i];
+        }
+    }
+
+    if (copy_src->pAcquireKeys) {
+        pAcquireKeys = new uint64_t[copy_src->acquireCount];
+        memcpy((void*)pAcquireKeys, (void*)copy_src->pAcquireKeys, sizeof(uint64_t) * copy_src->acquireCount);
+    }
+
+    if (copy_src->pAcquireTimeouts) {
+        pAcquireTimeouts = new uint32_t[copy_src->acquireCount];
+        memcpy((void*)pAcquireTimeouts, (void*)copy_src->pAcquireTimeouts, sizeof(uint32_t) * copy_src->acquireCount);
+    }
+    if (releaseCount && copy_src->pReleaseSyncs) {
+        pReleaseSyncs = new VkDeviceMemory[releaseCount];
+        for (uint32_t i = 0; i < releaseCount; ++i) {
+            pReleaseSyncs[i] = copy_src->pReleaseSyncs[i];
+        }
+    }
+
+    if (copy_src->pReleaseKeys) {
+        pReleaseKeys = new uint64_t[copy_src->releaseCount];
+        memcpy((void*)pReleaseKeys, (void*)copy_src->pReleaseKeys, sizeof(uint64_t) * copy_src->releaseCount);
+    }
+}
+
+safe_VkImportSemaphoreWin32HandleInfoKHR::safe_VkImportSemaphoreWin32HandleInfoKHR(
+    const VkImportSemaphoreWin32HandleInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      semaphore(in_struct->semaphore),
+      flags(in_struct->flags),
+      handleType(in_struct->handleType),
+      handle(in_struct->handle),
+      name(in_struct->name) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImportSemaphoreWin32HandleInfoKHR::safe_VkImportSemaphoreWin32HandleInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR),
+      pNext(nullptr),
+      semaphore(),
+      flags(),
+      handleType(),
+      handle(),
+      name() {}
+
+safe_VkImportSemaphoreWin32HandleInfoKHR::safe_VkImportSemaphoreWin32HandleInfoKHR(
+    const safe_VkImportSemaphoreWin32HandleInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    semaphore = copy_src.semaphore;
+    flags = copy_src.flags;
+    handleType = copy_src.handleType;
+    handle = copy_src.handle;
+    name = copy_src.name;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImportSemaphoreWin32HandleInfoKHR& safe_VkImportSemaphoreWin32HandleInfoKHR::operator=(
+    const safe_VkImportSemaphoreWin32HandleInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    semaphore = copy_src.semaphore;
+    flags = copy_src.flags;
+    handleType = copy_src.handleType;
+    handle = copy_src.handle;
+    name = copy_src.name;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImportSemaphoreWin32HandleInfoKHR::~safe_VkImportSemaphoreWin32HandleInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkImportSemaphoreWin32HandleInfoKHR::initialize(const VkImportSemaphoreWin32HandleInfoKHR* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    semaphore = in_struct->semaphore;
+    flags = in_struct->flags;
+    handleType = in_struct->handleType;
+    handle = in_struct->handle;
+    name = in_struct->name;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImportSemaphoreWin32HandleInfoKHR::initialize(const safe_VkImportSemaphoreWin32HandleInfoKHR* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    semaphore = copy_src->semaphore;
+    flags = copy_src->flags;
+    handleType = copy_src->handleType;
+    handle = copy_src->handle;
+    name = copy_src->name;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkExportSemaphoreWin32HandleInfoKHR::safe_VkExportSemaphoreWin32HandleInfoKHR(
+    const VkExportSemaphoreWin32HandleInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), pAttributes(nullptr), dwAccess(in_struct->dwAccess), name(in_struct->name) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pAttributes) {
+        pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
+    }
+}
+
+safe_VkExportSemaphoreWin32HandleInfoKHR::safe_VkExportSemaphoreWin32HandleInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR), pNext(nullptr), pAttributes(nullptr), dwAccess(), name() {}
+
+safe_VkExportSemaphoreWin32HandleInfoKHR::safe_VkExportSemaphoreWin32HandleInfoKHR(
+    const safe_VkExportSemaphoreWin32HandleInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pAttributes = nullptr;
+    dwAccess = copy_src.dwAccess;
+    name = copy_src.name;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pAttributes) {
+        pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes);
+    }
+}
+
+safe_VkExportSemaphoreWin32HandleInfoKHR& safe_VkExportSemaphoreWin32HandleInfoKHR::operator=(
+    const safe_VkExportSemaphoreWin32HandleInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pAttributes) delete pAttributes;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pAttributes = nullptr;
+    dwAccess = copy_src.dwAccess;
+    name = copy_src.name;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pAttributes) {
+        pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes);
+    }
+
+    return *this;
+}
+
+safe_VkExportSemaphoreWin32HandleInfoKHR::~safe_VkExportSemaphoreWin32HandleInfoKHR() {
+    if (pAttributes) delete pAttributes;
+    FreePnextChain(pNext);
+}
+
+void safe_VkExportSemaphoreWin32HandleInfoKHR::initialize(const VkExportSemaphoreWin32HandleInfoKHR* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pAttributes) delete pAttributes;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pAttributes = nullptr;
+    dwAccess = in_struct->dwAccess;
+    name = in_struct->name;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pAttributes) {
+        pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
+    }
+}
+
+void safe_VkExportSemaphoreWin32HandleInfoKHR::initialize(const safe_VkExportSemaphoreWin32HandleInfoKHR* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pAttributes = nullptr;
+    dwAccess = copy_src->dwAccess;
+    name = copy_src->name;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pAttributes) {
+        pAttributes = new SECURITY_ATTRIBUTES(*copy_src->pAttributes);
+    }
+}
+
+safe_VkD3D12FenceSubmitInfoKHR::safe_VkD3D12FenceSubmitInfoKHR(const VkD3D12FenceSubmitInfoKHR* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      waitSemaphoreValuesCount(in_struct->waitSemaphoreValuesCount),
+      pWaitSemaphoreValues(nullptr),
+      signalSemaphoreValuesCount(in_struct->signalSemaphoreValuesCount),
+      pSignalSemaphoreValues(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pWaitSemaphoreValues) {
+        pWaitSemaphoreValues = new uint64_t[in_struct->waitSemaphoreValuesCount];
+        memcpy((void*)pWaitSemaphoreValues, (void*)in_struct->pWaitSemaphoreValues,
+               sizeof(uint64_t) * in_struct->waitSemaphoreValuesCount);
+    }
+
+    if (in_struct->pSignalSemaphoreValues) {
+        pSignalSemaphoreValues = new uint64_t[in_struct->signalSemaphoreValuesCount];
+        memcpy((void*)pSignalSemaphoreValues, (void*)in_struct->pSignalSemaphoreValues,
+               sizeof(uint64_t) * in_struct->signalSemaphoreValuesCount);
+    }
+}
+
+safe_VkD3D12FenceSubmitInfoKHR::safe_VkD3D12FenceSubmitInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR),
+      pNext(nullptr),
+      waitSemaphoreValuesCount(),
+      pWaitSemaphoreValues(nullptr),
+      signalSemaphoreValuesCount(),
+      pSignalSemaphoreValues(nullptr) {}
+
+safe_VkD3D12FenceSubmitInfoKHR::safe_VkD3D12FenceSubmitInfoKHR(const safe_VkD3D12FenceSubmitInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    waitSemaphoreValuesCount = copy_src.waitSemaphoreValuesCount;
+    pWaitSemaphoreValues = nullptr;
+    signalSemaphoreValuesCount = copy_src.signalSemaphoreValuesCount;
+    pSignalSemaphoreValues = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pWaitSemaphoreValues) {
+        pWaitSemaphoreValues = new uint64_t[copy_src.waitSemaphoreValuesCount];
+        memcpy((void*)pWaitSemaphoreValues, (void*)copy_src.pWaitSemaphoreValues,
+               sizeof(uint64_t) * copy_src.waitSemaphoreValuesCount);
+    }
+
+    if (copy_src.pSignalSemaphoreValues) {
+        pSignalSemaphoreValues = new uint64_t[copy_src.signalSemaphoreValuesCount];
+        memcpy((void*)pSignalSemaphoreValues, (void*)copy_src.pSignalSemaphoreValues,
+               sizeof(uint64_t) * copy_src.signalSemaphoreValuesCount);
+    }
+}
+
+safe_VkD3D12FenceSubmitInfoKHR& safe_VkD3D12FenceSubmitInfoKHR::operator=(const safe_VkD3D12FenceSubmitInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pWaitSemaphoreValues) delete[] pWaitSemaphoreValues;
+    if (pSignalSemaphoreValues) delete[] pSignalSemaphoreValues;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    waitSemaphoreValuesCount = copy_src.waitSemaphoreValuesCount;
+    pWaitSemaphoreValues = nullptr;
+    signalSemaphoreValuesCount = copy_src.signalSemaphoreValuesCount;
+    pSignalSemaphoreValues = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pWaitSemaphoreValues) {
+        pWaitSemaphoreValues = new uint64_t[copy_src.waitSemaphoreValuesCount];
+        memcpy((void*)pWaitSemaphoreValues, (void*)copy_src.pWaitSemaphoreValues,
+               sizeof(uint64_t) * copy_src.waitSemaphoreValuesCount);
+    }
+
+    if (copy_src.pSignalSemaphoreValues) {
+        pSignalSemaphoreValues = new uint64_t[copy_src.signalSemaphoreValuesCount];
+        memcpy((void*)pSignalSemaphoreValues, (void*)copy_src.pSignalSemaphoreValues,
+               sizeof(uint64_t) * copy_src.signalSemaphoreValuesCount);
+    }
+
+    return *this;
+}
+
+safe_VkD3D12FenceSubmitInfoKHR::~safe_VkD3D12FenceSubmitInfoKHR() {
+    if (pWaitSemaphoreValues) delete[] pWaitSemaphoreValues;
+    if (pSignalSemaphoreValues) delete[] pSignalSemaphoreValues;
+    FreePnextChain(pNext);
+}
+
+void safe_VkD3D12FenceSubmitInfoKHR::initialize(const VkD3D12FenceSubmitInfoKHR* in_struct,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pWaitSemaphoreValues) delete[] pWaitSemaphoreValues;
+    if (pSignalSemaphoreValues) delete[] pSignalSemaphoreValues;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    waitSemaphoreValuesCount = in_struct->waitSemaphoreValuesCount;
+    pWaitSemaphoreValues = nullptr;
+    signalSemaphoreValuesCount = in_struct->signalSemaphoreValuesCount;
+    pSignalSemaphoreValues = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pWaitSemaphoreValues) {
+        pWaitSemaphoreValues = new uint64_t[in_struct->waitSemaphoreValuesCount];
+        memcpy((void*)pWaitSemaphoreValues, (void*)in_struct->pWaitSemaphoreValues,
+               sizeof(uint64_t) * in_struct->waitSemaphoreValuesCount);
+    }
+
+    if (in_struct->pSignalSemaphoreValues) {
+        pSignalSemaphoreValues = new uint64_t[in_struct->signalSemaphoreValuesCount];
+        memcpy((void*)pSignalSemaphoreValues, (void*)in_struct->pSignalSemaphoreValues,
+               sizeof(uint64_t) * in_struct->signalSemaphoreValuesCount);
+    }
+}
+
+void safe_VkD3D12FenceSubmitInfoKHR::initialize(const safe_VkD3D12FenceSubmitInfoKHR* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    waitSemaphoreValuesCount = copy_src->waitSemaphoreValuesCount;
+    pWaitSemaphoreValues = nullptr;
+    signalSemaphoreValuesCount = copy_src->signalSemaphoreValuesCount;
+    pSignalSemaphoreValues = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pWaitSemaphoreValues) {
+        pWaitSemaphoreValues = new uint64_t[copy_src->waitSemaphoreValuesCount];
+        memcpy((void*)pWaitSemaphoreValues, (void*)copy_src->pWaitSemaphoreValues,
+               sizeof(uint64_t) * copy_src->waitSemaphoreValuesCount);
+    }
+
+    if (copy_src->pSignalSemaphoreValues) {
+        pSignalSemaphoreValues = new uint64_t[copy_src->signalSemaphoreValuesCount];
+        memcpy((void*)pSignalSemaphoreValues, (void*)copy_src->pSignalSemaphoreValues,
+               sizeof(uint64_t) * copy_src->signalSemaphoreValuesCount);
+    }
+}
+
+safe_VkSemaphoreGetWin32HandleInfoKHR::safe_VkSemaphoreGetWin32HandleInfoKHR(const VkSemaphoreGetWin32HandleInfoKHR* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType), semaphore(in_struct->semaphore), handleType(in_struct->handleType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSemaphoreGetWin32HandleInfoKHR::safe_VkSemaphoreGetWin32HandleInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR), pNext(nullptr), semaphore(), handleType() {}
+
+safe_VkSemaphoreGetWin32HandleInfoKHR::safe_VkSemaphoreGetWin32HandleInfoKHR(
+    const safe_VkSemaphoreGetWin32HandleInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    semaphore = copy_src.semaphore;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSemaphoreGetWin32HandleInfoKHR& safe_VkSemaphoreGetWin32HandleInfoKHR::operator=(
+    const safe_VkSemaphoreGetWin32HandleInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    semaphore = copy_src.semaphore;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSemaphoreGetWin32HandleInfoKHR::~safe_VkSemaphoreGetWin32HandleInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkSemaphoreGetWin32HandleInfoKHR::initialize(const VkSemaphoreGetWin32HandleInfoKHR* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    semaphore = in_struct->semaphore;
+    handleType = in_struct->handleType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSemaphoreGetWin32HandleInfoKHR::initialize(const safe_VkSemaphoreGetWin32HandleInfoKHR* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    semaphore = copy_src->semaphore;
+    handleType = copy_src->handleType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+
+safe_VkImportSemaphoreFdInfoKHR::safe_VkImportSemaphoreFdInfoKHR(const VkImportSemaphoreFdInfoKHR* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      semaphore(in_struct->semaphore),
+      flags(in_struct->flags),
+      handleType(in_struct->handleType),
+      fd(in_struct->fd) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImportSemaphoreFdInfoKHR::safe_VkImportSemaphoreFdInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR), pNext(nullptr), semaphore(), flags(), handleType(), fd() {}
+
+safe_VkImportSemaphoreFdInfoKHR::safe_VkImportSemaphoreFdInfoKHR(const safe_VkImportSemaphoreFdInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    semaphore = copy_src.semaphore;
+    flags = copy_src.flags;
+    handleType = copy_src.handleType;
+    fd = copy_src.fd;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImportSemaphoreFdInfoKHR& safe_VkImportSemaphoreFdInfoKHR::operator=(const safe_VkImportSemaphoreFdInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    semaphore = copy_src.semaphore;
+    flags = copy_src.flags;
+    handleType = copy_src.handleType;
+    fd = copy_src.fd;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImportSemaphoreFdInfoKHR::~safe_VkImportSemaphoreFdInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkImportSemaphoreFdInfoKHR::initialize(const VkImportSemaphoreFdInfoKHR* in_struct,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    semaphore = in_struct->semaphore;
+    flags = in_struct->flags;
+    handleType = in_struct->handleType;
+    fd = in_struct->fd;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImportSemaphoreFdInfoKHR::initialize(const safe_VkImportSemaphoreFdInfoKHR* copy_src,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    semaphore = copy_src->semaphore;
+    flags = copy_src->flags;
+    handleType = copy_src->handleType;
+    fd = copy_src->fd;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSemaphoreGetFdInfoKHR::safe_VkSemaphoreGetFdInfoKHR(const VkSemaphoreGetFdInfoKHR* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), semaphore(in_struct->semaphore), handleType(in_struct->handleType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSemaphoreGetFdInfoKHR::safe_VkSemaphoreGetFdInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR), pNext(nullptr), semaphore(), handleType() {}
+
+safe_VkSemaphoreGetFdInfoKHR::safe_VkSemaphoreGetFdInfoKHR(const safe_VkSemaphoreGetFdInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    semaphore = copy_src.semaphore;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSemaphoreGetFdInfoKHR& safe_VkSemaphoreGetFdInfoKHR::operator=(const safe_VkSemaphoreGetFdInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    semaphore = copy_src.semaphore;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSemaphoreGetFdInfoKHR::~safe_VkSemaphoreGetFdInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkSemaphoreGetFdInfoKHR::initialize(const VkSemaphoreGetFdInfoKHR* in_struct,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    semaphore = in_struct->semaphore;
+    handleType = in_struct->handleType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSemaphoreGetFdInfoKHR::initialize(const safe_VkSemaphoreGetFdInfoKHR* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    semaphore = copy_src->semaphore;
+    handleType = copy_src->handleType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDevicePushDescriptorPropertiesKHR::safe_VkPhysicalDevicePushDescriptorPropertiesKHR(
+    const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), maxPushDescriptors(in_struct->maxPushDescriptors) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePushDescriptorPropertiesKHR::safe_VkPhysicalDevicePushDescriptorPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR), pNext(nullptr), maxPushDescriptors() {}
+
+safe_VkPhysicalDevicePushDescriptorPropertiesKHR::safe_VkPhysicalDevicePushDescriptorPropertiesKHR(
+    const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    maxPushDescriptors = copy_src.maxPushDescriptors;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePushDescriptorPropertiesKHR& safe_VkPhysicalDevicePushDescriptorPropertiesKHR::operator=(
+    const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxPushDescriptors = copy_src.maxPushDescriptors;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePushDescriptorPropertiesKHR::~safe_VkPhysicalDevicePushDescriptorPropertiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDevicePushDescriptorPropertiesKHR::initialize(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxPushDescriptors = in_struct->maxPushDescriptors;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePushDescriptorPropertiesKHR::initialize(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxPushDescriptors = copy_src->maxPushDescriptors;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPresentRegionKHR::safe_VkPresentRegionKHR(const VkPresentRegionKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state)
+    : rectangleCount(in_struct->rectangleCount), pRectangles(nullptr) {
+    if (in_struct->pRectangles) {
+        pRectangles = new VkRectLayerKHR[in_struct->rectangleCount];
+        memcpy((void*)pRectangles, (void*)in_struct->pRectangles, sizeof(VkRectLayerKHR) * in_struct->rectangleCount);
+    }
+}
+
+safe_VkPresentRegionKHR::safe_VkPresentRegionKHR() : rectangleCount(), pRectangles(nullptr) {}
+
+safe_VkPresentRegionKHR::safe_VkPresentRegionKHR(const safe_VkPresentRegionKHR& copy_src) {
+    rectangleCount = copy_src.rectangleCount;
+    pRectangles = nullptr;
+
+    if (copy_src.pRectangles) {
+        pRectangles = new VkRectLayerKHR[copy_src.rectangleCount];
+        memcpy((void*)pRectangles, (void*)copy_src.pRectangles, sizeof(VkRectLayerKHR) * copy_src.rectangleCount);
+    }
+}
+
+safe_VkPresentRegionKHR& safe_VkPresentRegionKHR::operator=(const safe_VkPresentRegionKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pRectangles) delete[] pRectangles;
+
+    rectangleCount = copy_src.rectangleCount;
+    pRectangles = nullptr;
+
+    if (copy_src.pRectangles) {
+        pRectangles = new VkRectLayerKHR[copy_src.rectangleCount];
+        memcpy((void*)pRectangles, (void*)copy_src.pRectangles, sizeof(VkRectLayerKHR) * copy_src.rectangleCount);
+    }
+
+    return *this;
+}
+
+safe_VkPresentRegionKHR::~safe_VkPresentRegionKHR() {
+    if (pRectangles) delete[] pRectangles;
+}
+
+void safe_VkPresentRegionKHR::initialize(const VkPresentRegionKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pRectangles) delete[] pRectangles;
+    rectangleCount = in_struct->rectangleCount;
+    pRectangles = nullptr;
+
+    if (in_struct->pRectangles) {
+        pRectangles = new VkRectLayerKHR[in_struct->rectangleCount];
+        memcpy((void*)pRectangles, (void*)in_struct->pRectangles, sizeof(VkRectLayerKHR) * in_struct->rectangleCount);
+    }
+}
+
+void safe_VkPresentRegionKHR::initialize(const safe_VkPresentRegionKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    rectangleCount = copy_src->rectangleCount;
+    pRectangles = nullptr;
+
+    if (copy_src->pRectangles) {
+        pRectangles = new VkRectLayerKHR[copy_src->rectangleCount];
+        memcpy((void*)pRectangles, (void*)copy_src->pRectangles, sizeof(VkRectLayerKHR) * copy_src->rectangleCount);
+    }
+}
+
+safe_VkPresentRegionsKHR::safe_VkPresentRegionsKHR(const VkPresentRegionsKHR* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), swapchainCount(in_struct->swapchainCount), pRegions(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (swapchainCount && in_struct->pRegions) {
+        pRegions = new safe_VkPresentRegionKHR[swapchainCount];
+        for (uint32_t i = 0; i < swapchainCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+safe_VkPresentRegionsKHR::safe_VkPresentRegionsKHR()
+    : sType(VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR), pNext(nullptr), swapchainCount(), pRegions(nullptr) {}
+
+safe_VkPresentRegionsKHR::safe_VkPresentRegionsKHR(const safe_VkPresentRegionsKHR& copy_src) {
+    sType = copy_src.sType;
+    swapchainCount = copy_src.swapchainCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (swapchainCount && copy_src.pRegions) {
+        pRegions = new safe_VkPresentRegionKHR[swapchainCount];
+        for (uint32_t i = 0; i < swapchainCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+}
+
+safe_VkPresentRegionsKHR& safe_VkPresentRegionsKHR::operator=(const safe_VkPresentRegionsKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    swapchainCount = copy_src.swapchainCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (swapchainCount && copy_src.pRegions) {
+        pRegions = new safe_VkPresentRegionKHR[swapchainCount];
+        for (uint32_t i = 0; i < swapchainCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkPresentRegionsKHR::~safe_VkPresentRegionsKHR() {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPresentRegionsKHR::initialize(const VkPresentRegionsKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    swapchainCount = in_struct->swapchainCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (swapchainCount && in_struct->pRegions) {
+        pRegions = new safe_VkPresentRegionKHR[swapchainCount];
+        for (uint32_t i = 0; i < swapchainCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+void safe_VkPresentRegionsKHR::initialize(const safe_VkPresentRegionsKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    swapchainCount = copy_src->swapchainCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (swapchainCount && copy_src->pRegions) {
+        pRegions = new safe_VkPresentRegionKHR[swapchainCount];
+        for (uint32_t i = 0; i < swapchainCount; ++i) {
+            pRegions[i].initialize(&copy_src->pRegions[i]);
+        }
+    }
+}
+
+safe_VkSharedPresentSurfaceCapabilitiesKHR::safe_VkSharedPresentSurfaceCapabilitiesKHR(
+    const VkSharedPresentSurfaceCapabilitiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), sharedPresentSupportedUsageFlags(in_struct->sharedPresentSupportedUsageFlags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSharedPresentSurfaceCapabilitiesKHR::safe_VkSharedPresentSurfaceCapabilitiesKHR()
+    : sType(VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR), pNext(nullptr), sharedPresentSupportedUsageFlags() {}
+
+safe_VkSharedPresentSurfaceCapabilitiesKHR::safe_VkSharedPresentSurfaceCapabilitiesKHR(
+    const safe_VkSharedPresentSurfaceCapabilitiesKHR& copy_src) {
+    sType = copy_src.sType;
+    sharedPresentSupportedUsageFlags = copy_src.sharedPresentSupportedUsageFlags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSharedPresentSurfaceCapabilitiesKHR& safe_VkSharedPresentSurfaceCapabilitiesKHR::operator=(
+    const safe_VkSharedPresentSurfaceCapabilitiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    sharedPresentSupportedUsageFlags = copy_src.sharedPresentSupportedUsageFlags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSharedPresentSurfaceCapabilitiesKHR::~safe_VkSharedPresentSurfaceCapabilitiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkSharedPresentSurfaceCapabilitiesKHR::initialize(const VkSharedPresentSurfaceCapabilitiesKHR* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    sharedPresentSupportedUsageFlags = in_struct->sharedPresentSupportedUsageFlags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSharedPresentSurfaceCapabilitiesKHR::initialize(const safe_VkSharedPresentSurfaceCapabilitiesKHR* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    sharedPresentSupportedUsageFlags = copy_src->sharedPresentSupportedUsageFlags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+safe_VkImportFenceWin32HandleInfoKHR::safe_VkImportFenceWin32HandleInfoKHR(const VkImportFenceWin32HandleInfoKHR* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType),
+      fence(in_struct->fence),
+      flags(in_struct->flags),
+      handleType(in_struct->handleType),
+      handle(in_struct->handle),
+      name(in_struct->name) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImportFenceWin32HandleInfoKHR::safe_VkImportFenceWin32HandleInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR),
+      pNext(nullptr),
+      fence(),
+      flags(),
+      handleType(),
+      handle(),
+      name() {}
+
+safe_VkImportFenceWin32HandleInfoKHR::safe_VkImportFenceWin32HandleInfoKHR(const safe_VkImportFenceWin32HandleInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    fence = copy_src.fence;
+    flags = copy_src.flags;
+    handleType = copy_src.handleType;
+    handle = copy_src.handle;
+    name = copy_src.name;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImportFenceWin32HandleInfoKHR& safe_VkImportFenceWin32HandleInfoKHR::operator=(
+    const safe_VkImportFenceWin32HandleInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    fence = copy_src.fence;
+    flags = copy_src.flags;
+    handleType = copy_src.handleType;
+    handle = copy_src.handle;
+    name = copy_src.name;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImportFenceWin32HandleInfoKHR::~safe_VkImportFenceWin32HandleInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkImportFenceWin32HandleInfoKHR::initialize(const VkImportFenceWin32HandleInfoKHR* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    fence = in_struct->fence;
+    flags = in_struct->flags;
+    handleType = in_struct->handleType;
+    handle = in_struct->handle;
+    name = in_struct->name;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImportFenceWin32HandleInfoKHR::initialize(const safe_VkImportFenceWin32HandleInfoKHR* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    fence = copy_src->fence;
+    flags = copy_src->flags;
+    handleType = copy_src->handleType;
+    handle = copy_src->handle;
+    name = copy_src->name;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkExportFenceWin32HandleInfoKHR::safe_VkExportFenceWin32HandleInfoKHR(const VkExportFenceWin32HandleInfoKHR* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), pAttributes(nullptr), dwAccess(in_struct->dwAccess), name(in_struct->name) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pAttributes) {
+        pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
+    }
+}
+
+safe_VkExportFenceWin32HandleInfoKHR::safe_VkExportFenceWin32HandleInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR), pNext(nullptr), pAttributes(nullptr), dwAccess(), name() {}
+
+safe_VkExportFenceWin32HandleInfoKHR::safe_VkExportFenceWin32HandleInfoKHR(const safe_VkExportFenceWin32HandleInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pAttributes = nullptr;
+    dwAccess = copy_src.dwAccess;
+    name = copy_src.name;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pAttributes) {
+        pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes);
+    }
+}
+
+safe_VkExportFenceWin32HandleInfoKHR& safe_VkExportFenceWin32HandleInfoKHR::operator=(
+    const safe_VkExportFenceWin32HandleInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pAttributes) delete pAttributes;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pAttributes = nullptr;
+    dwAccess = copy_src.dwAccess;
+    name = copy_src.name;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pAttributes) {
+        pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes);
+    }
+
+    return *this;
+}
+
+safe_VkExportFenceWin32HandleInfoKHR::~safe_VkExportFenceWin32HandleInfoKHR() {
+    if (pAttributes) delete pAttributes;
+    FreePnextChain(pNext);
+}
+
+void safe_VkExportFenceWin32HandleInfoKHR::initialize(const VkExportFenceWin32HandleInfoKHR* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pAttributes) delete pAttributes;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pAttributes = nullptr;
+    dwAccess = in_struct->dwAccess;
+    name = in_struct->name;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pAttributes) {
+        pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
+    }
+}
+
+void safe_VkExportFenceWin32HandleInfoKHR::initialize(const safe_VkExportFenceWin32HandleInfoKHR* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pAttributes = nullptr;
+    dwAccess = copy_src->dwAccess;
+    name = copy_src->name;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pAttributes) {
+        pAttributes = new SECURITY_ATTRIBUTES(*copy_src->pAttributes);
+    }
+}
+
+safe_VkFenceGetWin32HandleInfoKHR::safe_VkFenceGetWin32HandleInfoKHR(const VkFenceGetWin32HandleInfoKHR* in_struct,
+                                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), fence(in_struct->fence), handleType(in_struct->handleType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkFenceGetWin32HandleInfoKHR::safe_VkFenceGetWin32HandleInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR), pNext(nullptr), fence(), handleType() {}
+
+safe_VkFenceGetWin32HandleInfoKHR::safe_VkFenceGetWin32HandleInfoKHR(const safe_VkFenceGetWin32HandleInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    fence = copy_src.fence;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkFenceGetWin32HandleInfoKHR& safe_VkFenceGetWin32HandleInfoKHR::operator=(const safe_VkFenceGetWin32HandleInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    fence = copy_src.fence;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkFenceGetWin32HandleInfoKHR::~safe_VkFenceGetWin32HandleInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkFenceGetWin32HandleInfoKHR::initialize(const VkFenceGetWin32HandleInfoKHR* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    fence = in_struct->fence;
+    handleType = in_struct->handleType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkFenceGetWin32HandleInfoKHR::initialize(const safe_VkFenceGetWin32HandleInfoKHR* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    fence = copy_src->fence;
+    handleType = copy_src->handleType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+
+safe_VkImportFenceFdInfoKHR::safe_VkImportFenceFdInfoKHR(const VkImportFenceFdInfoKHR* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      fence(in_struct->fence),
+      flags(in_struct->flags),
+      handleType(in_struct->handleType),
+      fd(in_struct->fd) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImportFenceFdInfoKHR::safe_VkImportFenceFdInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR), pNext(nullptr), fence(), flags(), handleType(), fd() {}
+
+safe_VkImportFenceFdInfoKHR::safe_VkImportFenceFdInfoKHR(const safe_VkImportFenceFdInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    fence = copy_src.fence;
+    flags = copy_src.flags;
+    handleType = copy_src.handleType;
+    fd = copy_src.fd;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImportFenceFdInfoKHR& safe_VkImportFenceFdInfoKHR::operator=(const safe_VkImportFenceFdInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    fence = copy_src.fence;
+    flags = copy_src.flags;
+    handleType = copy_src.handleType;
+    fd = copy_src.fd;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImportFenceFdInfoKHR::~safe_VkImportFenceFdInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkImportFenceFdInfoKHR::initialize(const VkImportFenceFdInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    fence = in_struct->fence;
+    flags = in_struct->flags;
+    handleType = in_struct->handleType;
+    fd = in_struct->fd;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImportFenceFdInfoKHR::initialize(const safe_VkImportFenceFdInfoKHR* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    fence = copy_src->fence;
+    flags = copy_src->flags;
+    handleType = copy_src->handleType;
+    fd = copy_src->fd;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkFenceGetFdInfoKHR::safe_VkFenceGetFdInfoKHR(const VkFenceGetFdInfoKHR* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), fence(in_struct->fence), handleType(in_struct->handleType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkFenceGetFdInfoKHR::safe_VkFenceGetFdInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR), pNext(nullptr), fence(), handleType() {}
+
+safe_VkFenceGetFdInfoKHR::safe_VkFenceGetFdInfoKHR(const safe_VkFenceGetFdInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    fence = copy_src.fence;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkFenceGetFdInfoKHR& safe_VkFenceGetFdInfoKHR::operator=(const safe_VkFenceGetFdInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    fence = copy_src.fence;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkFenceGetFdInfoKHR::~safe_VkFenceGetFdInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkFenceGetFdInfoKHR::initialize(const VkFenceGetFdInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    fence = in_struct->fence;
+    handleType = in_struct->handleType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkFenceGetFdInfoKHR::initialize(const safe_VkFenceGetFdInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    fence = copy_src->fence;
+    handleType = copy_src->handleType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::safe_VkPhysicalDevicePerformanceQueryFeaturesKHR(
+    const VkPhysicalDevicePerformanceQueryFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      performanceCounterQueryPools(in_struct->performanceCounterQueryPools),
+      performanceCounterMultipleQueryPools(in_struct->performanceCounterMultipleQueryPools) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::safe_VkPhysicalDevicePerformanceQueryFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR),
+      pNext(nullptr),
+      performanceCounterQueryPools(),
+      performanceCounterMultipleQueryPools() {}
+
+safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::safe_VkPhysicalDevicePerformanceQueryFeaturesKHR(
+    const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    performanceCounterQueryPools = copy_src.performanceCounterQueryPools;
+    performanceCounterMultipleQueryPools = copy_src.performanceCounterMultipleQueryPools;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::operator=(
+    const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    performanceCounterQueryPools = copy_src.performanceCounterQueryPools;
+    performanceCounterMultipleQueryPools = copy_src.performanceCounterMultipleQueryPools;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::~safe_VkPhysicalDevicePerformanceQueryFeaturesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::initialize(const VkPhysicalDevicePerformanceQueryFeaturesKHR* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    performanceCounterQueryPools = in_struct->performanceCounterQueryPools;
+    performanceCounterMultipleQueryPools = in_struct->performanceCounterMultipleQueryPools;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePerformanceQueryFeaturesKHR::initialize(const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    performanceCounterQueryPools = copy_src->performanceCounterQueryPools;
+    performanceCounterMultipleQueryPools = copy_src->performanceCounterMultipleQueryPools;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::safe_VkPhysicalDevicePerformanceQueryPropertiesKHR(
+    const VkPhysicalDevicePerformanceQueryPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), allowCommandBufferQueryCopies(in_struct->allowCommandBufferQueryCopies) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::safe_VkPhysicalDevicePerformanceQueryPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR), pNext(nullptr), allowCommandBufferQueryCopies() {}
+
+safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::safe_VkPhysicalDevicePerformanceQueryPropertiesKHR(
+    const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    allowCommandBufferQueryCopies = copy_src.allowCommandBufferQueryCopies;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::operator=(
+    const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    allowCommandBufferQueryCopies = copy_src.allowCommandBufferQueryCopies;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::~safe_VkPhysicalDevicePerformanceQueryPropertiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::initialize(const VkPhysicalDevicePerformanceQueryPropertiesKHR* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    allowCommandBufferQueryCopies = in_struct->allowCommandBufferQueryCopies;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePerformanceQueryPropertiesKHR::initialize(
+    const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    allowCommandBufferQueryCopies = copy_src->allowCommandBufferQueryCopies;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPerformanceCounterKHR::safe_VkPerformanceCounterKHR(const VkPerformanceCounterKHR* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), unit(in_struct->unit), scope(in_struct->scope), storage(in_struct->storage) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        uuid[i] = in_struct->uuid[i];
+    }
+}
+
+safe_VkPerformanceCounterKHR::safe_VkPerformanceCounterKHR()
+    : sType(VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR), pNext(nullptr), unit(), scope(), storage() {}
+
+safe_VkPerformanceCounterKHR::safe_VkPerformanceCounterKHR(const safe_VkPerformanceCounterKHR& copy_src) {
+    sType = copy_src.sType;
+    unit = copy_src.unit;
+    scope = copy_src.scope;
+    storage = copy_src.storage;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        uuid[i] = copy_src.uuid[i];
+    }
+}
+
+safe_VkPerformanceCounterKHR& safe_VkPerformanceCounterKHR::operator=(const safe_VkPerformanceCounterKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    unit = copy_src.unit;
+    scope = copy_src.scope;
+    storage = copy_src.storage;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        uuid[i] = copy_src.uuid[i];
+    }
+
+    return *this;
+}
+
+safe_VkPerformanceCounterKHR::~safe_VkPerformanceCounterKHR() { FreePnextChain(pNext); }
+
+void safe_VkPerformanceCounterKHR::initialize(const VkPerformanceCounterKHR* in_struct,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    unit = in_struct->unit;
+    scope = in_struct->scope;
+    storage = in_struct->storage;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        uuid[i] = in_struct->uuid[i];
+    }
+}
+
+void safe_VkPerformanceCounterKHR::initialize(const safe_VkPerformanceCounterKHR* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    unit = copy_src->unit;
+    scope = copy_src->scope;
+    storage = copy_src->storage;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        uuid[i] = copy_src->uuid[i];
+    }
+}
+
+safe_VkPerformanceCounterDescriptionKHR::safe_VkPerformanceCounterDescriptionKHR(
+    const VkPerformanceCounterDescriptionKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = in_struct->name[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        category[i] = in_struct->category[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = in_struct->description[i];
+    }
+}
+
+safe_VkPerformanceCounterDescriptionKHR::safe_VkPerformanceCounterDescriptionKHR()
+    : sType(VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR), pNext(nullptr), flags() {}
+
+safe_VkPerformanceCounterDescriptionKHR::safe_VkPerformanceCounterDescriptionKHR(
+    const safe_VkPerformanceCounterDescriptionKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = copy_src.name[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        category[i] = copy_src.category[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = copy_src.description[i];
+    }
+}
+
+safe_VkPerformanceCounterDescriptionKHR& safe_VkPerformanceCounterDescriptionKHR::operator=(
+    const safe_VkPerformanceCounterDescriptionKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = copy_src.name[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        category[i] = copy_src.category[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = copy_src.description[i];
+    }
+
+    return *this;
+}
+
+safe_VkPerformanceCounterDescriptionKHR::~safe_VkPerformanceCounterDescriptionKHR() { FreePnextChain(pNext); }
+
+void safe_VkPerformanceCounterDescriptionKHR::initialize(const VkPerformanceCounterDescriptionKHR* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = in_struct->name[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        category[i] = in_struct->category[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = in_struct->description[i];
+    }
+}
+
+void safe_VkPerformanceCounterDescriptionKHR::initialize(const safe_VkPerformanceCounterDescriptionKHR* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = copy_src->name[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        category[i] = copy_src->category[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = copy_src->description[i];
+    }
+}
+
+safe_VkQueryPoolPerformanceCreateInfoKHR::safe_VkQueryPoolPerformanceCreateInfoKHR(
+    const VkQueryPoolPerformanceCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      queueFamilyIndex(in_struct->queueFamilyIndex),
+      counterIndexCount(in_struct->counterIndexCount),
+      pCounterIndices(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pCounterIndices) {
+        pCounterIndices = new uint32_t[in_struct->counterIndexCount];
+        memcpy((void*)pCounterIndices, (void*)in_struct->pCounterIndices, sizeof(uint32_t) * in_struct->counterIndexCount);
+    }
+}
+
+safe_VkQueryPoolPerformanceCreateInfoKHR::safe_VkQueryPoolPerformanceCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR),
+      pNext(nullptr),
+      queueFamilyIndex(),
+      counterIndexCount(),
+      pCounterIndices(nullptr) {}
+
+safe_VkQueryPoolPerformanceCreateInfoKHR::safe_VkQueryPoolPerformanceCreateInfoKHR(
+    const safe_VkQueryPoolPerformanceCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    queueFamilyIndex = copy_src.queueFamilyIndex;
+    counterIndexCount = copy_src.counterIndexCount;
+    pCounterIndices = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pCounterIndices) {
+        pCounterIndices = new uint32_t[copy_src.counterIndexCount];
+        memcpy((void*)pCounterIndices, (void*)copy_src.pCounterIndices, sizeof(uint32_t) * copy_src.counterIndexCount);
+    }
+}
+
+safe_VkQueryPoolPerformanceCreateInfoKHR& safe_VkQueryPoolPerformanceCreateInfoKHR::operator=(
+    const safe_VkQueryPoolPerformanceCreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pCounterIndices) delete[] pCounterIndices;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    queueFamilyIndex = copy_src.queueFamilyIndex;
+    counterIndexCount = copy_src.counterIndexCount;
+    pCounterIndices = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pCounterIndices) {
+        pCounterIndices = new uint32_t[copy_src.counterIndexCount];
+        memcpy((void*)pCounterIndices, (void*)copy_src.pCounterIndices, sizeof(uint32_t) * copy_src.counterIndexCount);
+    }
+
+    return *this;
+}
+
+safe_VkQueryPoolPerformanceCreateInfoKHR::~safe_VkQueryPoolPerformanceCreateInfoKHR() {
+    if (pCounterIndices) delete[] pCounterIndices;
+    FreePnextChain(pNext);
+}
+
+void safe_VkQueryPoolPerformanceCreateInfoKHR::initialize(const VkQueryPoolPerformanceCreateInfoKHR* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pCounterIndices) delete[] pCounterIndices;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    queueFamilyIndex = in_struct->queueFamilyIndex;
+    counterIndexCount = in_struct->counterIndexCount;
+    pCounterIndices = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pCounterIndices) {
+        pCounterIndices = new uint32_t[in_struct->counterIndexCount];
+        memcpy((void*)pCounterIndices, (void*)in_struct->pCounterIndices, sizeof(uint32_t) * in_struct->counterIndexCount);
+    }
+}
+
+void safe_VkQueryPoolPerformanceCreateInfoKHR::initialize(const safe_VkQueryPoolPerformanceCreateInfoKHR* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    queueFamilyIndex = copy_src->queueFamilyIndex;
+    counterIndexCount = copy_src->counterIndexCount;
+    pCounterIndices = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pCounterIndices) {
+        pCounterIndices = new uint32_t[copy_src->counterIndexCount];
+        memcpy((void*)pCounterIndices, (void*)copy_src->pCounterIndices, sizeof(uint32_t) * copy_src->counterIndexCount);
+    }
+}
+
+safe_VkAcquireProfilingLockInfoKHR::safe_VkAcquireProfilingLockInfoKHR(const VkAcquireProfilingLockInfoKHR* in_struct,
+                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags), timeout(in_struct->timeout) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkAcquireProfilingLockInfoKHR::safe_VkAcquireProfilingLockInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR), pNext(nullptr), flags(), timeout() {}
+
+safe_VkAcquireProfilingLockInfoKHR::safe_VkAcquireProfilingLockInfoKHR(const safe_VkAcquireProfilingLockInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    timeout = copy_src.timeout;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkAcquireProfilingLockInfoKHR& safe_VkAcquireProfilingLockInfoKHR::operator=(
+    const safe_VkAcquireProfilingLockInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    timeout = copy_src.timeout;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkAcquireProfilingLockInfoKHR::~safe_VkAcquireProfilingLockInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkAcquireProfilingLockInfoKHR::initialize(const VkAcquireProfilingLockInfoKHR* in_struct,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    timeout = in_struct->timeout;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkAcquireProfilingLockInfoKHR::initialize(const safe_VkAcquireProfilingLockInfoKHR* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    timeout = copy_src->timeout;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPerformanceQuerySubmitInfoKHR::safe_VkPerformanceQuerySubmitInfoKHR(const VkPerformanceQuerySubmitInfoKHR* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), counterPassIndex(in_struct->counterPassIndex) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPerformanceQuerySubmitInfoKHR::safe_VkPerformanceQuerySubmitInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR), pNext(nullptr), counterPassIndex() {}
+
+safe_VkPerformanceQuerySubmitInfoKHR::safe_VkPerformanceQuerySubmitInfoKHR(const safe_VkPerformanceQuerySubmitInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    counterPassIndex = copy_src.counterPassIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPerformanceQuerySubmitInfoKHR& safe_VkPerformanceQuerySubmitInfoKHR::operator=(
+    const safe_VkPerformanceQuerySubmitInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    counterPassIndex = copy_src.counterPassIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPerformanceQuerySubmitInfoKHR::~safe_VkPerformanceQuerySubmitInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkPerformanceQuerySubmitInfoKHR::initialize(const VkPerformanceQuerySubmitInfoKHR* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    counterPassIndex = in_struct->counterPassIndex;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPerformanceQuerySubmitInfoKHR::initialize(const safe_VkPerformanceQuerySubmitInfoKHR* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    counterPassIndex = copy_src->counterPassIndex;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceSurfaceInfo2KHR::safe_VkPhysicalDeviceSurfaceInfo2KHR(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), surface(in_struct->surface) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceSurfaceInfo2KHR::safe_VkPhysicalDeviceSurfaceInfo2KHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR), pNext(nullptr), surface() {}
+
+safe_VkPhysicalDeviceSurfaceInfo2KHR::safe_VkPhysicalDeviceSurfaceInfo2KHR(const safe_VkPhysicalDeviceSurfaceInfo2KHR& copy_src) {
+    sType = copy_src.sType;
+    surface = copy_src.surface;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceSurfaceInfo2KHR& safe_VkPhysicalDeviceSurfaceInfo2KHR::operator=(
+    const safe_VkPhysicalDeviceSurfaceInfo2KHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    surface = copy_src.surface;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceSurfaceInfo2KHR::~safe_VkPhysicalDeviceSurfaceInfo2KHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceSurfaceInfo2KHR::initialize(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    surface = in_struct->surface;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceSurfaceInfo2KHR::initialize(const safe_VkPhysicalDeviceSurfaceInfo2KHR* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    surface = copy_src->surface;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSurfaceCapabilities2KHR::safe_VkSurfaceCapabilities2KHR(const VkSurfaceCapabilities2KHR* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), surfaceCapabilities(in_struct->surfaceCapabilities) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSurfaceCapabilities2KHR::safe_VkSurfaceCapabilities2KHR()
+    : sType(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR), pNext(nullptr), surfaceCapabilities() {}
+
+safe_VkSurfaceCapabilities2KHR::safe_VkSurfaceCapabilities2KHR(const safe_VkSurfaceCapabilities2KHR& copy_src) {
+    sType = copy_src.sType;
+    surfaceCapabilities = copy_src.surfaceCapabilities;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSurfaceCapabilities2KHR& safe_VkSurfaceCapabilities2KHR::operator=(const safe_VkSurfaceCapabilities2KHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    surfaceCapabilities = copy_src.surfaceCapabilities;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSurfaceCapabilities2KHR::~safe_VkSurfaceCapabilities2KHR() { FreePnextChain(pNext); }
+
+void safe_VkSurfaceCapabilities2KHR::initialize(const VkSurfaceCapabilities2KHR* in_struct,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    surfaceCapabilities = in_struct->surfaceCapabilities;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSurfaceCapabilities2KHR::initialize(const safe_VkSurfaceCapabilities2KHR* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    surfaceCapabilities = copy_src->surfaceCapabilities;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSurfaceFormat2KHR::safe_VkSurfaceFormat2KHR(const VkSurfaceFormat2KHR* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), surfaceFormat(in_struct->surfaceFormat) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSurfaceFormat2KHR::safe_VkSurfaceFormat2KHR()
+    : sType(VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR), pNext(nullptr), surfaceFormat() {}
+
+safe_VkSurfaceFormat2KHR::safe_VkSurfaceFormat2KHR(const safe_VkSurfaceFormat2KHR& copy_src) {
+    sType = copy_src.sType;
+    surfaceFormat = copy_src.surfaceFormat;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSurfaceFormat2KHR& safe_VkSurfaceFormat2KHR::operator=(const safe_VkSurfaceFormat2KHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    surfaceFormat = copy_src.surfaceFormat;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSurfaceFormat2KHR::~safe_VkSurfaceFormat2KHR() { FreePnextChain(pNext); }
+
+void safe_VkSurfaceFormat2KHR::initialize(const VkSurfaceFormat2KHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    surfaceFormat = in_struct->surfaceFormat;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSurfaceFormat2KHR::initialize(const safe_VkSurfaceFormat2KHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    surfaceFormat = copy_src->surfaceFormat;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDisplayProperties2KHR::safe_VkDisplayProperties2KHR(const VkDisplayProperties2KHR* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), displayProperties(&in_struct->displayProperties) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDisplayProperties2KHR::safe_VkDisplayProperties2KHR() : sType(VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR), pNext(nullptr) {}
+
+safe_VkDisplayProperties2KHR::safe_VkDisplayProperties2KHR(const safe_VkDisplayProperties2KHR& copy_src) {
+    sType = copy_src.sType;
+    displayProperties.initialize(&copy_src.displayProperties);
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDisplayProperties2KHR& safe_VkDisplayProperties2KHR::operator=(const safe_VkDisplayProperties2KHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    displayProperties.initialize(&copy_src.displayProperties);
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDisplayProperties2KHR::~safe_VkDisplayProperties2KHR() { FreePnextChain(pNext); }
+
+void safe_VkDisplayProperties2KHR::initialize(const VkDisplayProperties2KHR* in_struct,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    displayProperties.initialize(&in_struct->displayProperties);
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDisplayProperties2KHR::initialize(const safe_VkDisplayProperties2KHR* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    displayProperties.initialize(&copy_src->displayProperties);
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDisplayPlaneProperties2KHR::safe_VkDisplayPlaneProperties2KHR(const VkDisplayPlaneProperties2KHR* in_struct,
+                                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), displayPlaneProperties(in_struct->displayPlaneProperties) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDisplayPlaneProperties2KHR::safe_VkDisplayPlaneProperties2KHR()
+    : sType(VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR), pNext(nullptr), displayPlaneProperties() {}
+
+safe_VkDisplayPlaneProperties2KHR::safe_VkDisplayPlaneProperties2KHR(const safe_VkDisplayPlaneProperties2KHR& copy_src) {
+    sType = copy_src.sType;
+    displayPlaneProperties = copy_src.displayPlaneProperties;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDisplayPlaneProperties2KHR& safe_VkDisplayPlaneProperties2KHR::operator=(const safe_VkDisplayPlaneProperties2KHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    displayPlaneProperties = copy_src.displayPlaneProperties;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDisplayPlaneProperties2KHR::~safe_VkDisplayPlaneProperties2KHR() { FreePnextChain(pNext); }
+
+void safe_VkDisplayPlaneProperties2KHR::initialize(const VkDisplayPlaneProperties2KHR* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    displayPlaneProperties = in_struct->displayPlaneProperties;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDisplayPlaneProperties2KHR::initialize(const safe_VkDisplayPlaneProperties2KHR* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    displayPlaneProperties = copy_src->displayPlaneProperties;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDisplayModeProperties2KHR::safe_VkDisplayModeProperties2KHR(const VkDisplayModeProperties2KHR* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), displayModeProperties(in_struct->displayModeProperties) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDisplayModeProperties2KHR::safe_VkDisplayModeProperties2KHR()
+    : sType(VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR), pNext(nullptr), displayModeProperties() {}
+
+safe_VkDisplayModeProperties2KHR::safe_VkDisplayModeProperties2KHR(const safe_VkDisplayModeProperties2KHR& copy_src) {
+    sType = copy_src.sType;
+    displayModeProperties = copy_src.displayModeProperties;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDisplayModeProperties2KHR& safe_VkDisplayModeProperties2KHR::operator=(const safe_VkDisplayModeProperties2KHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    displayModeProperties = copy_src.displayModeProperties;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDisplayModeProperties2KHR::~safe_VkDisplayModeProperties2KHR() { FreePnextChain(pNext); }
+
+void safe_VkDisplayModeProperties2KHR::initialize(const VkDisplayModeProperties2KHR* in_struct,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    displayModeProperties = in_struct->displayModeProperties;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDisplayModeProperties2KHR::initialize(const safe_VkDisplayModeProperties2KHR* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    displayModeProperties = copy_src->displayModeProperties;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDisplayPlaneInfo2KHR::safe_VkDisplayPlaneInfo2KHR(const VkDisplayPlaneInfo2KHR* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), mode(in_struct->mode), planeIndex(in_struct->planeIndex) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDisplayPlaneInfo2KHR::safe_VkDisplayPlaneInfo2KHR()
+    : sType(VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR), pNext(nullptr), mode(), planeIndex() {}
+
+safe_VkDisplayPlaneInfo2KHR::safe_VkDisplayPlaneInfo2KHR(const safe_VkDisplayPlaneInfo2KHR& copy_src) {
+    sType = copy_src.sType;
+    mode = copy_src.mode;
+    planeIndex = copy_src.planeIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDisplayPlaneInfo2KHR& safe_VkDisplayPlaneInfo2KHR::operator=(const safe_VkDisplayPlaneInfo2KHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    mode = copy_src.mode;
+    planeIndex = copy_src.planeIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDisplayPlaneInfo2KHR::~safe_VkDisplayPlaneInfo2KHR() { FreePnextChain(pNext); }
+
+void safe_VkDisplayPlaneInfo2KHR::initialize(const VkDisplayPlaneInfo2KHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    mode = in_struct->mode;
+    planeIndex = in_struct->planeIndex;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDisplayPlaneInfo2KHR::initialize(const safe_VkDisplayPlaneInfo2KHR* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    mode = copy_src->mode;
+    planeIndex = copy_src->planeIndex;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDisplayPlaneCapabilities2KHR::safe_VkDisplayPlaneCapabilities2KHR(const VkDisplayPlaneCapabilities2KHR* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType), capabilities(in_struct->capabilities) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDisplayPlaneCapabilities2KHR::safe_VkDisplayPlaneCapabilities2KHR()
+    : sType(VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR), pNext(nullptr), capabilities() {}
+
+safe_VkDisplayPlaneCapabilities2KHR::safe_VkDisplayPlaneCapabilities2KHR(const safe_VkDisplayPlaneCapabilities2KHR& copy_src) {
+    sType = copy_src.sType;
+    capabilities = copy_src.capabilities;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDisplayPlaneCapabilities2KHR& safe_VkDisplayPlaneCapabilities2KHR::operator=(
+    const safe_VkDisplayPlaneCapabilities2KHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    capabilities = copy_src.capabilities;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDisplayPlaneCapabilities2KHR::~safe_VkDisplayPlaneCapabilities2KHR() { FreePnextChain(pNext); }
+
+void safe_VkDisplayPlaneCapabilities2KHR::initialize(const VkDisplayPlaneCapabilities2KHR* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    capabilities = in_struct->capabilities;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDisplayPlaneCapabilities2KHR::initialize(const safe_VkDisplayPlaneCapabilities2KHR* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    capabilities = copy_src->capabilities;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+
+safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
+    const VkPhysicalDevicePortabilitySubsetFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      constantAlphaColorBlendFactors(in_struct->constantAlphaColorBlendFactors),
+      events(in_struct->events),
+      imageViewFormatReinterpretation(in_struct->imageViewFormatReinterpretation),
+      imageViewFormatSwizzle(in_struct->imageViewFormatSwizzle),
+      imageView2DOn3DImage(in_struct->imageView2DOn3DImage),
+      multisampleArrayImage(in_struct->multisampleArrayImage),
+      mutableComparisonSamplers(in_struct->mutableComparisonSamplers),
+      pointPolygons(in_struct->pointPolygons),
+      samplerMipLodBias(in_struct->samplerMipLodBias),
+      separateStencilMaskRef(in_struct->separateStencilMaskRef),
+      shaderSampleRateInterpolationFunctions(in_struct->shaderSampleRateInterpolationFunctions),
+      tessellationIsolines(in_struct->tessellationIsolines),
+      tessellationPointMode(in_struct->tessellationPointMode),
+      triangleFans(in_struct->triangleFans),
+      vertexAttributeAccessBeyondStride(in_struct->vertexAttributeAccessBeyondStride) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR),
+      pNext(nullptr),
+      constantAlphaColorBlendFactors(),
+      events(),
+      imageViewFormatReinterpretation(),
+      imageViewFormatSwizzle(),
+      imageView2DOn3DImage(),
+      multisampleArrayImage(),
+      mutableComparisonSamplers(),
+      pointPolygons(),
+      samplerMipLodBias(),
+      separateStencilMaskRef(),
+      shaderSampleRateInterpolationFunctions(),
+      tessellationIsolines(),
+      tessellationPointMode(),
+      triangleFans(),
+      vertexAttributeAccessBeyondStride() {}
+
+safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
+    const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    constantAlphaColorBlendFactors = copy_src.constantAlphaColorBlendFactors;
+    events = copy_src.events;
+    imageViewFormatReinterpretation = copy_src.imageViewFormatReinterpretation;
+    imageViewFormatSwizzle = copy_src.imageViewFormatSwizzle;
+    imageView2DOn3DImage = copy_src.imageView2DOn3DImage;
+    multisampleArrayImage = copy_src.multisampleArrayImage;
+    mutableComparisonSamplers = copy_src.mutableComparisonSamplers;
+    pointPolygons = copy_src.pointPolygons;
+    samplerMipLodBias = copy_src.samplerMipLodBias;
+    separateStencilMaskRef = copy_src.separateStencilMaskRef;
+    shaderSampleRateInterpolationFunctions = copy_src.shaderSampleRateInterpolationFunctions;
+    tessellationIsolines = copy_src.tessellationIsolines;
+    tessellationPointMode = copy_src.tessellationPointMode;
+    triangleFans = copy_src.triangleFans;
+    vertexAttributeAccessBeyondStride = copy_src.vertexAttributeAccessBeyondStride;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR& safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::operator=(
+    const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    constantAlphaColorBlendFactors = copy_src.constantAlphaColorBlendFactors;
+    events = copy_src.events;
+    imageViewFormatReinterpretation = copy_src.imageViewFormatReinterpretation;
+    imageViewFormatSwizzle = copy_src.imageViewFormatSwizzle;
+    imageView2DOn3DImage = copy_src.imageView2DOn3DImage;
+    multisampleArrayImage = copy_src.multisampleArrayImage;
+    mutableComparisonSamplers = copy_src.mutableComparisonSamplers;
+    pointPolygons = copy_src.pointPolygons;
+    samplerMipLodBias = copy_src.samplerMipLodBias;
+    separateStencilMaskRef = copy_src.separateStencilMaskRef;
+    shaderSampleRateInterpolationFunctions = copy_src.shaderSampleRateInterpolationFunctions;
+    tessellationIsolines = copy_src.tessellationIsolines;
+    tessellationPointMode = copy_src.tessellationPointMode;
+    triangleFans = copy_src.triangleFans;
+    vertexAttributeAccessBeyondStride = copy_src.vertexAttributeAccessBeyondStride;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::~safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::initialize(const VkPhysicalDevicePortabilitySubsetFeaturesKHR* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    constantAlphaColorBlendFactors = in_struct->constantAlphaColorBlendFactors;
+    events = in_struct->events;
+    imageViewFormatReinterpretation = in_struct->imageViewFormatReinterpretation;
+    imageViewFormatSwizzle = in_struct->imageViewFormatSwizzle;
+    imageView2DOn3DImage = in_struct->imageView2DOn3DImage;
+    multisampleArrayImage = in_struct->multisampleArrayImage;
+    mutableComparisonSamplers = in_struct->mutableComparisonSamplers;
+    pointPolygons = in_struct->pointPolygons;
+    samplerMipLodBias = in_struct->samplerMipLodBias;
+    separateStencilMaskRef = in_struct->separateStencilMaskRef;
+    shaderSampleRateInterpolationFunctions = in_struct->shaderSampleRateInterpolationFunctions;
+    tessellationIsolines = in_struct->tessellationIsolines;
+    tessellationPointMode = in_struct->tessellationPointMode;
+    triangleFans = in_struct->triangleFans;
+    vertexAttributeAccessBeyondStride = in_struct->vertexAttributeAccessBeyondStride;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::initialize(
+    const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    constantAlphaColorBlendFactors = copy_src->constantAlphaColorBlendFactors;
+    events = copy_src->events;
+    imageViewFormatReinterpretation = copy_src->imageViewFormatReinterpretation;
+    imageViewFormatSwizzle = copy_src->imageViewFormatSwizzle;
+    imageView2DOn3DImage = copy_src->imageView2DOn3DImage;
+    multisampleArrayImage = copy_src->multisampleArrayImage;
+    mutableComparisonSamplers = copy_src->mutableComparisonSamplers;
+    pointPolygons = copy_src->pointPolygons;
+    samplerMipLodBias = copy_src->samplerMipLodBias;
+    separateStencilMaskRef = copy_src->separateStencilMaskRef;
+    shaderSampleRateInterpolationFunctions = copy_src->shaderSampleRateInterpolationFunctions;
+    tessellationIsolines = copy_src->tessellationIsolines;
+    tessellationPointMode = copy_src->tessellationPointMode;
+    triangleFans = copy_src->triangleFans;
+    vertexAttributeAccessBeyondStride = copy_src->vertexAttributeAccessBeyondStride;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
+    const VkPhysicalDevicePortabilitySubsetPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), minVertexInputBindingStrideAlignment(in_struct->minVertexInputBindingStrideAlignment) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR),
+      pNext(nullptr),
+      minVertexInputBindingStrideAlignment() {}
+
+safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
+    const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    minVertexInputBindingStrideAlignment = copy_src.minVertexInputBindingStrideAlignment;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR& safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::operator=(
+    const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    minVertexInputBindingStrideAlignment = copy_src.minVertexInputBindingStrideAlignment;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::~safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::initialize(
+    const VkPhysicalDevicePortabilitySubsetPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    minVertexInputBindingStrideAlignment = in_struct->minVertexInputBindingStrideAlignment;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR::initialize(
+    const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    minVertexInputBindingStrideAlignment = copy_src->minVertexInputBindingStrideAlignment;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+
+safe_VkPhysicalDeviceShaderClockFeaturesKHR::safe_VkPhysicalDeviceShaderClockFeaturesKHR(
+    const VkPhysicalDeviceShaderClockFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      shaderSubgroupClock(in_struct->shaderSubgroupClock),
+      shaderDeviceClock(in_struct->shaderDeviceClock) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderClockFeaturesKHR::safe_VkPhysicalDeviceShaderClockFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR),
+      pNext(nullptr),
+      shaderSubgroupClock(),
+      shaderDeviceClock() {}
+
+safe_VkPhysicalDeviceShaderClockFeaturesKHR::safe_VkPhysicalDeviceShaderClockFeaturesKHR(
+    const safe_VkPhysicalDeviceShaderClockFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    shaderSubgroupClock = copy_src.shaderSubgroupClock;
+    shaderDeviceClock = copy_src.shaderDeviceClock;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderClockFeaturesKHR& safe_VkPhysicalDeviceShaderClockFeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceShaderClockFeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderSubgroupClock = copy_src.shaderSubgroupClock;
+    shaderDeviceClock = copy_src.shaderDeviceClock;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderClockFeaturesKHR::~safe_VkPhysicalDeviceShaderClockFeaturesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceShaderClockFeaturesKHR::initialize(const VkPhysicalDeviceShaderClockFeaturesKHR* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderSubgroupClock = in_struct->shaderSubgroupClock;
+    shaderDeviceClock = in_struct->shaderDeviceClock;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderClockFeaturesKHR::initialize(const safe_VkPhysicalDeviceShaderClockFeaturesKHR* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderSubgroupClock = copy_src->shaderSubgroupClock;
+    shaderDeviceClock = copy_src->shaderDeviceClock;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoDecodeH265ProfileInfoKHR::safe_VkVideoDecodeH265ProfileInfoKHR(const VkVideoDecodeH265ProfileInfoKHR* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), stdProfileIdc(in_struct->stdProfileIdc) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoDecodeH265ProfileInfoKHR::safe_VkVideoDecodeH265ProfileInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR), pNext(nullptr), stdProfileIdc() {}
+
+safe_VkVideoDecodeH265ProfileInfoKHR::safe_VkVideoDecodeH265ProfileInfoKHR(const safe_VkVideoDecodeH265ProfileInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    stdProfileIdc = copy_src.stdProfileIdc;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoDecodeH265ProfileInfoKHR& safe_VkVideoDecodeH265ProfileInfoKHR::operator=(
+    const safe_VkVideoDecodeH265ProfileInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    stdProfileIdc = copy_src.stdProfileIdc;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoDecodeH265ProfileInfoKHR::~safe_VkVideoDecodeH265ProfileInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoDecodeH265ProfileInfoKHR::initialize(const VkVideoDecodeH265ProfileInfoKHR* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    stdProfileIdc = in_struct->stdProfileIdc;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoDecodeH265ProfileInfoKHR::initialize(const safe_VkVideoDecodeH265ProfileInfoKHR* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stdProfileIdc = copy_src->stdProfileIdc;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoDecodeH265CapabilitiesKHR::safe_VkVideoDecodeH265CapabilitiesKHR(const VkVideoDecodeH265CapabilitiesKHR* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType), maxLevelIdc(in_struct->maxLevelIdc) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoDecodeH265CapabilitiesKHR::safe_VkVideoDecodeH265CapabilitiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR), pNext(nullptr), maxLevelIdc() {}
+
+safe_VkVideoDecodeH265CapabilitiesKHR::safe_VkVideoDecodeH265CapabilitiesKHR(
+    const safe_VkVideoDecodeH265CapabilitiesKHR& copy_src) {
+    sType = copy_src.sType;
+    maxLevelIdc = copy_src.maxLevelIdc;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoDecodeH265CapabilitiesKHR& safe_VkVideoDecodeH265CapabilitiesKHR::operator=(
+    const safe_VkVideoDecodeH265CapabilitiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxLevelIdc = copy_src.maxLevelIdc;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoDecodeH265CapabilitiesKHR::~safe_VkVideoDecodeH265CapabilitiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoDecodeH265CapabilitiesKHR::initialize(const VkVideoDecodeH265CapabilitiesKHR* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxLevelIdc = in_struct->maxLevelIdc;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoDecodeH265CapabilitiesKHR::initialize(const safe_VkVideoDecodeH265CapabilitiesKHR* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxLevelIdc = copy_src->maxLevelIdc;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoDecodeH265SessionParametersAddInfoKHR::safe_VkVideoDecodeH265SessionParametersAddInfoKHR(
+    const VkVideoDecodeH265SessionParametersAddInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      stdVPSCount(in_struct->stdVPSCount),
+      pStdVPSs(nullptr),
+      stdSPSCount(in_struct->stdSPSCount),
+      pStdSPSs(nullptr),
+      stdPPSCount(in_struct->stdPPSCount),
+      pStdPPSs(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pStdVPSs) {
+        pStdVPSs = new StdVideoH265VideoParameterSet[in_struct->stdVPSCount];
+        memcpy((void*)pStdVPSs, (void*)in_struct->pStdVPSs, sizeof(StdVideoH265VideoParameterSet) * in_struct->stdVPSCount);
+    }
+
+    if (in_struct->pStdSPSs) {
+        pStdSPSs = new StdVideoH265SequenceParameterSet[in_struct->stdSPSCount];
+        memcpy((void*)pStdSPSs, (void*)in_struct->pStdSPSs, sizeof(StdVideoH265SequenceParameterSet) * in_struct->stdSPSCount);
+    }
+
+    if (in_struct->pStdPPSs) {
+        pStdPPSs = new StdVideoH265PictureParameterSet[in_struct->stdPPSCount];
+        memcpy((void*)pStdPPSs, (void*)in_struct->pStdPPSs, sizeof(StdVideoH265PictureParameterSet) * in_struct->stdPPSCount);
+    }
+}
+
+safe_VkVideoDecodeH265SessionParametersAddInfoKHR::safe_VkVideoDecodeH265SessionParametersAddInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR),
+      pNext(nullptr),
+      stdVPSCount(),
+      pStdVPSs(nullptr),
+      stdSPSCount(),
+      pStdSPSs(nullptr),
+      stdPPSCount(),
+      pStdPPSs(nullptr) {}
+
+safe_VkVideoDecodeH265SessionParametersAddInfoKHR::safe_VkVideoDecodeH265SessionParametersAddInfoKHR(
+    const safe_VkVideoDecodeH265SessionParametersAddInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    stdVPSCount = copy_src.stdVPSCount;
+    pStdVPSs = nullptr;
+    stdSPSCount = copy_src.stdSPSCount;
+    pStdSPSs = nullptr;
+    stdPPSCount = copy_src.stdPPSCount;
+    pStdPPSs = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdVPSs) {
+        pStdVPSs = new StdVideoH265VideoParameterSet[copy_src.stdVPSCount];
+        memcpy((void*)pStdVPSs, (void*)copy_src.pStdVPSs, sizeof(StdVideoH265VideoParameterSet) * copy_src.stdVPSCount);
+    }
+
+    if (copy_src.pStdSPSs) {
+        pStdSPSs = new StdVideoH265SequenceParameterSet[copy_src.stdSPSCount];
+        memcpy((void*)pStdSPSs, (void*)copy_src.pStdSPSs, sizeof(StdVideoH265SequenceParameterSet) * copy_src.stdSPSCount);
+    }
+
+    if (copy_src.pStdPPSs) {
+        pStdPPSs = new StdVideoH265PictureParameterSet[copy_src.stdPPSCount];
+        memcpy((void*)pStdPPSs, (void*)copy_src.pStdPPSs, sizeof(StdVideoH265PictureParameterSet) * copy_src.stdPPSCount);
+    }
+}
+
+safe_VkVideoDecodeH265SessionParametersAddInfoKHR& safe_VkVideoDecodeH265SessionParametersAddInfoKHR::operator=(
+    const safe_VkVideoDecodeH265SessionParametersAddInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pStdVPSs) delete[] pStdVPSs;
+    if (pStdSPSs) delete[] pStdSPSs;
+    if (pStdPPSs) delete[] pStdPPSs;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    stdVPSCount = copy_src.stdVPSCount;
+    pStdVPSs = nullptr;
+    stdSPSCount = copy_src.stdSPSCount;
+    pStdSPSs = nullptr;
+    stdPPSCount = copy_src.stdPPSCount;
+    pStdPPSs = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdVPSs) {
+        pStdVPSs = new StdVideoH265VideoParameterSet[copy_src.stdVPSCount];
+        memcpy((void*)pStdVPSs, (void*)copy_src.pStdVPSs, sizeof(StdVideoH265VideoParameterSet) * copy_src.stdVPSCount);
+    }
+
+    if (copy_src.pStdSPSs) {
+        pStdSPSs = new StdVideoH265SequenceParameterSet[copy_src.stdSPSCount];
+        memcpy((void*)pStdSPSs, (void*)copy_src.pStdSPSs, sizeof(StdVideoH265SequenceParameterSet) * copy_src.stdSPSCount);
+    }
+
+    if (copy_src.pStdPPSs) {
+        pStdPPSs = new StdVideoH265PictureParameterSet[copy_src.stdPPSCount];
+        memcpy((void*)pStdPPSs, (void*)copy_src.pStdPPSs, sizeof(StdVideoH265PictureParameterSet) * copy_src.stdPPSCount);
+    }
+
+    return *this;
+}
+
+safe_VkVideoDecodeH265SessionParametersAddInfoKHR::~safe_VkVideoDecodeH265SessionParametersAddInfoKHR() {
+    if (pStdVPSs) delete[] pStdVPSs;
+    if (pStdSPSs) delete[] pStdSPSs;
+    if (pStdPPSs) delete[] pStdPPSs;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoDecodeH265SessionParametersAddInfoKHR::initialize(const VkVideoDecodeH265SessionParametersAddInfoKHR* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pStdVPSs) delete[] pStdVPSs;
+    if (pStdSPSs) delete[] pStdSPSs;
+    if (pStdPPSs) delete[] pStdPPSs;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    stdVPSCount = in_struct->stdVPSCount;
+    pStdVPSs = nullptr;
+    stdSPSCount = in_struct->stdSPSCount;
+    pStdSPSs = nullptr;
+    stdPPSCount = in_struct->stdPPSCount;
+    pStdPPSs = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pStdVPSs) {
+        pStdVPSs = new StdVideoH265VideoParameterSet[in_struct->stdVPSCount];
+        memcpy((void*)pStdVPSs, (void*)in_struct->pStdVPSs, sizeof(StdVideoH265VideoParameterSet) * in_struct->stdVPSCount);
+    }
+
+    if (in_struct->pStdSPSs) {
+        pStdSPSs = new StdVideoH265SequenceParameterSet[in_struct->stdSPSCount];
+        memcpy((void*)pStdSPSs, (void*)in_struct->pStdSPSs, sizeof(StdVideoH265SequenceParameterSet) * in_struct->stdSPSCount);
+    }
+
+    if (in_struct->pStdPPSs) {
+        pStdPPSs = new StdVideoH265PictureParameterSet[in_struct->stdPPSCount];
+        memcpy((void*)pStdPPSs, (void*)in_struct->pStdPPSs, sizeof(StdVideoH265PictureParameterSet) * in_struct->stdPPSCount);
+    }
+}
+
+void safe_VkVideoDecodeH265SessionParametersAddInfoKHR::initialize(
+    const safe_VkVideoDecodeH265SessionParametersAddInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stdVPSCount = copy_src->stdVPSCount;
+    pStdVPSs = nullptr;
+    stdSPSCount = copy_src->stdSPSCount;
+    pStdSPSs = nullptr;
+    stdPPSCount = copy_src->stdPPSCount;
+    pStdPPSs = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pStdVPSs) {
+        pStdVPSs = new StdVideoH265VideoParameterSet[copy_src->stdVPSCount];
+        memcpy((void*)pStdVPSs, (void*)copy_src->pStdVPSs, sizeof(StdVideoH265VideoParameterSet) * copy_src->stdVPSCount);
+    }
+
+    if (copy_src->pStdSPSs) {
+        pStdSPSs = new StdVideoH265SequenceParameterSet[copy_src->stdSPSCount];
+        memcpy((void*)pStdSPSs, (void*)copy_src->pStdSPSs, sizeof(StdVideoH265SequenceParameterSet) * copy_src->stdSPSCount);
+    }
+
+    if (copy_src->pStdPPSs) {
+        pStdPPSs = new StdVideoH265PictureParameterSet[copy_src->stdPPSCount];
+        memcpy((void*)pStdPPSs, (void*)copy_src->pStdPPSs, sizeof(StdVideoH265PictureParameterSet) * copy_src->stdPPSCount);
+    }
+}
+
+safe_VkVideoDecodeH265SessionParametersCreateInfoKHR::safe_VkVideoDecodeH265SessionParametersCreateInfoKHR(
+    const VkVideoDecodeH265SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      maxStdVPSCount(in_struct->maxStdVPSCount),
+      maxStdSPSCount(in_struct->maxStdSPSCount),
+      maxStdPPSCount(in_struct->maxStdPPSCount),
+      pParametersAddInfo(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pParametersAddInfo)
+        pParametersAddInfo = new safe_VkVideoDecodeH265SessionParametersAddInfoKHR(in_struct->pParametersAddInfo);
+}
+
+safe_VkVideoDecodeH265SessionParametersCreateInfoKHR::safe_VkVideoDecodeH265SessionParametersCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR),
+      pNext(nullptr),
+      maxStdVPSCount(),
+      maxStdSPSCount(),
+      maxStdPPSCount(),
+      pParametersAddInfo(nullptr) {}
+
+safe_VkVideoDecodeH265SessionParametersCreateInfoKHR::safe_VkVideoDecodeH265SessionParametersCreateInfoKHR(
+    const safe_VkVideoDecodeH265SessionParametersCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    maxStdVPSCount = copy_src.maxStdVPSCount;
+    maxStdSPSCount = copy_src.maxStdSPSCount;
+    maxStdPPSCount = copy_src.maxStdPPSCount;
+    pParametersAddInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pParametersAddInfo)
+        pParametersAddInfo = new safe_VkVideoDecodeH265SessionParametersAddInfoKHR(*copy_src.pParametersAddInfo);
+}
+
+safe_VkVideoDecodeH265SessionParametersCreateInfoKHR& safe_VkVideoDecodeH265SessionParametersCreateInfoKHR::operator=(
+    const safe_VkVideoDecodeH265SessionParametersCreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pParametersAddInfo) delete pParametersAddInfo;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxStdVPSCount = copy_src.maxStdVPSCount;
+    maxStdSPSCount = copy_src.maxStdSPSCount;
+    maxStdPPSCount = copy_src.maxStdPPSCount;
+    pParametersAddInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pParametersAddInfo)
+        pParametersAddInfo = new safe_VkVideoDecodeH265SessionParametersAddInfoKHR(*copy_src.pParametersAddInfo);
+
+    return *this;
+}
+
+safe_VkVideoDecodeH265SessionParametersCreateInfoKHR::~safe_VkVideoDecodeH265SessionParametersCreateInfoKHR() {
+    if (pParametersAddInfo) delete pParametersAddInfo;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoDecodeH265SessionParametersCreateInfoKHR::initialize(
+    const VkVideoDecodeH265SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pParametersAddInfo) delete pParametersAddInfo;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxStdVPSCount = in_struct->maxStdVPSCount;
+    maxStdSPSCount = in_struct->maxStdSPSCount;
+    maxStdPPSCount = in_struct->maxStdPPSCount;
+    pParametersAddInfo = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (in_struct->pParametersAddInfo)
+        pParametersAddInfo = new safe_VkVideoDecodeH265SessionParametersAddInfoKHR(in_struct->pParametersAddInfo);
+}
+
+void safe_VkVideoDecodeH265SessionParametersCreateInfoKHR::initialize(
+    const safe_VkVideoDecodeH265SessionParametersCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxStdVPSCount = copy_src->maxStdVPSCount;
+    maxStdSPSCount = copy_src->maxStdSPSCount;
+    maxStdPPSCount = copy_src->maxStdPPSCount;
+    pParametersAddInfo = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (copy_src->pParametersAddInfo)
+        pParametersAddInfo = new safe_VkVideoDecodeH265SessionParametersAddInfoKHR(*copy_src->pParametersAddInfo);
+}
+
+safe_VkVideoDecodeH265PictureInfoKHR::safe_VkVideoDecodeH265PictureInfoKHR(const VkVideoDecodeH265PictureInfoKHR* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType),
+      pStdPictureInfo(nullptr),
+      sliceSegmentCount(in_struct->sliceSegmentCount),
+      pSliceSegmentOffsets(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoDecodeH265PictureInfo(*in_struct->pStdPictureInfo);
+    }
+
+    if (in_struct->pSliceSegmentOffsets) {
+        pSliceSegmentOffsets = new uint32_t[in_struct->sliceSegmentCount];
+        memcpy((void*)pSliceSegmentOffsets, (void*)in_struct->pSliceSegmentOffsets,
+               sizeof(uint32_t) * in_struct->sliceSegmentCount);
+    }
+}
+
+safe_VkVideoDecodeH265PictureInfoKHR::safe_VkVideoDecodeH265PictureInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR),
+      pNext(nullptr),
+      pStdPictureInfo(nullptr),
+      sliceSegmentCount(),
+      pSliceSegmentOffsets(nullptr) {}
+
+safe_VkVideoDecodeH265PictureInfoKHR::safe_VkVideoDecodeH265PictureInfoKHR(const safe_VkVideoDecodeH265PictureInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pStdPictureInfo = nullptr;
+    sliceSegmentCount = copy_src.sliceSegmentCount;
+    pSliceSegmentOffsets = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoDecodeH265PictureInfo(*copy_src.pStdPictureInfo);
+    }
+
+    if (copy_src.pSliceSegmentOffsets) {
+        pSliceSegmentOffsets = new uint32_t[copy_src.sliceSegmentCount];
+        memcpy((void*)pSliceSegmentOffsets, (void*)copy_src.pSliceSegmentOffsets, sizeof(uint32_t) * copy_src.sliceSegmentCount);
+    }
+}
+
+safe_VkVideoDecodeH265PictureInfoKHR& safe_VkVideoDecodeH265PictureInfoKHR::operator=(
+    const safe_VkVideoDecodeH265PictureInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pStdPictureInfo) delete pStdPictureInfo;
+    if (pSliceSegmentOffsets) delete[] pSliceSegmentOffsets;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pStdPictureInfo = nullptr;
+    sliceSegmentCount = copy_src.sliceSegmentCount;
+    pSliceSegmentOffsets = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoDecodeH265PictureInfo(*copy_src.pStdPictureInfo);
+    }
+
+    if (copy_src.pSliceSegmentOffsets) {
+        pSliceSegmentOffsets = new uint32_t[copy_src.sliceSegmentCount];
+        memcpy((void*)pSliceSegmentOffsets, (void*)copy_src.pSliceSegmentOffsets, sizeof(uint32_t) * copy_src.sliceSegmentCount);
+    }
+
+    return *this;
+}
+
+safe_VkVideoDecodeH265PictureInfoKHR::~safe_VkVideoDecodeH265PictureInfoKHR() {
+    if (pStdPictureInfo) delete pStdPictureInfo;
+    if (pSliceSegmentOffsets) delete[] pSliceSegmentOffsets;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoDecodeH265PictureInfoKHR::initialize(const VkVideoDecodeH265PictureInfoKHR* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pStdPictureInfo) delete pStdPictureInfo;
+    if (pSliceSegmentOffsets) delete[] pSliceSegmentOffsets;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pStdPictureInfo = nullptr;
+    sliceSegmentCount = in_struct->sliceSegmentCount;
+    pSliceSegmentOffsets = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoDecodeH265PictureInfo(*in_struct->pStdPictureInfo);
+    }
+
+    if (in_struct->pSliceSegmentOffsets) {
+        pSliceSegmentOffsets = new uint32_t[in_struct->sliceSegmentCount];
+        memcpy((void*)pSliceSegmentOffsets, (void*)in_struct->pSliceSegmentOffsets,
+               sizeof(uint32_t) * in_struct->sliceSegmentCount);
+    }
+}
+
+void safe_VkVideoDecodeH265PictureInfoKHR::initialize(const safe_VkVideoDecodeH265PictureInfoKHR* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pStdPictureInfo = nullptr;
+    sliceSegmentCount = copy_src->sliceSegmentCount;
+    pSliceSegmentOffsets = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoDecodeH265PictureInfo(*copy_src->pStdPictureInfo);
+    }
+
+    if (copy_src->pSliceSegmentOffsets) {
+        pSliceSegmentOffsets = new uint32_t[copy_src->sliceSegmentCount];
+        memcpy((void*)pSliceSegmentOffsets, (void*)copy_src->pSliceSegmentOffsets, sizeof(uint32_t) * copy_src->sliceSegmentCount);
+    }
+}
+
+safe_VkVideoDecodeH265DpbSlotInfoKHR::safe_VkVideoDecodeH265DpbSlotInfoKHR(const VkVideoDecodeH265DpbSlotInfoKHR* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), pStdReferenceInfo(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoDecodeH265ReferenceInfo(*in_struct->pStdReferenceInfo);
+    }
+}
+
+safe_VkVideoDecodeH265DpbSlotInfoKHR::safe_VkVideoDecodeH265DpbSlotInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR), pNext(nullptr), pStdReferenceInfo(nullptr) {}
+
+safe_VkVideoDecodeH265DpbSlotInfoKHR::safe_VkVideoDecodeH265DpbSlotInfoKHR(const safe_VkVideoDecodeH265DpbSlotInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pStdReferenceInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoDecodeH265ReferenceInfo(*copy_src.pStdReferenceInfo);
+    }
+}
+
+safe_VkVideoDecodeH265DpbSlotInfoKHR& safe_VkVideoDecodeH265DpbSlotInfoKHR::operator=(
+    const safe_VkVideoDecodeH265DpbSlotInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pStdReferenceInfo) delete pStdReferenceInfo;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pStdReferenceInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoDecodeH265ReferenceInfo(*copy_src.pStdReferenceInfo);
+    }
+
+    return *this;
+}
+
+safe_VkVideoDecodeH265DpbSlotInfoKHR::~safe_VkVideoDecodeH265DpbSlotInfoKHR() {
+    if (pStdReferenceInfo) delete pStdReferenceInfo;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoDecodeH265DpbSlotInfoKHR::initialize(const VkVideoDecodeH265DpbSlotInfoKHR* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pStdReferenceInfo) delete pStdReferenceInfo;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pStdReferenceInfo = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoDecodeH265ReferenceInfo(*in_struct->pStdReferenceInfo);
+    }
+}
+
+void safe_VkVideoDecodeH265DpbSlotInfoKHR::initialize(const safe_VkVideoDecodeH265DpbSlotInfoKHR* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pStdReferenceInfo = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoDecodeH265ReferenceInfo(*copy_src->pStdReferenceInfo);
+    }
+}
+
+safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::safe_VkDeviceQueueGlobalPriorityCreateInfoKHR(
+    const VkDeviceQueueGlobalPriorityCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), globalPriority(in_struct->globalPriority) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::safe_VkDeviceQueueGlobalPriorityCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR), pNext(nullptr), globalPriority() {}
+
+safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::safe_VkDeviceQueueGlobalPriorityCreateInfoKHR(
+    const safe_VkDeviceQueueGlobalPriorityCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    globalPriority = copy_src.globalPriority;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDeviceQueueGlobalPriorityCreateInfoKHR& safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::operator=(
+    const safe_VkDeviceQueueGlobalPriorityCreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    globalPriority = copy_src.globalPriority;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::~safe_VkDeviceQueueGlobalPriorityCreateInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::initialize(const VkDeviceQueueGlobalPriorityCreateInfoKHR* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    globalPriority = in_struct->globalPriority;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::initialize(const safe_VkDeviceQueueGlobalPriorityCreateInfoKHR* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    globalPriority = copy_src->globalPriority;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
+    const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), globalPriorityQuery(in_struct->globalPriorityQuery) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR), pNext(nullptr), globalPriorityQuery() {}
+
+safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
+    const safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    globalPriorityQuery = copy_src.globalPriorityQuery;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    globalPriorityQuery = copy_src.globalPriorityQuery;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::~safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::initialize(
+    const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    globalPriorityQuery = in_struct->globalPriorityQuery;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::initialize(
+    const safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    globalPriorityQuery = copy_src->globalPriorityQuery;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkQueueFamilyGlobalPriorityPropertiesKHR::safe_VkQueueFamilyGlobalPriorityPropertiesKHR(
+    const VkQueueFamilyGlobalPriorityPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), priorityCount(in_struct->priorityCount) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    for (uint32_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE_KHR; ++i) {
+        priorities[i] = in_struct->priorities[i];
+    }
+}
+
+safe_VkQueueFamilyGlobalPriorityPropertiesKHR::safe_VkQueueFamilyGlobalPriorityPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR), pNext(nullptr), priorityCount() {}
+
+safe_VkQueueFamilyGlobalPriorityPropertiesKHR::safe_VkQueueFamilyGlobalPriorityPropertiesKHR(
+    const safe_VkQueueFamilyGlobalPriorityPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    priorityCount = copy_src.priorityCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE_KHR; ++i) {
+        priorities[i] = copy_src.priorities[i];
+    }
+}
+
+safe_VkQueueFamilyGlobalPriorityPropertiesKHR& safe_VkQueueFamilyGlobalPriorityPropertiesKHR::operator=(
+    const safe_VkQueueFamilyGlobalPriorityPropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    priorityCount = copy_src.priorityCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE_KHR; ++i) {
+        priorities[i] = copy_src.priorities[i];
+    }
+
+    return *this;
+}
+
+safe_VkQueueFamilyGlobalPriorityPropertiesKHR::~safe_VkQueueFamilyGlobalPriorityPropertiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkQueueFamilyGlobalPriorityPropertiesKHR::initialize(const VkQueueFamilyGlobalPriorityPropertiesKHR* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    priorityCount = in_struct->priorityCount;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    for (uint32_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE_KHR; ++i) {
+        priorities[i] = in_struct->priorities[i];
+    }
+}
+
+void safe_VkQueueFamilyGlobalPriorityPropertiesKHR::initialize(const safe_VkQueueFamilyGlobalPriorityPropertiesKHR* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    priorityCount = copy_src->priorityCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE_KHR; ++i) {
+        priorities[i] = copy_src->priorities[i];
+    }
+}
+
+safe_VkFragmentShadingRateAttachmentInfoKHR::safe_VkFragmentShadingRateAttachmentInfoKHR(
+    const VkFragmentShadingRateAttachmentInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      pFragmentShadingRateAttachment(nullptr),
+      shadingRateAttachmentTexelSize(in_struct->shadingRateAttachmentTexelSize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pFragmentShadingRateAttachment)
+        pFragmentShadingRateAttachment = new safe_VkAttachmentReference2(in_struct->pFragmentShadingRateAttachment);
+}
+
+safe_VkFragmentShadingRateAttachmentInfoKHR::safe_VkFragmentShadingRateAttachmentInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR),
+      pNext(nullptr),
+      pFragmentShadingRateAttachment(nullptr),
+      shadingRateAttachmentTexelSize() {}
+
+safe_VkFragmentShadingRateAttachmentInfoKHR::safe_VkFragmentShadingRateAttachmentInfoKHR(
+    const safe_VkFragmentShadingRateAttachmentInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pFragmentShadingRateAttachment = nullptr;
+    shadingRateAttachmentTexelSize = copy_src.shadingRateAttachmentTexelSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pFragmentShadingRateAttachment)
+        pFragmentShadingRateAttachment = new safe_VkAttachmentReference2(*copy_src.pFragmentShadingRateAttachment);
+}
+
+safe_VkFragmentShadingRateAttachmentInfoKHR& safe_VkFragmentShadingRateAttachmentInfoKHR::operator=(
+    const safe_VkFragmentShadingRateAttachmentInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pFragmentShadingRateAttachment) delete pFragmentShadingRateAttachment;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pFragmentShadingRateAttachment = nullptr;
+    shadingRateAttachmentTexelSize = copy_src.shadingRateAttachmentTexelSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pFragmentShadingRateAttachment)
+        pFragmentShadingRateAttachment = new safe_VkAttachmentReference2(*copy_src.pFragmentShadingRateAttachment);
+
+    return *this;
+}
+
+safe_VkFragmentShadingRateAttachmentInfoKHR::~safe_VkFragmentShadingRateAttachmentInfoKHR() {
+    if (pFragmentShadingRateAttachment) delete pFragmentShadingRateAttachment;
+    FreePnextChain(pNext);
+}
+
+void safe_VkFragmentShadingRateAttachmentInfoKHR::initialize(const VkFragmentShadingRateAttachmentInfoKHR* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pFragmentShadingRateAttachment) delete pFragmentShadingRateAttachment;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pFragmentShadingRateAttachment = nullptr;
+    shadingRateAttachmentTexelSize = in_struct->shadingRateAttachmentTexelSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (in_struct->pFragmentShadingRateAttachment)
+        pFragmentShadingRateAttachment = new safe_VkAttachmentReference2(in_struct->pFragmentShadingRateAttachment);
+}
+
+void safe_VkFragmentShadingRateAttachmentInfoKHR::initialize(const safe_VkFragmentShadingRateAttachmentInfoKHR* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pFragmentShadingRateAttachment = nullptr;
+    shadingRateAttachmentTexelSize = copy_src->shadingRateAttachmentTexelSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (copy_src->pFragmentShadingRateAttachment)
+        pFragmentShadingRateAttachment = new safe_VkAttachmentReference2(*copy_src->pFragmentShadingRateAttachment);
+}
+
+safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::safe_VkPipelineFragmentShadingRateStateCreateInfoKHR(
+    const VkPipelineFragmentShadingRateStateCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), fragmentSize(in_struct->fragmentSize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    for (uint32_t i = 0; i < 2; ++i) {
+        combinerOps[i] = in_struct->combinerOps[i];
+    }
+}
+
+safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::safe_VkPipelineFragmentShadingRateStateCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR), pNext(nullptr), fragmentSize() {}
+
+safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::safe_VkPipelineFragmentShadingRateStateCreateInfoKHR(
+    const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    fragmentSize = copy_src.fragmentSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < 2; ++i) {
+        combinerOps[i] = copy_src.combinerOps[i];
+    }
+}
+
+safe_VkPipelineFragmentShadingRateStateCreateInfoKHR& safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::operator=(
+    const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    fragmentSize = copy_src.fragmentSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < 2; ++i) {
+        combinerOps[i] = copy_src.combinerOps[i];
+    }
+
+    return *this;
+}
+
+safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::~safe_VkPipelineFragmentShadingRateStateCreateInfoKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::initialize(
+    const VkPipelineFragmentShadingRateStateCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    fragmentSize = in_struct->fragmentSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    for (uint32_t i = 0; i < 2; ++i) {
+        combinerOps[i] = in_struct->combinerOps[i];
+    }
+}
+
+void safe_VkPipelineFragmentShadingRateStateCreateInfoKHR::initialize(
+    const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    fragmentSize = copy_src->fragmentSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    for (uint32_t i = 0; i < 2; ++i) {
+        combinerOps[i] = copy_src->combinerOps[i];
+    }
+}
+
+safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
+    const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      pipelineFragmentShadingRate(in_struct->pipelineFragmentShadingRate),
+      primitiveFragmentShadingRate(in_struct->primitiveFragmentShadingRate),
+      attachmentFragmentShadingRate(in_struct->attachmentFragmentShadingRate) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR),
+      pNext(nullptr),
+      pipelineFragmentShadingRate(),
+      primitiveFragmentShadingRate(),
+      attachmentFragmentShadingRate() {}
+
+safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
+    const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    pipelineFragmentShadingRate = copy_src.pipelineFragmentShadingRate;
+    primitiveFragmentShadingRate = copy_src.primitiveFragmentShadingRate;
+    attachmentFragmentShadingRate = copy_src.attachmentFragmentShadingRate;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pipelineFragmentShadingRate = copy_src.pipelineFragmentShadingRate;
+    primitiveFragmentShadingRate = copy_src.primitiveFragmentShadingRate;
+    attachmentFragmentShadingRate = copy_src.attachmentFragmentShadingRate;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::~safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::initialize(
+    const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pipelineFragmentShadingRate = in_struct->pipelineFragmentShadingRate;
+    primitiveFragmentShadingRate = in_struct->primitiveFragmentShadingRate;
+    attachmentFragmentShadingRate = in_struct->attachmentFragmentShadingRate;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR::initialize(
+    const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pipelineFragmentShadingRate = copy_src->pipelineFragmentShadingRate;
+    primitiveFragmentShadingRate = copy_src->primitiveFragmentShadingRate;
+    attachmentFragmentShadingRate = copy_src->attachmentFragmentShadingRate;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
+    const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      minFragmentShadingRateAttachmentTexelSize(in_struct->minFragmentShadingRateAttachmentTexelSize),
+      maxFragmentShadingRateAttachmentTexelSize(in_struct->maxFragmentShadingRateAttachmentTexelSize),
+      maxFragmentShadingRateAttachmentTexelSizeAspectRatio(in_struct->maxFragmentShadingRateAttachmentTexelSizeAspectRatio),
+      primitiveFragmentShadingRateWithMultipleViewports(in_struct->primitiveFragmentShadingRateWithMultipleViewports),
+      layeredShadingRateAttachments(in_struct->layeredShadingRateAttachments),
+      fragmentShadingRateNonTrivialCombinerOps(in_struct->fragmentShadingRateNonTrivialCombinerOps),
+      maxFragmentSize(in_struct->maxFragmentSize),
+      maxFragmentSizeAspectRatio(in_struct->maxFragmentSizeAspectRatio),
+      maxFragmentShadingRateCoverageSamples(in_struct->maxFragmentShadingRateCoverageSamples),
+      maxFragmentShadingRateRasterizationSamples(in_struct->maxFragmentShadingRateRasterizationSamples),
+      fragmentShadingRateWithShaderDepthStencilWrites(in_struct->fragmentShadingRateWithShaderDepthStencilWrites),
+      fragmentShadingRateWithSampleMask(in_struct->fragmentShadingRateWithSampleMask),
+      fragmentShadingRateWithShaderSampleMask(in_struct->fragmentShadingRateWithShaderSampleMask),
+      fragmentShadingRateWithConservativeRasterization(in_struct->fragmentShadingRateWithConservativeRasterization),
+      fragmentShadingRateWithFragmentShaderInterlock(in_struct->fragmentShadingRateWithFragmentShaderInterlock),
+      fragmentShadingRateWithCustomSampleLocations(in_struct->fragmentShadingRateWithCustomSampleLocations),
+      fragmentShadingRateStrictMultiplyCombiner(in_struct->fragmentShadingRateStrictMultiplyCombiner) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR),
+      pNext(nullptr),
+      minFragmentShadingRateAttachmentTexelSize(),
+      maxFragmentShadingRateAttachmentTexelSize(),
+      maxFragmentShadingRateAttachmentTexelSizeAspectRatio(),
+      primitiveFragmentShadingRateWithMultipleViewports(),
+      layeredShadingRateAttachments(),
+      fragmentShadingRateNonTrivialCombinerOps(),
+      maxFragmentSize(),
+      maxFragmentSizeAspectRatio(),
+      maxFragmentShadingRateCoverageSamples(),
+      maxFragmentShadingRateRasterizationSamples(),
+      fragmentShadingRateWithShaderDepthStencilWrites(),
+      fragmentShadingRateWithSampleMask(),
+      fragmentShadingRateWithShaderSampleMask(),
+      fragmentShadingRateWithConservativeRasterization(),
+      fragmentShadingRateWithFragmentShaderInterlock(),
+      fragmentShadingRateWithCustomSampleLocations(),
+      fragmentShadingRateStrictMultiplyCombiner() {}
+
+safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
+    const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    minFragmentShadingRateAttachmentTexelSize = copy_src.minFragmentShadingRateAttachmentTexelSize;
+    maxFragmentShadingRateAttachmentTexelSize = copy_src.maxFragmentShadingRateAttachmentTexelSize;
+    maxFragmentShadingRateAttachmentTexelSizeAspectRatio = copy_src.maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
+    primitiveFragmentShadingRateWithMultipleViewports = copy_src.primitiveFragmentShadingRateWithMultipleViewports;
+    layeredShadingRateAttachments = copy_src.layeredShadingRateAttachments;
+    fragmentShadingRateNonTrivialCombinerOps = copy_src.fragmentShadingRateNonTrivialCombinerOps;
+    maxFragmentSize = copy_src.maxFragmentSize;
+    maxFragmentSizeAspectRatio = copy_src.maxFragmentSizeAspectRatio;
+    maxFragmentShadingRateCoverageSamples = copy_src.maxFragmentShadingRateCoverageSamples;
+    maxFragmentShadingRateRasterizationSamples = copy_src.maxFragmentShadingRateRasterizationSamples;
+    fragmentShadingRateWithShaderDepthStencilWrites = copy_src.fragmentShadingRateWithShaderDepthStencilWrites;
+    fragmentShadingRateWithSampleMask = copy_src.fragmentShadingRateWithSampleMask;
+    fragmentShadingRateWithShaderSampleMask = copy_src.fragmentShadingRateWithShaderSampleMask;
+    fragmentShadingRateWithConservativeRasterization = copy_src.fragmentShadingRateWithConservativeRasterization;
+    fragmentShadingRateWithFragmentShaderInterlock = copy_src.fragmentShadingRateWithFragmentShaderInterlock;
+    fragmentShadingRateWithCustomSampleLocations = copy_src.fragmentShadingRateWithCustomSampleLocations;
+    fragmentShadingRateStrictMultiplyCombiner = copy_src.fragmentShadingRateStrictMultiplyCombiner;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::operator=(
+    const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    minFragmentShadingRateAttachmentTexelSize = copy_src.minFragmentShadingRateAttachmentTexelSize;
+    maxFragmentShadingRateAttachmentTexelSize = copy_src.maxFragmentShadingRateAttachmentTexelSize;
+    maxFragmentShadingRateAttachmentTexelSizeAspectRatio = copy_src.maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
+    primitiveFragmentShadingRateWithMultipleViewports = copy_src.primitiveFragmentShadingRateWithMultipleViewports;
+    layeredShadingRateAttachments = copy_src.layeredShadingRateAttachments;
+    fragmentShadingRateNonTrivialCombinerOps = copy_src.fragmentShadingRateNonTrivialCombinerOps;
+    maxFragmentSize = copy_src.maxFragmentSize;
+    maxFragmentSizeAspectRatio = copy_src.maxFragmentSizeAspectRatio;
+    maxFragmentShadingRateCoverageSamples = copy_src.maxFragmentShadingRateCoverageSamples;
+    maxFragmentShadingRateRasterizationSamples = copy_src.maxFragmentShadingRateRasterizationSamples;
+    fragmentShadingRateWithShaderDepthStencilWrites = copy_src.fragmentShadingRateWithShaderDepthStencilWrites;
+    fragmentShadingRateWithSampleMask = copy_src.fragmentShadingRateWithSampleMask;
+    fragmentShadingRateWithShaderSampleMask = copy_src.fragmentShadingRateWithShaderSampleMask;
+    fragmentShadingRateWithConservativeRasterization = copy_src.fragmentShadingRateWithConservativeRasterization;
+    fragmentShadingRateWithFragmentShaderInterlock = copy_src.fragmentShadingRateWithFragmentShaderInterlock;
+    fragmentShadingRateWithCustomSampleLocations = copy_src.fragmentShadingRateWithCustomSampleLocations;
+    fragmentShadingRateStrictMultiplyCombiner = copy_src.fragmentShadingRateStrictMultiplyCombiner;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::~safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::initialize(
+    const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    minFragmentShadingRateAttachmentTexelSize = in_struct->minFragmentShadingRateAttachmentTexelSize;
+    maxFragmentShadingRateAttachmentTexelSize = in_struct->maxFragmentShadingRateAttachmentTexelSize;
+    maxFragmentShadingRateAttachmentTexelSizeAspectRatio = in_struct->maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
+    primitiveFragmentShadingRateWithMultipleViewports = in_struct->primitiveFragmentShadingRateWithMultipleViewports;
+    layeredShadingRateAttachments = in_struct->layeredShadingRateAttachments;
+    fragmentShadingRateNonTrivialCombinerOps = in_struct->fragmentShadingRateNonTrivialCombinerOps;
+    maxFragmentSize = in_struct->maxFragmentSize;
+    maxFragmentSizeAspectRatio = in_struct->maxFragmentSizeAspectRatio;
+    maxFragmentShadingRateCoverageSamples = in_struct->maxFragmentShadingRateCoverageSamples;
+    maxFragmentShadingRateRasterizationSamples = in_struct->maxFragmentShadingRateRasterizationSamples;
+    fragmentShadingRateWithShaderDepthStencilWrites = in_struct->fragmentShadingRateWithShaderDepthStencilWrites;
+    fragmentShadingRateWithSampleMask = in_struct->fragmentShadingRateWithSampleMask;
+    fragmentShadingRateWithShaderSampleMask = in_struct->fragmentShadingRateWithShaderSampleMask;
+    fragmentShadingRateWithConservativeRasterization = in_struct->fragmentShadingRateWithConservativeRasterization;
+    fragmentShadingRateWithFragmentShaderInterlock = in_struct->fragmentShadingRateWithFragmentShaderInterlock;
+    fragmentShadingRateWithCustomSampleLocations = in_struct->fragmentShadingRateWithCustomSampleLocations;
+    fragmentShadingRateStrictMultiplyCombiner = in_struct->fragmentShadingRateStrictMultiplyCombiner;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR::initialize(
+    const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    minFragmentShadingRateAttachmentTexelSize = copy_src->minFragmentShadingRateAttachmentTexelSize;
+    maxFragmentShadingRateAttachmentTexelSize = copy_src->maxFragmentShadingRateAttachmentTexelSize;
+    maxFragmentShadingRateAttachmentTexelSizeAspectRatio = copy_src->maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
+    primitiveFragmentShadingRateWithMultipleViewports = copy_src->primitiveFragmentShadingRateWithMultipleViewports;
+    layeredShadingRateAttachments = copy_src->layeredShadingRateAttachments;
+    fragmentShadingRateNonTrivialCombinerOps = copy_src->fragmentShadingRateNonTrivialCombinerOps;
+    maxFragmentSize = copy_src->maxFragmentSize;
+    maxFragmentSizeAspectRatio = copy_src->maxFragmentSizeAspectRatio;
+    maxFragmentShadingRateCoverageSamples = copy_src->maxFragmentShadingRateCoverageSamples;
+    maxFragmentShadingRateRasterizationSamples = copy_src->maxFragmentShadingRateRasterizationSamples;
+    fragmentShadingRateWithShaderDepthStencilWrites = copy_src->fragmentShadingRateWithShaderDepthStencilWrites;
+    fragmentShadingRateWithSampleMask = copy_src->fragmentShadingRateWithSampleMask;
+    fragmentShadingRateWithShaderSampleMask = copy_src->fragmentShadingRateWithShaderSampleMask;
+    fragmentShadingRateWithConservativeRasterization = copy_src->fragmentShadingRateWithConservativeRasterization;
+    fragmentShadingRateWithFragmentShaderInterlock = copy_src->fragmentShadingRateWithFragmentShaderInterlock;
+    fragmentShadingRateWithCustomSampleLocations = copy_src->fragmentShadingRateWithCustomSampleLocations;
+    fragmentShadingRateStrictMultiplyCombiner = copy_src->fragmentShadingRateStrictMultiplyCombiner;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceFragmentShadingRateKHR::safe_VkPhysicalDeviceFragmentShadingRateKHR(
+    const VkPhysicalDeviceFragmentShadingRateKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), sampleCounts(in_struct->sampleCounts), fragmentSize(in_struct->fragmentSize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceFragmentShadingRateKHR::safe_VkPhysicalDeviceFragmentShadingRateKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR), pNext(nullptr), sampleCounts(), fragmentSize() {}
+
+safe_VkPhysicalDeviceFragmentShadingRateKHR::safe_VkPhysicalDeviceFragmentShadingRateKHR(
+    const safe_VkPhysicalDeviceFragmentShadingRateKHR& copy_src) {
+    sType = copy_src.sType;
+    sampleCounts = copy_src.sampleCounts;
+    fragmentSize = copy_src.fragmentSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceFragmentShadingRateKHR& safe_VkPhysicalDeviceFragmentShadingRateKHR::operator=(
+    const safe_VkPhysicalDeviceFragmentShadingRateKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    sampleCounts = copy_src.sampleCounts;
+    fragmentSize = copy_src.fragmentSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceFragmentShadingRateKHR::~safe_VkPhysicalDeviceFragmentShadingRateKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceFragmentShadingRateKHR::initialize(const VkPhysicalDeviceFragmentShadingRateKHR* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    sampleCounts = in_struct->sampleCounts;
+    fragmentSize = in_struct->fragmentSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceFragmentShadingRateKHR::initialize(const safe_VkPhysicalDeviceFragmentShadingRateKHR* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    sampleCounts = copy_src->sampleCounts;
+    fragmentSize = copy_src->fragmentSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR(
+    const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), dynamicRenderingLocalRead(in_struct->dynamicRenderingLocalRead) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR),
+      pNext(nullptr),
+      dynamicRenderingLocalRead() {}
+
+safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR(
+    const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    dynamicRenderingLocalRead = copy_src.dynamicRenderingLocalRead;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    dynamicRenderingLocalRead = copy_src.dynamicRenderingLocalRead;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::~safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::initialize(
+    const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    dynamicRenderingLocalRead = in_struct->dynamicRenderingLocalRead;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::initialize(
+    const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    dynamicRenderingLocalRead = copy_src->dynamicRenderingLocalRead;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkRenderingAttachmentLocationInfoKHR::safe_VkRenderingAttachmentLocationInfoKHR(
+    const VkRenderingAttachmentLocationInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), colorAttachmentCount(in_struct->colorAttachmentCount), pColorAttachmentLocations(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pColorAttachmentLocations) {
+        pColorAttachmentLocations = new uint32_t[in_struct->colorAttachmentCount];
+        memcpy((void*)pColorAttachmentLocations, (void*)in_struct->pColorAttachmentLocations,
+               sizeof(uint32_t) * in_struct->colorAttachmentCount);
+    }
+}
+
+safe_VkRenderingAttachmentLocationInfoKHR::safe_VkRenderingAttachmentLocationInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR),
+      pNext(nullptr),
+      colorAttachmentCount(),
+      pColorAttachmentLocations(nullptr) {}
+
+safe_VkRenderingAttachmentLocationInfoKHR::safe_VkRenderingAttachmentLocationInfoKHR(
+    const safe_VkRenderingAttachmentLocationInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    colorAttachmentCount = copy_src.colorAttachmentCount;
+    pColorAttachmentLocations = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pColorAttachmentLocations) {
+        pColorAttachmentLocations = new uint32_t[copy_src.colorAttachmentCount];
+        memcpy((void*)pColorAttachmentLocations, (void*)copy_src.pColorAttachmentLocations,
+               sizeof(uint32_t) * copy_src.colorAttachmentCount);
+    }
+}
+
+safe_VkRenderingAttachmentLocationInfoKHR& safe_VkRenderingAttachmentLocationInfoKHR::operator=(
+    const safe_VkRenderingAttachmentLocationInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pColorAttachmentLocations) delete[] pColorAttachmentLocations;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    colorAttachmentCount = copy_src.colorAttachmentCount;
+    pColorAttachmentLocations = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pColorAttachmentLocations) {
+        pColorAttachmentLocations = new uint32_t[copy_src.colorAttachmentCount];
+        memcpy((void*)pColorAttachmentLocations, (void*)copy_src.pColorAttachmentLocations,
+               sizeof(uint32_t) * copy_src.colorAttachmentCount);
+    }
+
+    return *this;
+}
+
+safe_VkRenderingAttachmentLocationInfoKHR::~safe_VkRenderingAttachmentLocationInfoKHR() {
+    if (pColorAttachmentLocations) delete[] pColorAttachmentLocations;
+    FreePnextChain(pNext);
+}
+
+void safe_VkRenderingAttachmentLocationInfoKHR::initialize(const VkRenderingAttachmentLocationInfoKHR* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pColorAttachmentLocations) delete[] pColorAttachmentLocations;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    colorAttachmentCount = in_struct->colorAttachmentCount;
+    pColorAttachmentLocations = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pColorAttachmentLocations) {
+        pColorAttachmentLocations = new uint32_t[in_struct->colorAttachmentCount];
+        memcpy((void*)pColorAttachmentLocations, (void*)in_struct->pColorAttachmentLocations,
+               sizeof(uint32_t) * in_struct->colorAttachmentCount);
+    }
+}
+
+void safe_VkRenderingAttachmentLocationInfoKHR::initialize(const safe_VkRenderingAttachmentLocationInfoKHR* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    colorAttachmentCount = copy_src->colorAttachmentCount;
+    pColorAttachmentLocations = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pColorAttachmentLocations) {
+        pColorAttachmentLocations = new uint32_t[copy_src->colorAttachmentCount];
+        memcpy((void*)pColorAttachmentLocations, (void*)copy_src->pColorAttachmentLocations,
+               sizeof(uint32_t) * copy_src->colorAttachmentCount);
+    }
+}
+
+safe_VkRenderingInputAttachmentIndexInfoKHR::safe_VkRenderingInputAttachmentIndexInfoKHR(
+    const VkRenderingInputAttachmentIndexInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      colorAttachmentCount(in_struct->colorAttachmentCount),
+      pColorAttachmentInputIndices(nullptr),
+      pDepthInputAttachmentIndex(nullptr),
+      pStencilInputAttachmentIndex(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pColorAttachmentInputIndices) {
+        pColorAttachmentInputIndices = new uint32_t[in_struct->colorAttachmentCount];
+        memcpy((void*)pColorAttachmentInputIndices, (void*)in_struct->pColorAttachmentInputIndices,
+               sizeof(uint32_t) * in_struct->colorAttachmentCount);
+    }
+
+    if (in_struct->pDepthInputAttachmentIndex) {
+        pDepthInputAttachmentIndex = new uint32_t(*in_struct->pDepthInputAttachmentIndex);
+    }
+
+    if (in_struct->pStencilInputAttachmentIndex) {
+        pStencilInputAttachmentIndex = new uint32_t(*in_struct->pStencilInputAttachmentIndex);
+    }
+}
+
+safe_VkRenderingInputAttachmentIndexInfoKHR::safe_VkRenderingInputAttachmentIndexInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR),
+      pNext(nullptr),
+      colorAttachmentCount(),
+      pColorAttachmentInputIndices(nullptr),
+      pDepthInputAttachmentIndex(nullptr),
+      pStencilInputAttachmentIndex(nullptr) {}
+
+safe_VkRenderingInputAttachmentIndexInfoKHR::safe_VkRenderingInputAttachmentIndexInfoKHR(
+    const safe_VkRenderingInputAttachmentIndexInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    colorAttachmentCount = copy_src.colorAttachmentCount;
+    pColorAttachmentInputIndices = nullptr;
+    pDepthInputAttachmentIndex = nullptr;
+    pStencilInputAttachmentIndex = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pColorAttachmentInputIndices) {
+        pColorAttachmentInputIndices = new uint32_t[copy_src.colorAttachmentCount];
+        memcpy((void*)pColorAttachmentInputIndices, (void*)copy_src.pColorAttachmentInputIndices,
+               sizeof(uint32_t) * copy_src.colorAttachmentCount);
+    }
+
+    if (copy_src.pDepthInputAttachmentIndex) {
+        pDepthInputAttachmentIndex = new uint32_t(*copy_src.pDepthInputAttachmentIndex);
+    }
+
+    if (copy_src.pStencilInputAttachmentIndex) {
+        pStencilInputAttachmentIndex = new uint32_t(*copy_src.pStencilInputAttachmentIndex);
+    }
+}
+
+safe_VkRenderingInputAttachmentIndexInfoKHR& safe_VkRenderingInputAttachmentIndexInfoKHR::operator=(
+    const safe_VkRenderingInputAttachmentIndexInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pColorAttachmentInputIndices) delete[] pColorAttachmentInputIndices;
+    if (pDepthInputAttachmentIndex) delete pDepthInputAttachmentIndex;
+    if (pStencilInputAttachmentIndex) delete pStencilInputAttachmentIndex;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    colorAttachmentCount = copy_src.colorAttachmentCount;
+    pColorAttachmentInputIndices = nullptr;
+    pDepthInputAttachmentIndex = nullptr;
+    pStencilInputAttachmentIndex = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pColorAttachmentInputIndices) {
+        pColorAttachmentInputIndices = new uint32_t[copy_src.colorAttachmentCount];
+        memcpy((void*)pColorAttachmentInputIndices, (void*)copy_src.pColorAttachmentInputIndices,
+               sizeof(uint32_t) * copy_src.colorAttachmentCount);
+    }
+
+    if (copy_src.pDepthInputAttachmentIndex) {
+        pDepthInputAttachmentIndex = new uint32_t(*copy_src.pDepthInputAttachmentIndex);
+    }
+
+    if (copy_src.pStencilInputAttachmentIndex) {
+        pStencilInputAttachmentIndex = new uint32_t(*copy_src.pStencilInputAttachmentIndex);
+    }
+
+    return *this;
+}
+
+safe_VkRenderingInputAttachmentIndexInfoKHR::~safe_VkRenderingInputAttachmentIndexInfoKHR() {
+    if (pColorAttachmentInputIndices) delete[] pColorAttachmentInputIndices;
+    if (pDepthInputAttachmentIndex) delete pDepthInputAttachmentIndex;
+    if (pStencilInputAttachmentIndex) delete pStencilInputAttachmentIndex;
+    FreePnextChain(pNext);
+}
+
+void safe_VkRenderingInputAttachmentIndexInfoKHR::initialize(const VkRenderingInputAttachmentIndexInfoKHR* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pColorAttachmentInputIndices) delete[] pColorAttachmentInputIndices;
+    if (pDepthInputAttachmentIndex) delete pDepthInputAttachmentIndex;
+    if (pStencilInputAttachmentIndex) delete pStencilInputAttachmentIndex;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    colorAttachmentCount = in_struct->colorAttachmentCount;
+    pColorAttachmentInputIndices = nullptr;
+    pDepthInputAttachmentIndex = nullptr;
+    pStencilInputAttachmentIndex = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pColorAttachmentInputIndices) {
+        pColorAttachmentInputIndices = new uint32_t[in_struct->colorAttachmentCount];
+        memcpy((void*)pColorAttachmentInputIndices, (void*)in_struct->pColorAttachmentInputIndices,
+               sizeof(uint32_t) * in_struct->colorAttachmentCount);
+    }
+
+    if (in_struct->pDepthInputAttachmentIndex) {
+        pDepthInputAttachmentIndex = new uint32_t(*in_struct->pDepthInputAttachmentIndex);
+    }
+
+    if (in_struct->pStencilInputAttachmentIndex) {
+        pStencilInputAttachmentIndex = new uint32_t(*in_struct->pStencilInputAttachmentIndex);
+    }
+}
+
+void safe_VkRenderingInputAttachmentIndexInfoKHR::initialize(const safe_VkRenderingInputAttachmentIndexInfoKHR* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    colorAttachmentCount = copy_src->colorAttachmentCount;
+    pColorAttachmentInputIndices = nullptr;
+    pDepthInputAttachmentIndex = nullptr;
+    pStencilInputAttachmentIndex = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pColorAttachmentInputIndices) {
+        pColorAttachmentInputIndices = new uint32_t[copy_src->colorAttachmentCount];
+        memcpy((void*)pColorAttachmentInputIndices, (void*)copy_src->pColorAttachmentInputIndices,
+               sizeof(uint32_t) * copy_src->colorAttachmentCount);
+    }
+
+    if (copy_src->pDepthInputAttachmentIndex) {
+        pDepthInputAttachmentIndex = new uint32_t(*copy_src->pDepthInputAttachmentIndex);
+    }
+
+    if (copy_src->pStencilInputAttachmentIndex) {
+        pStencilInputAttachmentIndex = new uint32_t(*copy_src->pStencilInputAttachmentIndex);
+    }
+}
+
+safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR(
+    const VkPhysicalDeviceShaderQuadControlFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), shaderQuadControl(in_struct->shaderQuadControl) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR), pNext(nullptr), shaderQuadControl() {}
+
+safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR(
+    const safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    shaderQuadControl = copy_src.shaderQuadControl;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR& safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderQuadControl = copy_src.shaderQuadControl;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::~safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::initialize(const VkPhysicalDeviceShaderQuadControlFeaturesKHR* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderQuadControl = in_struct->shaderQuadControl;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::initialize(
+    const safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderQuadControl = copy_src->shaderQuadControl;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSurfaceProtectedCapabilitiesKHR::safe_VkSurfaceProtectedCapabilitiesKHR(const VkSurfaceProtectedCapabilitiesKHR* in_struct,
+                                                                               [[maybe_unused]] PNextCopyState* copy_state,
+                                                                               bool copy_pnext)
+    : sType(in_struct->sType), supportsProtected(in_struct->supportsProtected) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSurfaceProtectedCapabilitiesKHR::safe_VkSurfaceProtectedCapabilitiesKHR()
+    : sType(VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR), pNext(nullptr), supportsProtected() {}
+
+safe_VkSurfaceProtectedCapabilitiesKHR::safe_VkSurfaceProtectedCapabilitiesKHR(
+    const safe_VkSurfaceProtectedCapabilitiesKHR& copy_src) {
+    sType = copy_src.sType;
+    supportsProtected = copy_src.supportsProtected;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSurfaceProtectedCapabilitiesKHR& safe_VkSurfaceProtectedCapabilitiesKHR::operator=(
+    const safe_VkSurfaceProtectedCapabilitiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    supportsProtected = copy_src.supportsProtected;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSurfaceProtectedCapabilitiesKHR::~safe_VkSurfaceProtectedCapabilitiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkSurfaceProtectedCapabilitiesKHR::initialize(const VkSurfaceProtectedCapabilitiesKHR* in_struct,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    supportsProtected = in_struct->supportsProtected;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSurfaceProtectedCapabilitiesKHR::initialize(const safe_VkSurfaceProtectedCapabilitiesKHR* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    supportsProtected = copy_src->supportsProtected;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDevicePresentWaitFeaturesKHR::safe_VkPhysicalDevicePresentWaitFeaturesKHR(
+    const VkPhysicalDevicePresentWaitFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), presentWait(in_struct->presentWait) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePresentWaitFeaturesKHR::safe_VkPhysicalDevicePresentWaitFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR), pNext(nullptr), presentWait() {}
+
+safe_VkPhysicalDevicePresentWaitFeaturesKHR::safe_VkPhysicalDevicePresentWaitFeaturesKHR(
+    const safe_VkPhysicalDevicePresentWaitFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    presentWait = copy_src.presentWait;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePresentWaitFeaturesKHR& safe_VkPhysicalDevicePresentWaitFeaturesKHR::operator=(
+    const safe_VkPhysicalDevicePresentWaitFeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    presentWait = copy_src.presentWait;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePresentWaitFeaturesKHR::~safe_VkPhysicalDevicePresentWaitFeaturesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDevicePresentWaitFeaturesKHR::initialize(const VkPhysicalDevicePresentWaitFeaturesKHR* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    presentWait = in_struct->presentWait;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePresentWaitFeaturesKHR::initialize(const safe_VkPhysicalDevicePresentWaitFeaturesKHR* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    presentWait = copy_src->presentWait;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
+    const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), pipelineExecutableInfo(in_struct->pipelineExecutableInfo) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR),
+      pNext(nullptr),
+      pipelineExecutableInfo() {}
+
+safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
+    const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    pipelineExecutableInfo = copy_src.pipelineExecutableInfo;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR&
+safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::operator=(
+    const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pipelineExecutableInfo = copy_src.pipelineExecutableInfo;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::~safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::initialize(
+    const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pipelineExecutableInfo = in_struct->pipelineExecutableInfo;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::initialize(
+    const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pipelineExecutableInfo = copy_src->pipelineExecutableInfo;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineInfoKHR::safe_VkPipelineInfoKHR(const VkPipelineInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                               bool copy_pnext)
+    : sType(in_struct->sType), pipeline(in_struct->pipeline) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPipelineInfoKHR::safe_VkPipelineInfoKHR() : sType(VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR), pNext(nullptr), pipeline() {}
+
+safe_VkPipelineInfoKHR::safe_VkPipelineInfoKHR(const safe_VkPipelineInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pipeline = copy_src.pipeline;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPipelineInfoKHR& safe_VkPipelineInfoKHR::operator=(const safe_VkPipelineInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pipeline = copy_src.pipeline;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineInfoKHR::~safe_VkPipelineInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkPipelineInfoKHR::initialize(const VkPipelineInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pipeline = in_struct->pipeline;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPipelineInfoKHR::initialize(const safe_VkPipelineInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pipeline = copy_src->pipeline;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineExecutablePropertiesKHR::safe_VkPipelineExecutablePropertiesKHR(const VkPipelineExecutablePropertiesKHR* in_struct,
+                                                                               [[maybe_unused]] PNextCopyState* copy_state,
+                                                                               bool copy_pnext)
+    : sType(in_struct->sType), stages(in_struct->stages), subgroupSize(in_struct->subgroupSize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = in_struct->name[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = in_struct->description[i];
+    }
+}
+
+safe_VkPipelineExecutablePropertiesKHR::safe_VkPipelineExecutablePropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR), pNext(nullptr), stages(), subgroupSize() {}
+
+safe_VkPipelineExecutablePropertiesKHR::safe_VkPipelineExecutablePropertiesKHR(
+    const safe_VkPipelineExecutablePropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    stages = copy_src.stages;
+    subgroupSize = copy_src.subgroupSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = copy_src.name[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = copy_src.description[i];
+    }
+}
+
+safe_VkPipelineExecutablePropertiesKHR& safe_VkPipelineExecutablePropertiesKHR::operator=(
+    const safe_VkPipelineExecutablePropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    stages = copy_src.stages;
+    subgroupSize = copy_src.subgroupSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = copy_src.name[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = copy_src.description[i];
+    }
+
+    return *this;
+}
+
+safe_VkPipelineExecutablePropertiesKHR::~safe_VkPipelineExecutablePropertiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPipelineExecutablePropertiesKHR::initialize(const VkPipelineExecutablePropertiesKHR* in_struct,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    stages = in_struct->stages;
+    subgroupSize = in_struct->subgroupSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = in_struct->name[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = in_struct->description[i];
+    }
+}
+
+void safe_VkPipelineExecutablePropertiesKHR::initialize(const safe_VkPipelineExecutablePropertiesKHR* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stages = copy_src->stages;
+    subgroupSize = copy_src->subgroupSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = copy_src->name[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = copy_src->description[i];
+    }
+}
+
+safe_VkPipelineExecutableInfoKHR::safe_VkPipelineExecutableInfoKHR(const VkPipelineExecutableInfoKHR* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), pipeline(in_struct->pipeline), executableIndex(in_struct->executableIndex) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPipelineExecutableInfoKHR::safe_VkPipelineExecutableInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR), pNext(nullptr), pipeline(), executableIndex() {}
+
+safe_VkPipelineExecutableInfoKHR::safe_VkPipelineExecutableInfoKHR(const safe_VkPipelineExecutableInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pipeline = copy_src.pipeline;
+    executableIndex = copy_src.executableIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPipelineExecutableInfoKHR& safe_VkPipelineExecutableInfoKHR::operator=(const safe_VkPipelineExecutableInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pipeline = copy_src.pipeline;
+    executableIndex = copy_src.executableIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineExecutableInfoKHR::~safe_VkPipelineExecutableInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkPipelineExecutableInfoKHR::initialize(const VkPipelineExecutableInfoKHR* in_struct,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pipeline = in_struct->pipeline;
+    executableIndex = in_struct->executableIndex;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPipelineExecutableInfoKHR::initialize(const safe_VkPipelineExecutableInfoKHR* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pipeline = copy_src->pipeline;
+    executableIndex = copy_src->executableIndex;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineExecutableStatisticKHR::safe_VkPipelineExecutableStatisticKHR(const VkPipelineExecutableStatisticKHR* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType), format(in_struct->format), value(in_struct->value) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = in_struct->name[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = in_struct->description[i];
+    }
+}
+
+safe_VkPipelineExecutableStatisticKHR::safe_VkPipelineExecutableStatisticKHR()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR), pNext(nullptr), format(), value() {}
+
+safe_VkPipelineExecutableStatisticKHR::safe_VkPipelineExecutableStatisticKHR(
+    const safe_VkPipelineExecutableStatisticKHR& copy_src) {
+    sType = copy_src.sType;
+    format = copy_src.format;
+    value = copy_src.value;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = copy_src.name[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = copy_src.description[i];
+    }
+}
+
+safe_VkPipelineExecutableStatisticKHR& safe_VkPipelineExecutableStatisticKHR::operator=(
+    const safe_VkPipelineExecutableStatisticKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    format = copy_src.format;
+    value = copy_src.value;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = copy_src.name[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = copy_src.description[i];
+    }
+
+    return *this;
+}
+
+safe_VkPipelineExecutableStatisticKHR::~safe_VkPipelineExecutableStatisticKHR() { FreePnextChain(pNext); }
+
+void safe_VkPipelineExecutableStatisticKHR::initialize(const VkPipelineExecutableStatisticKHR* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    format = in_struct->format;
+    value = in_struct->value;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = in_struct->name[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = in_struct->description[i];
+    }
+}
+
+void safe_VkPipelineExecutableStatisticKHR::initialize(const safe_VkPipelineExecutableStatisticKHR* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    format = copy_src->format;
+    value = copy_src->value;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = copy_src->name[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = copy_src->description[i];
+    }
+}
+
+safe_VkPipelineExecutableInternalRepresentationKHR::safe_VkPipelineExecutableInternalRepresentationKHR(
+    const VkPipelineExecutableInternalRepresentationKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), isText(in_struct->isText), dataSize(in_struct->dataSize), pData(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = in_struct->name[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = in_struct->description[i];
+    }
+
+    if (in_struct->pData != nullptr) {
+        auto temp = new std::byte[in_struct->dataSize];
+        std::memcpy(temp, in_struct->pData, in_struct->dataSize);
+        pData = temp;
+    }
+}
+
+safe_VkPipelineExecutableInternalRepresentationKHR::safe_VkPipelineExecutableInternalRepresentationKHR()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR),
+      pNext(nullptr),
+      isText(),
+      dataSize(),
+      pData(nullptr) {}
+
+safe_VkPipelineExecutableInternalRepresentationKHR::safe_VkPipelineExecutableInternalRepresentationKHR(
+    const safe_VkPipelineExecutableInternalRepresentationKHR& copy_src) {
+    sType = copy_src.sType;
+    isText = copy_src.isText;
+    dataSize = copy_src.dataSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = copy_src.name[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = copy_src.description[i];
+    }
+
+    if (copy_src.pData != nullptr) {
+        auto temp = new std::byte[copy_src.dataSize];
+        std::memcpy(temp, copy_src.pData, copy_src.dataSize);
+        pData = temp;
+    }
+}
+
+safe_VkPipelineExecutableInternalRepresentationKHR& safe_VkPipelineExecutableInternalRepresentationKHR::operator=(
+    const safe_VkPipelineExecutableInternalRepresentationKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pData != nullptr) {
+        auto temp = reinterpret_cast<const std::byte*>(pData);
+        delete[] temp;
+    }
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    isText = copy_src.isText;
+    dataSize = copy_src.dataSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = copy_src.name[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = copy_src.description[i];
+    }
+
+    if (copy_src.pData != nullptr) {
+        auto temp = new std::byte[copy_src.dataSize];
+        std::memcpy(temp, copy_src.pData, copy_src.dataSize);
+        pData = temp;
+    }
+
+    return *this;
+}
+
+safe_VkPipelineExecutableInternalRepresentationKHR::~safe_VkPipelineExecutableInternalRepresentationKHR() {
+    if (pData != nullptr) {
+        auto temp = reinterpret_cast<const std::byte*>(pData);
+        delete[] temp;
+    }
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineExecutableInternalRepresentationKHR::initialize(const VkPipelineExecutableInternalRepresentationKHR* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pData != nullptr) {
+        auto temp = reinterpret_cast<const std::byte*>(pData);
+        delete[] temp;
+    }
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    isText = in_struct->isText;
+    dataSize = in_struct->dataSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = in_struct->name[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = in_struct->description[i];
+    }
+
+    if (in_struct->pData != nullptr) {
+        auto temp = new std::byte[in_struct->dataSize];
+        std::memcpy(temp, in_struct->pData, in_struct->dataSize);
+        pData = temp;
+    }
+}
+
+void safe_VkPipelineExecutableInternalRepresentationKHR::initialize(
+    const safe_VkPipelineExecutableInternalRepresentationKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    isText = copy_src->isText;
+    dataSize = copy_src->dataSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = copy_src->name[i];
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = copy_src->description[i];
+    }
+
+    if (copy_src->pData != nullptr) {
+        auto temp = new std::byte[copy_src->dataSize];
+        std::memcpy(temp, copy_src->pData, copy_src->dataSize);
+        pData = temp;
+    }
+}
+
+safe_VkMemoryMapInfoKHR::safe_VkMemoryMapInfoKHR(const VkMemoryMapInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                                 bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      memory(in_struct->memory),
+      offset(in_struct->offset),
+      size(in_struct->size) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMemoryMapInfoKHR::safe_VkMemoryMapInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR), pNext(nullptr), flags(), memory(), offset(), size() {}
+
+safe_VkMemoryMapInfoKHR::safe_VkMemoryMapInfoKHR(const safe_VkMemoryMapInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    memory = copy_src.memory;
+    offset = copy_src.offset;
+    size = copy_src.size;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMemoryMapInfoKHR& safe_VkMemoryMapInfoKHR::operator=(const safe_VkMemoryMapInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    memory = copy_src.memory;
+    offset = copy_src.offset;
+    size = copy_src.size;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMemoryMapInfoKHR::~safe_VkMemoryMapInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkMemoryMapInfoKHR::initialize(const VkMemoryMapInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    memory = in_struct->memory;
+    offset = in_struct->offset;
+    size = in_struct->size;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMemoryMapInfoKHR::initialize(const safe_VkMemoryMapInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    memory = copy_src->memory;
+    offset = copy_src->offset;
+    size = copy_src->size;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkMemoryUnmapInfoKHR::safe_VkMemoryUnmapInfoKHR(const VkMemoryUnmapInfoKHR* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags), memory(in_struct->memory) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMemoryUnmapInfoKHR::safe_VkMemoryUnmapInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR), pNext(nullptr), flags(), memory() {}
+
+safe_VkMemoryUnmapInfoKHR::safe_VkMemoryUnmapInfoKHR(const safe_VkMemoryUnmapInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    memory = copy_src.memory;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMemoryUnmapInfoKHR& safe_VkMemoryUnmapInfoKHR::operator=(const safe_VkMemoryUnmapInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    memory = copy_src.memory;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMemoryUnmapInfoKHR::~safe_VkMemoryUnmapInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkMemoryUnmapInfoKHR::initialize(const VkMemoryUnmapInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    memory = in_struct->memory;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMemoryUnmapInfoKHR::initialize(const safe_VkMemoryUnmapInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    memory = copy_src->memory;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineLibraryCreateInfoKHR::safe_VkPipelineLibraryCreateInfoKHR(const VkPipelineLibraryCreateInfoKHR* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType), libraryCount(in_struct->libraryCount), pLibraries(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (libraryCount && in_struct->pLibraries) {
+        pLibraries = new VkPipeline[libraryCount];
+        for (uint32_t i = 0; i < libraryCount; ++i) {
+            pLibraries[i] = in_struct->pLibraries[i];
+        }
+    }
+}
+
+safe_VkPipelineLibraryCreateInfoKHR::safe_VkPipelineLibraryCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR), pNext(nullptr), libraryCount(), pLibraries(nullptr) {}
+
+safe_VkPipelineLibraryCreateInfoKHR::safe_VkPipelineLibraryCreateInfoKHR(const safe_VkPipelineLibraryCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    libraryCount = copy_src.libraryCount;
+    pLibraries = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (libraryCount && copy_src.pLibraries) {
+        pLibraries = new VkPipeline[libraryCount];
+        for (uint32_t i = 0; i < libraryCount; ++i) {
+            pLibraries[i] = copy_src.pLibraries[i];
+        }
+    }
+}
+
+safe_VkPipelineLibraryCreateInfoKHR& safe_VkPipelineLibraryCreateInfoKHR::operator=(
+    const safe_VkPipelineLibraryCreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pLibraries) delete[] pLibraries;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    libraryCount = copy_src.libraryCount;
+    pLibraries = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (libraryCount && copy_src.pLibraries) {
+        pLibraries = new VkPipeline[libraryCount];
+        for (uint32_t i = 0; i < libraryCount; ++i) {
+            pLibraries[i] = copy_src.pLibraries[i];
+        }
+    }
+
+    return *this;
+}
+
+safe_VkPipelineLibraryCreateInfoKHR::~safe_VkPipelineLibraryCreateInfoKHR() {
+    if (pLibraries) delete[] pLibraries;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineLibraryCreateInfoKHR::initialize(const VkPipelineLibraryCreateInfoKHR* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pLibraries) delete[] pLibraries;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    libraryCount = in_struct->libraryCount;
+    pLibraries = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (libraryCount && in_struct->pLibraries) {
+        pLibraries = new VkPipeline[libraryCount];
+        for (uint32_t i = 0; i < libraryCount; ++i) {
+            pLibraries[i] = in_struct->pLibraries[i];
+        }
+    }
+}
+
+void safe_VkPipelineLibraryCreateInfoKHR::initialize(const safe_VkPipelineLibraryCreateInfoKHR* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    libraryCount = copy_src->libraryCount;
+    pLibraries = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (libraryCount && copy_src->pLibraries) {
+        pLibraries = new VkPipeline[libraryCount];
+        for (uint32_t i = 0; i < libraryCount; ++i) {
+            pLibraries[i] = copy_src->pLibraries[i];
+        }
+    }
+}
+
+safe_VkPresentIdKHR::safe_VkPresentIdKHR(const VkPresentIdKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                         bool copy_pnext)
+    : sType(in_struct->sType), swapchainCount(in_struct->swapchainCount), pPresentIds(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pPresentIds) {
+        pPresentIds = new uint64_t[in_struct->swapchainCount];
+        memcpy((void*)pPresentIds, (void*)in_struct->pPresentIds, sizeof(uint64_t) * in_struct->swapchainCount);
+    }
+}
+
+safe_VkPresentIdKHR::safe_VkPresentIdKHR()
+    : sType(VK_STRUCTURE_TYPE_PRESENT_ID_KHR), pNext(nullptr), swapchainCount(), pPresentIds(nullptr) {}
+
+safe_VkPresentIdKHR::safe_VkPresentIdKHR(const safe_VkPresentIdKHR& copy_src) {
+    sType = copy_src.sType;
+    swapchainCount = copy_src.swapchainCount;
+    pPresentIds = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pPresentIds) {
+        pPresentIds = new uint64_t[copy_src.swapchainCount];
+        memcpy((void*)pPresentIds, (void*)copy_src.pPresentIds, sizeof(uint64_t) * copy_src.swapchainCount);
+    }
+}
+
+safe_VkPresentIdKHR& safe_VkPresentIdKHR::operator=(const safe_VkPresentIdKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pPresentIds) delete[] pPresentIds;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    swapchainCount = copy_src.swapchainCount;
+    pPresentIds = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pPresentIds) {
+        pPresentIds = new uint64_t[copy_src.swapchainCount];
+        memcpy((void*)pPresentIds, (void*)copy_src.pPresentIds, sizeof(uint64_t) * copy_src.swapchainCount);
+    }
+
+    return *this;
+}
+
+safe_VkPresentIdKHR::~safe_VkPresentIdKHR() {
+    if (pPresentIds) delete[] pPresentIds;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPresentIdKHR::initialize(const VkPresentIdKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pPresentIds) delete[] pPresentIds;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    swapchainCount = in_struct->swapchainCount;
+    pPresentIds = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pPresentIds) {
+        pPresentIds = new uint64_t[in_struct->swapchainCount];
+        memcpy((void*)pPresentIds, (void*)in_struct->pPresentIds, sizeof(uint64_t) * in_struct->swapchainCount);
+    }
+}
+
+void safe_VkPresentIdKHR::initialize(const safe_VkPresentIdKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    swapchainCount = copy_src->swapchainCount;
+    pPresentIds = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pPresentIds) {
+        pPresentIds = new uint64_t[copy_src->swapchainCount];
+        memcpy((void*)pPresentIds, (void*)copy_src->pPresentIds, sizeof(uint64_t) * copy_src->swapchainCount);
+    }
+}
+
+safe_VkPhysicalDevicePresentIdFeaturesKHR::safe_VkPhysicalDevicePresentIdFeaturesKHR(
+    const VkPhysicalDevicePresentIdFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), presentId(in_struct->presentId) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePresentIdFeaturesKHR::safe_VkPhysicalDevicePresentIdFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR), pNext(nullptr), presentId() {}
+
+safe_VkPhysicalDevicePresentIdFeaturesKHR::safe_VkPhysicalDevicePresentIdFeaturesKHR(
+    const safe_VkPhysicalDevicePresentIdFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    presentId = copy_src.presentId;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePresentIdFeaturesKHR& safe_VkPhysicalDevicePresentIdFeaturesKHR::operator=(
+    const safe_VkPhysicalDevicePresentIdFeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    presentId = copy_src.presentId;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePresentIdFeaturesKHR::~safe_VkPhysicalDevicePresentIdFeaturesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDevicePresentIdFeaturesKHR::initialize(const VkPhysicalDevicePresentIdFeaturesKHR* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    presentId = in_struct->presentId;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePresentIdFeaturesKHR::initialize(const safe_VkPhysicalDevicePresentIdFeaturesKHR* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    presentId = copy_src->presentId;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeInfoKHR::safe_VkVideoEncodeInfoKHR(const VkVideoEncodeInfoKHR* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      dstBuffer(in_struct->dstBuffer),
+      dstBufferOffset(in_struct->dstBufferOffset),
+      dstBufferRange(in_struct->dstBufferRange),
+      srcPictureResource(&in_struct->srcPictureResource),
+      pSetupReferenceSlot(nullptr),
+      referenceSlotCount(in_struct->referenceSlotCount),
+      pReferenceSlots(nullptr),
+      precedingExternallyEncodedBytes(in_struct->precedingExternallyEncodedBytes) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pSetupReferenceSlot) pSetupReferenceSlot = new safe_VkVideoReferenceSlotInfoKHR(in_struct->pSetupReferenceSlot);
+    if (referenceSlotCount && in_struct->pReferenceSlots) {
+        pReferenceSlots = new safe_VkVideoReferenceSlotInfoKHR[referenceSlotCount];
+        for (uint32_t i = 0; i < referenceSlotCount; ++i) {
+            pReferenceSlots[i].initialize(&in_struct->pReferenceSlots[i]);
+        }
+    }
+}
+
+safe_VkVideoEncodeInfoKHR::safe_VkVideoEncodeInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR),
+      pNext(nullptr),
+      flags(),
+      dstBuffer(),
+      dstBufferOffset(),
+      dstBufferRange(),
+      pSetupReferenceSlot(nullptr),
+      referenceSlotCount(),
+      pReferenceSlots(nullptr),
+      precedingExternallyEncodedBytes() {}
+
+safe_VkVideoEncodeInfoKHR::safe_VkVideoEncodeInfoKHR(const safe_VkVideoEncodeInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    dstBuffer = copy_src.dstBuffer;
+    dstBufferOffset = copy_src.dstBufferOffset;
+    dstBufferRange = copy_src.dstBufferRange;
+    srcPictureResource.initialize(&copy_src.srcPictureResource);
+    pSetupReferenceSlot = nullptr;
+    referenceSlotCount = copy_src.referenceSlotCount;
+    pReferenceSlots = nullptr;
+    precedingExternallyEncodedBytes = copy_src.precedingExternallyEncodedBytes;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pSetupReferenceSlot) pSetupReferenceSlot = new safe_VkVideoReferenceSlotInfoKHR(*copy_src.pSetupReferenceSlot);
+    if (referenceSlotCount && copy_src.pReferenceSlots) {
+        pReferenceSlots = new safe_VkVideoReferenceSlotInfoKHR[referenceSlotCount];
+        for (uint32_t i = 0; i < referenceSlotCount; ++i) {
+            pReferenceSlots[i].initialize(&copy_src.pReferenceSlots[i]);
+        }
+    }
+}
+
+safe_VkVideoEncodeInfoKHR& safe_VkVideoEncodeInfoKHR::operator=(const safe_VkVideoEncodeInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pSetupReferenceSlot) delete pSetupReferenceSlot;
+    if (pReferenceSlots) delete[] pReferenceSlots;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    dstBuffer = copy_src.dstBuffer;
+    dstBufferOffset = copy_src.dstBufferOffset;
+    dstBufferRange = copy_src.dstBufferRange;
+    srcPictureResource.initialize(&copy_src.srcPictureResource);
+    pSetupReferenceSlot = nullptr;
+    referenceSlotCount = copy_src.referenceSlotCount;
+    pReferenceSlots = nullptr;
+    precedingExternallyEncodedBytes = copy_src.precedingExternallyEncodedBytes;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pSetupReferenceSlot) pSetupReferenceSlot = new safe_VkVideoReferenceSlotInfoKHR(*copy_src.pSetupReferenceSlot);
+    if (referenceSlotCount && copy_src.pReferenceSlots) {
+        pReferenceSlots = new safe_VkVideoReferenceSlotInfoKHR[referenceSlotCount];
+        for (uint32_t i = 0; i < referenceSlotCount; ++i) {
+            pReferenceSlots[i].initialize(&copy_src.pReferenceSlots[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkVideoEncodeInfoKHR::~safe_VkVideoEncodeInfoKHR() {
+    if (pSetupReferenceSlot) delete pSetupReferenceSlot;
+    if (pReferenceSlots) delete[] pReferenceSlots;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoEncodeInfoKHR::initialize(const VkVideoEncodeInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pSetupReferenceSlot) delete pSetupReferenceSlot;
+    if (pReferenceSlots) delete[] pReferenceSlots;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    dstBuffer = in_struct->dstBuffer;
+    dstBufferOffset = in_struct->dstBufferOffset;
+    dstBufferRange = in_struct->dstBufferRange;
+    srcPictureResource.initialize(&in_struct->srcPictureResource);
+    pSetupReferenceSlot = nullptr;
+    referenceSlotCount = in_struct->referenceSlotCount;
+    pReferenceSlots = nullptr;
+    precedingExternallyEncodedBytes = in_struct->precedingExternallyEncodedBytes;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (in_struct->pSetupReferenceSlot) pSetupReferenceSlot = new safe_VkVideoReferenceSlotInfoKHR(in_struct->pSetupReferenceSlot);
+    if (referenceSlotCount && in_struct->pReferenceSlots) {
+        pReferenceSlots = new safe_VkVideoReferenceSlotInfoKHR[referenceSlotCount];
+        for (uint32_t i = 0; i < referenceSlotCount; ++i) {
+            pReferenceSlots[i].initialize(&in_struct->pReferenceSlots[i]);
+        }
+    }
+}
+
+void safe_VkVideoEncodeInfoKHR::initialize(const safe_VkVideoEncodeInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    dstBuffer = copy_src->dstBuffer;
+    dstBufferOffset = copy_src->dstBufferOffset;
+    dstBufferRange = copy_src->dstBufferRange;
+    srcPictureResource.initialize(&copy_src->srcPictureResource);
+    pSetupReferenceSlot = nullptr;
+    referenceSlotCount = copy_src->referenceSlotCount;
+    pReferenceSlots = nullptr;
+    precedingExternallyEncodedBytes = copy_src->precedingExternallyEncodedBytes;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (copy_src->pSetupReferenceSlot) pSetupReferenceSlot = new safe_VkVideoReferenceSlotInfoKHR(*copy_src->pSetupReferenceSlot);
+    if (referenceSlotCount && copy_src->pReferenceSlots) {
+        pReferenceSlots = new safe_VkVideoReferenceSlotInfoKHR[referenceSlotCount];
+        for (uint32_t i = 0; i < referenceSlotCount; ++i) {
+            pReferenceSlots[i].initialize(&copy_src->pReferenceSlots[i]);
+        }
+    }
+}
+
+safe_VkVideoEncodeCapabilitiesKHR::safe_VkVideoEncodeCapabilitiesKHR(const VkVideoEncodeCapabilitiesKHR* in_struct,
+                                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      rateControlModes(in_struct->rateControlModes),
+      maxRateControlLayers(in_struct->maxRateControlLayers),
+      maxBitrate(in_struct->maxBitrate),
+      maxQualityLevels(in_struct->maxQualityLevels),
+      encodeInputPictureGranularity(in_struct->encodeInputPictureGranularity),
+      supportedEncodeFeedbackFlags(in_struct->supportedEncodeFeedbackFlags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeCapabilitiesKHR::safe_VkVideoEncodeCapabilitiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR),
+      pNext(nullptr),
+      flags(),
+      rateControlModes(),
+      maxRateControlLayers(),
+      maxBitrate(),
+      maxQualityLevels(),
+      encodeInputPictureGranularity(),
+      supportedEncodeFeedbackFlags() {}
+
+safe_VkVideoEncodeCapabilitiesKHR::safe_VkVideoEncodeCapabilitiesKHR(const safe_VkVideoEncodeCapabilitiesKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    rateControlModes = copy_src.rateControlModes;
+    maxRateControlLayers = copy_src.maxRateControlLayers;
+    maxBitrate = copy_src.maxBitrate;
+    maxQualityLevels = copy_src.maxQualityLevels;
+    encodeInputPictureGranularity = copy_src.encodeInputPictureGranularity;
+    supportedEncodeFeedbackFlags = copy_src.supportedEncodeFeedbackFlags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeCapabilitiesKHR& safe_VkVideoEncodeCapabilitiesKHR::operator=(const safe_VkVideoEncodeCapabilitiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    rateControlModes = copy_src.rateControlModes;
+    maxRateControlLayers = copy_src.maxRateControlLayers;
+    maxBitrate = copy_src.maxBitrate;
+    maxQualityLevels = copy_src.maxQualityLevels;
+    encodeInputPictureGranularity = copy_src.encodeInputPictureGranularity;
+    supportedEncodeFeedbackFlags = copy_src.supportedEncodeFeedbackFlags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeCapabilitiesKHR::~safe_VkVideoEncodeCapabilitiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeCapabilitiesKHR::initialize(const VkVideoEncodeCapabilitiesKHR* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    rateControlModes = in_struct->rateControlModes;
+    maxRateControlLayers = in_struct->maxRateControlLayers;
+    maxBitrate = in_struct->maxBitrate;
+    maxQualityLevels = in_struct->maxQualityLevels;
+    encodeInputPictureGranularity = in_struct->encodeInputPictureGranularity;
+    supportedEncodeFeedbackFlags = in_struct->supportedEncodeFeedbackFlags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeCapabilitiesKHR::initialize(const safe_VkVideoEncodeCapabilitiesKHR* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    rateControlModes = copy_src->rateControlModes;
+    maxRateControlLayers = copy_src->maxRateControlLayers;
+    maxBitrate = copy_src->maxBitrate;
+    maxQualityLevels = copy_src->maxQualityLevels;
+    encodeInputPictureGranularity = copy_src->encodeInputPictureGranularity;
+    supportedEncodeFeedbackFlags = copy_src->supportedEncodeFeedbackFlags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
+    const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), encodeFeedbackFlags(in_struct->encodeFeedbackFlags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR), pNext(nullptr), encodeFeedbackFlags() {}
+
+safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
+    const safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    encodeFeedbackFlags = copy_src.encodeFeedbackFlags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::operator=(
+    const safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    encodeFeedbackFlags = copy_src.encodeFeedbackFlags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::~safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::initialize(const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    encodeFeedbackFlags = in_struct->encodeFeedbackFlags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR::initialize(const safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    encodeFeedbackFlags = copy_src->encodeFeedbackFlags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeUsageInfoKHR::safe_VkVideoEncodeUsageInfoKHR(const VkVideoEncodeUsageInfoKHR* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      videoUsageHints(in_struct->videoUsageHints),
+      videoContentHints(in_struct->videoContentHints),
+      tuningMode(in_struct->tuningMode) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeUsageInfoKHR::safe_VkVideoEncodeUsageInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR), pNext(nullptr), videoUsageHints(), videoContentHints(), tuningMode() {}
+
+safe_VkVideoEncodeUsageInfoKHR::safe_VkVideoEncodeUsageInfoKHR(const safe_VkVideoEncodeUsageInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    videoUsageHints = copy_src.videoUsageHints;
+    videoContentHints = copy_src.videoContentHints;
+    tuningMode = copy_src.tuningMode;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeUsageInfoKHR& safe_VkVideoEncodeUsageInfoKHR::operator=(const safe_VkVideoEncodeUsageInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    videoUsageHints = copy_src.videoUsageHints;
+    videoContentHints = copy_src.videoContentHints;
+    tuningMode = copy_src.tuningMode;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeUsageInfoKHR::~safe_VkVideoEncodeUsageInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeUsageInfoKHR::initialize(const VkVideoEncodeUsageInfoKHR* in_struct,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    videoUsageHints = in_struct->videoUsageHints;
+    videoContentHints = in_struct->videoContentHints;
+    tuningMode = in_struct->tuningMode;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeUsageInfoKHR::initialize(const safe_VkVideoEncodeUsageInfoKHR* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    videoUsageHints = copy_src->videoUsageHints;
+    videoContentHints = copy_src->videoContentHints;
+    tuningMode = copy_src->tuningMode;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeRateControlLayerInfoKHR::safe_VkVideoEncodeRateControlLayerInfoKHR(
+    const VkVideoEncodeRateControlLayerInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      averageBitrate(in_struct->averageBitrate),
+      maxBitrate(in_struct->maxBitrate),
+      frameRateNumerator(in_struct->frameRateNumerator),
+      frameRateDenominator(in_struct->frameRateDenominator) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeRateControlLayerInfoKHR::safe_VkVideoEncodeRateControlLayerInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR),
+      pNext(nullptr),
+      averageBitrate(),
+      maxBitrate(),
+      frameRateNumerator(),
+      frameRateDenominator() {}
+
+safe_VkVideoEncodeRateControlLayerInfoKHR::safe_VkVideoEncodeRateControlLayerInfoKHR(
+    const safe_VkVideoEncodeRateControlLayerInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    averageBitrate = copy_src.averageBitrate;
+    maxBitrate = copy_src.maxBitrate;
+    frameRateNumerator = copy_src.frameRateNumerator;
+    frameRateDenominator = copy_src.frameRateDenominator;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeRateControlLayerInfoKHR& safe_VkVideoEncodeRateControlLayerInfoKHR::operator=(
+    const safe_VkVideoEncodeRateControlLayerInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    averageBitrate = copy_src.averageBitrate;
+    maxBitrate = copy_src.maxBitrate;
+    frameRateNumerator = copy_src.frameRateNumerator;
+    frameRateDenominator = copy_src.frameRateDenominator;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeRateControlLayerInfoKHR::~safe_VkVideoEncodeRateControlLayerInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeRateControlLayerInfoKHR::initialize(const VkVideoEncodeRateControlLayerInfoKHR* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    averageBitrate = in_struct->averageBitrate;
+    maxBitrate = in_struct->maxBitrate;
+    frameRateNumerator = in_struct->frameRateNumerator;
+    frameRateDenominator = in_struct->frameRateDenominator;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeRateControlLayerInfoKHR::initialize(const safe_VkVideoEncodeRateControlLayerInfoKHR* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    averageBitrate = copy_src->averageBitrate;
+    maxBitrate = copy_src->maxBitrate;
+    frameRateNumerator = copy_src->frameRateNumerator;
+    frameRateDenominator = copy_src->frameRateDenominator;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeRateControlInfoKHR::safe_VkVideoEncodeRateControlInfoKHR(const VkVideoEncodeRateControlInfoKHR* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      rateControlMode(in_struct->rateControlMode),
+      layerCount(in_struct->layerCount),
+      pLayers(nullptr),
+      virtualBufferSizeInMs(in_struct->virtualBufferSizeInMs),
+      initialVirtualBufferSizeInMs(in_struct->initialVirtualBufferSizeInMs) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (layerCount && in_struct->pLayers) {
+        pLayers = new safe_VkVideoEncodeRateControlLayerInfoKHR[layerCount];
+        for (uint32_t i = 0; i < layerCount; ++i) {
+            pLayers[i].initialize(&in_struct->pLayers[i]);
+        }
+    }
+}
+
+safe_VkVideoEncodeRateControlInfoKHR::safe_VkVideoEncodeRateControlInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR),
+      pNext(nullptr),
+      flags(),
+      rateControlMode(),
+      layerCount(),
+      pLayers(nullptr),
+      virtualBufferSizeInMs(),
+      initialVirtualBufferSizeInMs() {}
+
+safe_VkVideoEncodeRateControlInfoKHR::safe_VkVideoEncodeRateControlInfoKHR(const safe_VkVideoEncodeRateControlInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    rateControlMode = copy_src.rateControlMode;
+    layerCount = copy_src.layerCount;
+    pLayers = nullptr;
+    virtualBufferSizeInMs = copy_src.virtualBufferSizeInMs;
+    initialVirtualBufferSizeInMs = copy_src.initialVirtualBufferSizeInMs;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (layerCount && copy_src.pLayers) {
+        pLayers = new safe_VkVideoEncodeRateControlLayerInfoKHR[layerCount];
+        for (uint32_t i = 0; i < layerCount; ++i) {
+            pLayers[i].initialize(&copy_src.pLayers[i]);
+        }
+    }
+}
+
+safe_VkVideoEncodeRateControlInfoKHR& safe_VkVideoEncodeRateControlInfoKHR::operator=(
+    const safe_VkVideoEncodeRateControlInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pLayers) delete[] pLayers;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    rateControlMode = copy_src.rateControlMode;
+    layerCount = copy_src.layerCount;
+    pLayers = nullptr;
+    virtualBufferSizeInMs = copy_src.virtualBufferSizeInMs;
+    initialVirtualBufferSizeInMs = copy_src.initialVirtualBufferSizeInMs;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (layerCount && copy_src.pLayers) {
+        pLayers = new safe_VkVideoEncodeRateControlLayerInfoKHR[layerCount];
+        for (uint32_t i = 0; i < layerCount; ++i) {
+            pLayers[i].initialize(&copy_src.pLayers[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkVideoEncodeRateControlInfoKHR::~safe_VkVideoEncodeRateControlInfoKHR() {
+    if (pLayers) delete[] pLayers;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoEncodeRateControlInfoKHR::initialize(const VkVideoEncodeRateControlInfoKHR* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pLayers) delete[] pLayers;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    rateControlMode = in_struct->rateControlMode;
+    layerCount = in_struct->layerCount;
+    pLayers = nullptr;
+    virtualBufferSizeInMs = in_struct->virtualBufferSizeInMs;
+    initialVirtualBufferSizeInMs = in_struct->initialVirtualBufferSizeInMs;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (layerCount && in_struct->pLayers) {
+        pLayers = new safe_VkVideoEncodeRateControlLayerInfoKHR[layerCount];
+        for (uint32_t i = 0; i < layerCount; ++i) {
+            pLayers[i].initialize(&in_struct->pLayers[i]);
+        }
+    }
+}
+
+void safe_VkVideoEncodeRateControlInfoKHR::initialize(const safe_VkVideoEncodeRateControlInfoKHR* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    rateControlMode = copy_src->rateControlMode;
+    layerCount = copy_src->layerCount;
+    pLayers = nullptr;
+    virtualBufferSizeInMs = copy_src->virtualBufferSizeInMs;
+    initialVirtualBufferSizeInMs = copy_src->initialVirtualBufferSizeInMs;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (layerCount && copy_src->pLayers) {
+        pLayers = new safe_VkVideoEncodeRateControlLayerInfoKHR[layerCount];
+        for (uint32_t i = 0; i < layerCount; ++i) {
+            pLayers[i].initialize(&copy_src->pLayers[i]);
+        }
+    }
+}
+
+safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR::safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR(
+    const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), pVideoProfile(nullptr), qualityLevel(in_struct->qualityLevel) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pVideoProfile) pVideoProfile = new safe_VkVideoProfileInfoKHR(in_struct->pVideoProfile);
+}
+
+safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR::safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR),
+      pNext(nullptr),
+      pVideoProfile(nullptr),
+      qualityLevel() {}
+
+safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR::safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR(
+    const safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pVideoProfile = nullptr;
+    qualityLevel = copy_src.qualityLevel;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pVideoProfile) pVideoProfile = new safe_VkVideoProfileInfoKHR(*copy_src.pVideoProfile);
+}
+
+safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR& safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR::operator=(
+    const safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pVideoProfile) delete pVideoProfile;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pVideoProfile = nullptr;
+    qualityLevel = copy_src.qualityLevel;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pVideoProfile) pVideoProfile = new safe_VkVideoProfileInfoKHR(*copy_src.pVideoProfile);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR::~safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR() {
+    if (pVideoProfile) delete pVideoProfile;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR::initialize(
+    const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pVideoProfile) delete pVideoProfile;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pVideoProfile = nullptr;
+    qualityLevel = in_struct->qualityLevel;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (in_struct->pVideoProfile) pVideoProfile = new safe_VkVideoProfileInfoKHR(in_struct->pVideoProfile);
+}
+
+void safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR::initialize(
+    const safe_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pVideoProfile = nullptr;
+    qualityLevel = copy_src->qualityLevel;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (copy_src->pVideoProfile) pVideoProfile = new safe_VkVideoProfileInfoKHR(*copy_src->pVideoProfile);
+}
+
+safe_VkVideoEncodeQualityLevelPropertiesKHR::safe_VkVideoEncodeQualityLevelPropertiesKHR(
+    const VkVideoEncodeQualityLevelPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      preferredRateControlMode(in_struct->preferredRateControlMode),
+      preferredRateControlLayerCount(in_struct->preferredRateControlLayerCount) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeQualityLevelPropertiesKHR::safe_VkVideoEncodeQualityLevelPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR),
+      pNext(nullptr),
+      preferredRateControlMode(),
+      preferredRateControlLayerCount() {}
+
+safe_VkVideoEncodeQualityLevelPropertiesKHR::safe_VkVideoEncodeQualityLevelPropertiesKHR(
+    const safe_VkVideoEncodeQualityLevelPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    preferredRateControlMode = copy_src.preferredRateControlMode;
+    preferredRateControlLayerCount = copy_src.preferredRateControlLayerCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeQualityLevelPropertiesKHR& safe_VkVideoEncodeQualityLevelPropertiesKHR::operator=(
+    const safe_VkVideoEncodeQualityLevelPropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    preferredRateControlMode = copy_src.preferredRateControlMode;
+    preferredRateControlLayerCount = copy_src.preferredRateControlLayerCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeQualityLevelPropertiesKHR::~safe_VkVideoEncodeQualityLevelPropertiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeQualityLevelPropertiesKHR::initialize(const VkVideoEncodeQualityLevelPropertiesKHR* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    preferredRateControlMode = in_struct->preferredRateControlMode;
+    preferredRateControlLayerCount = in_struct->preferredRateControlLayerCount;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeQualityLevelPropertiesKHR::initialize(const safe_VkVideoEncodeQualityLevelPropertiesKHR* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    preferredRateControlMode = copy_src->preferredRateControlMode;
+    preferredRateControlLayerCount = copy_src->preferredRateControlLayerCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeQualityLevelInfoKHR::safe_VkVideoEncodeQualityLevelInfoKHR(const VkVideoEncodeQualityLevelInfoKHR* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType), qualityLevel(in_struct->qualityLevel) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeQualityLevelInfoKHR::safe_VkVideoEncodeQualityLevelInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR), pNext(nullptr), qualityLevel() {}
+
+safe_VkVideoEncodeQualityLevelInfoKHR::safe_VkVideoEncodeQualityLevelInfoKHR(
+    const safe_VkVideoEncodeQualityLevelInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    qualityLevel = copy_src.qualityLevel;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeQualityLevelInfoKHR& safe_VkVideoEncodeQualityLevelInfoKHR::operator=(
+    const safe_VkVideoEncodeQualityLevelInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    qualityLevel = copy_src.qualityLevel;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeQualityLevelInfoKHR::~safe_VkVideoEncodeQualityLevelInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeQualityLevelInfoKHR::initialize(const VkVideoEncodeQualityLevelInfoKHR* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    qualityLevel = in_struct->qualityLevel;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeQualityLevelInfoKHR::initialize(const safe_VkVideoEncodeQualityLevelInfoKHR* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    qualityLevel = copy_src->qualityLevel;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeSessionParametersGetInfoKHR::safe_VkVideoEncodeSessionParametersGetInfoKHR(
+    const VkVideoEncodeSessionParametersGetInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), videoSessionParameters(in_struct->videoSessionParameters) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeSessionParametersGetInfoKHR::safe_VkVideoEncodeSessionParametersGetInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR), pNext(nullptr), videoSessionParameters() {}
+
+safe_VkVideoEncodeSessionParametersGetInfoKHR::safe_VkVideoEncodeSessionParametersGetInfoKHR(
+    const safe_VkVideoEncodeSessionParametersGetInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    videoSessionParameters = copy_src.videoSessionParameters;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeSessionParametersGetInfoKHR& safe_VkVideoEncodeSessionParametersGetInfoKHR::operator=(
+    const safe_VkVideoEncodeSessionParametersGetInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    videoSessionParameters = copy_src.videoSessionParameters;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeSessionParametersGetInfoKHR::~safe_VkVideoEncodeSessionParametersGetInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeSessionParametersGetInfoKHR::initialize(const VkVideoEncodeSessionParametersGetInfoKHR* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    videoSessionParameters = in_struct->videoSessionParameters;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeSessionParametersGetInfoKHR::initialize(const safe_VkVideoEncodeSessionParametersGetInfoKHR* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    videoSessionParameters = copy_src->videoSessionParameters;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeSessionParametersFeedbackInfoKHR::safe_VkVideoEncodeSessionParametersFeedbackInfoKHR(
+    const VkVideoEncodeSessionParametersFeedbackInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), hasOverrides(in_struct->hasOverrides) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeSessionParametersFeedbackInfoKHR::safe_VkVideoEncodeSessionParametersFeedbackInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR), pNext(nullptr), hasOverrides() {}
+
+safe_VkVideoEncodeSessionParametersFeedbackInfoKHR::safe_VkVideoEncodeSessionParametersFeedbackInfoKHR(
+    const safe_VkVideoEncodeSessionParametersFeedbackInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    hasOverrides = copy_src.hasOverrides;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeSessionParametersFeedbackInfoKHR& safe_VkVideoEncodeSessionParametersFeedbackInfoKHR::operator=(
+    const safe_VkVideoEncodeSessionParametersFeedbackInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    hasOverrides = copy_src.hasOverrides;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeSessionParametersFeedbackInfoKHR::~safe_VkVideoEncodeSessionParametersFeedbackInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeSessionParametersFeedbackInfoKHR::initialize(const VkVideoEncodeSessionParametersFeedbackInfoKHR* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    hasOverrides = in_struct->hasOverrides;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeSessionParametersFeedbackInfoKHR::initialize(
+    const safe_VkVideoEncodeSessionParametersFeedbackInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    hasOverrides = copy_src->hasOverrides;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
+    const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), fragmentShaderBarycentric(in_struct->fragmentShaderBarycentric) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR),
+      pNext(nullptr),
+      fragmentShaderBarycentric() {}
+
+safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
+    const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    fragmentShaderBarycentric = copy_src.fragmentShaderBarycentric;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    fragmentShaderBarycentric = copy_src.fragmentShaderBarycentric;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::~safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::initialize(
+    const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    fragmentShaderBarycentric = in_struct->fragmentShaderBarycentric;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::initialize(
+    const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    fragmentShaderBarycentric = copy_src->fragmentShaderBarycentric;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
+    const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      triStripVertexOrderIndependentOfProvokingVertex(in_struct->triStripVertexOrderIndependentOfProvokingVertex) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR),
+      pNext(nullptr),
+      triStripVertexOrderIndependentOfProvokingVertex() {}
+
+safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
+    const safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    triStripVertexOrderIndependentOfProvokingVertex = copy_src.triStripVertexOrderIndependentOfProvokingVertex;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::operator=(
+    const safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    triStripVertexOrderIndependentOfProvokingVertex = copy_src.triStripVertexOrderIndependentOfProvokingVertex;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::~safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::initialize(
+    const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    triStripVertexOrderIndependentOfProvokingVertex = in_struct->triStripVertexOrderIndependentOfProvokingVertex;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::initialize(
+    const safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    triStripVertexOrderIndependentOfProvokingVertex = copy_src->triStripVertexOrderIndependentOfProvokingVertex;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
+    const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), shaderSubgroupUniformControlFlow(in_struct->shaderSubgroupUniformControlFlow) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR),
+      pNext(nullptr),
+      shaderSubgroupUniformControlFlow() {}
+
+safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
+    const safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    shaderSubgroupUniformControlFlow = copy_src.shaderSubgroupUniformControlFlow;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR&
+safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderSubgroupUniformControlFlow = copy_src.shaderSubgroupUniformControlFlow;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::
+    ~safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::initialize(
+    const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderSubgroupUniformControlFlow = in_struct->shaderSubgroupUniformControlFlow;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::initialize(
+    const safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderSubgroupUniformControlFlow = copy_src->shaderSubgroupUniformControlFlow;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
+    const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      workgroupMemoryExplicitLayout(in_struct->workgroupMemoryExplicitLayout),
+      workgroupMemoryExplicitLayoutScalarBlockLayout(in_struct->workgroupMemoryExplicitLayoutScalarBlockLayout),
+      workgroupMemoryExplicitLayout8BitAccess(in_struct->workgroupMemoryExplicitLayout8BitAccess),
+      workgroupMemoryExplicitLayout16BitAccess(in_struct->workgroupMemoryExplicitLayout16BitAccess) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR),
+      pNext(nullptr),
+      workgroupMemoryExplicitLayout(),
+      workgroupMemoryExplicitLayoutScalarBlockLayout(),
+      workgroupMemoryExplicitLayout8BitAccess(),
+      workgroupMemoryExplicitLayout16BitAccess() {}
+
+safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
+    const safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    workgroupMemoryExplicitLayout = copy_src.workgroupMemoryExplicitLayout;
+    workgroupMemoryExplicitLayoutScalarBlockLayout = copy_src.workgroupMemoryExplicitLayoutScalarBlockLayout;
+    workgroupMemoryExplicitLayout8BitAccess = copy_src.workgroupMemoryExplicitLayout8BitAccess;
+    workgroupMemoryExplicitLayout16BitAccess = copy_src.workgroupMemoryExplicitLayout16BitAccess;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR&
+safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    workgroupMemoryExplicitLayout = copy_src.workgroupMemoryExplicitLayout;
+    workgroupMemoryExplicitLayoutScalarBlockLayout = copy_src.workgroupMemoryExplicitLayoutScalarBlockLayout;
+    workgroupMemoryExplicitLayout8BitAccess = copy_src.workgroupMemoryExplicitLayout8BitAccess;
+    workgroupMemoryExplicitLayout16BitAccess = copy_src.workgroupMemoryExplicitLayout16BitAccess;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::~safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::initialize(
+    const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    workgroupMemoryExplicitLayout = in_struct->workgroupMemoryExplicitLayout;
+    workgroupMemoryExplicitLayoutScalarBlockLayout = in_struct->workgroupMemoryExplicitLayoutScalarBlockLayout;
+    workgroupMemoryExplicitLayout8BitAccess = in_struct->workgroupMemoryExplicitLayout8BitAccess;
+    workgroupMemoryExplicitLayout16BitAccess = in_struct->workgroupMemoryExplicitLayout16BitAccess;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::initialize(
+    const safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    workgroupMemoryExplicitLayout = copy_src->workgroupMemoryExplicitLayout;
+    workgroupMemoryExplicitLayoutScalarBlockLayout = copy_src->workgroupMemoryExplicitLayoutScalarBlockLayout;
+    workgroupMemoryExplicitLayout8BitAccess = copy_src->workgroupMemoryExplicitLayout8BitAccess;
+    workgroupMemoryExplicitLayout16BitAccess = copy_src->workgroupMemoryExplicitLayout16BitAccess;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
+    const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      rayTracingMaintenance1(in_struct->rayTracingMaintenance1),
+      rayTracingPipelineTraceRaysIndirect2(in_struct->rayTracingPipelineTraceRaysIndirect2) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR),
+      pNext(nullptr),
+      rayTracingMaintenance1(),
+      rayTracingPipelineTraceRaysIndirect2() {}
+
+safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
+    const safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    rayTracingMaintenance1 = copy_src.rayTracingMaintenance1;
+    rayTracingPipelineTraceRaysIndirect2 = copy_src.rayTracingPipelineTraceRaysIndirect2;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    rayTracingMaintenance1 = copy_src.rayTracingMaintenance1;
+    rayTracingPipelineTraceRaysIndirect2 = copy_src.rayTracingPipelineTraceRaysIndirect2;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::~safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::initialize(
+    const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    rayTracingMaintenance1 = in_struct->rayTracingMaintenance1;
+    rayTracingPipelineTraceRaysIndirect2 = in_struct->rayTracingPipelineTraceRaysIndirect2;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::initialize(
+    const safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    rayTracingMaintenance1 = copy_src->rayTracingMaintenance1;
+    rayTracingPipelineTraceRaysIndirect2 = copy_src->rayTracingPipelineTraceRaysIndirect2;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR(
+    const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      shaderSubgroupRotate(in_struct->shaderSubgroupRotate),
+      shaderSubgroupRotateClustered(in_struct->shaderSubgroupRotateClustered) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR),
+      pNext(nullptr),
+      shaderSubgroupRotate(),
+      shaderSubgroupRotateClustered() {}
+
+safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR(
+    const safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    shaderSubgroupRotate = copy_src.shaderSubgroupRotate;
+    shaderSubgroupRotateClustered = copy_src.shaderSubgroupRotateClustered;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR& safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderSubgroupRotate = copy_src.shaderSubgroupRotate;
+    shaderSubgroupRotateClustered = copy_src.shaderSubgroupRotateClustered;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::~safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::initialize(
+    const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderSubgroupRotate = in_struct->shaderSubgroupRotate;
+    shaderSubgroupRotateClustered = in_struct->shaderSubgroupRotateClustered;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::initialize(
+    const safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderSubgroupRotate = copy_src->shaderSubgroupRotate;
+    shaderSubgroupRotateClustered = copy_src->shaderSubgroupRotateClustered;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(
+    const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), shaderMaximalReconvergence(in_struct->shaderMaximalReconvergence) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR),
+      pNext(nullptr),
+      shaderMaximalReconvergence() {}
+
+safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(
+    const safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    shaderMaximalReconvergence = copy_src.shaderMaximalReconvergence;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderMaximalReconvergence = copy_src.shaderMaximalReconvergence;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::~safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::initialize(
+    const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderMaximalReconvergence = in_struct->shaderMaximalReconvergence;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::initialize(
+    const safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderMaximalReconvergence = copy_src->shaderMaximalReconvergence;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceMaintenance5FeaturesKHR::safe_VkPhysicalDeviceMaintenance5FeaturesKHR(
+    const VkPhysicalDeviceMaintenance5FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), maintenance5(in_struct->maintenance5) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMaintenance5FeaturesKHR::safe_VkPhysicalDeviceMaintenance5FeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR), pNext(nullptr), maintenance5() {}
+
+safe_VkPhysicalDeviceMaintenance5FeaturesKHR::safe_VkPhysicalDeviceMaintenance5FeaturesKHR(
+    const safe_VkPhysicalDeviceMaintenance5FeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    maintenance5 = copy_src.maintenance5;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMaintenance5FeaturesKHR& safe_VkPhysicalDeviceMaintenance5FeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceMaintenance5FeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maintenance5 = copy_src.maintenance5;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMaintenance5FeaturesKHR::~safe_VkPhysicalDeviceMaintenance5FeaturesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceMaintenance5FeaturesKHR::initialize(const VkPhysicalDeviceMaintenance5FeaturesKHR* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maintenance5 = in_struct->maintenance5;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMaintenance5FeaturesKHR::initialize(const safe_VkPhysicalDeviceMaintenance5FeaturesKHR* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maintenance5 = copy_src->maintenance5;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceMaintenance5PropertiesKHR::safe_VkPhysicalDeviceMaintenance5PropertiesKHR(
+    const VkPhysicalDeviceMaintenance5PropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      earlyFragmentMultisampleCoverageAfterSampleCounting(in_struct->earlyFragmentMultisampleCoverageAfterSampleCounting),
+      earlyFragmentSampleMaskTestBeforeSampleCounting(in_struct->earlyFragmentSampleMaskTestBeforeSampleCounting),
+      depthStencilSwizzleOneSupport(in_struct->depthStencilSwizzleOneSupport),
+      polygonModePointSize(in_struct->polygonModePointSize),
+      nonStrictSinglePixelWideLinesUseParallelogram(in_struct->nonStrictSinglePixelWideLinesUseParallelogram),
+      nonStrictWideLinesUseParallelogram(in_struct->nonStrictWideLinesUseParallelogram) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMaintenance5PropertiesKHR::safe_VkPhysicalDeviceMaintenance5PropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR),
+      pNext(nullptr),
+      earlyFragmentMultisampleCoverageAfterSampleCounting(),
+      earlyFragmentSampleMaskTestBeforeSampleCounting(),
+      depthStencilSwizzleOneSupport(),
+      polygonModePointSize(),
+      nonStrictSinglePixelWideLinesUseParallelogram(),
+      nonStrictWideLinesUseParallelogram() {}
+
+safe_VkPhysicalDeviceMaintenance5PropertiesKHR::safe_VkPhysicalDeviceMaintenance5PropertiesKHR(
+    const safe_VkPhysicalDeviceMaintenance5PropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    earlyFragmentMultisampleCoverageAfterSampleCounting = copy_src.earlyFragmentMultisampleCoverageAfterSampleCounting;
+    earlyFragmentSampleMaskTestBeforeSampleCounting = copy_src.earlyFragmentSampleMaskTestBeforeSampleCounting;
+    depthStencilSwizzleOneSupport = copy_src.depthStencilSwizzleOneSupport;
+    polygonModePointSize = copy_src.polygonModePointSize;
+    nonStrictSinglePixelWideLinesUseParallelogram = copy_src.nonStrictSinglePixelWideLinesUseParallelogram;
+    nonStrictWideLinesUseParallelogram = copy_src.nonStrictWideLinesUseParallelogram;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMaintenance5PropertiesKHR& safe_VkPhysicalDeviceMaintenance5PropertiesKHR::operator=(
+    const safe_VkPhysicalDeviceMaintenance5PropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    earlyFragmentMultisampleCoverageAfterSampleCounting = copy_src.earlyFragmentMultisampleCoverageAfterSampleCounting;
+    earlyFragmentSampleMaskTestBeforeSampleCounting = copy_src.earlyFragmentSampleMaskTestBeforeSampleCounting;
+    depthStencilSwizzleOneSupport = copy_src.depthStencilSwizzleOneSupport;
+    polygonModePointSize = copy_src.polygonModePointSize;
+    nonStrictSinglePixelWideLinesUseParallelogram = copy_src.nonStrictSinglePixelWideLinesUseParallelogram;
+    nonStrictWideLinesUseParallelogram = copy_src.nonStrictWideLinesUseParallelogram;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMaintenance5PropertiesKHR::~safe_VkPhysicalDeviceMaintenance5PropertiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceMaintenance5PropertiesKHR::initialize(const VkPhysicalDeviceMaintenance5PropertiesKHR* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    earlyFragmentMultisampleCoverageAfterSampleCounting = in_struct->earlyFragmentMultisampleCoverageAfterSampleCounting;
+    earlyFragmentSampleMaskTestBeforeSampleCounting = in_struct->earlyFragmentSampleMaskTestBeforeSampleCounting;
+    depthStencilSwizzleOneSupport = in_struct->depthStencilSwizzleOneSupport;
+    polygonModePointSize = in_struct->polygonModePointSize;
+    nonStrictSinglePixelWideLinesUseParallelogram = in_struct->nonStrictSinglePixelWideLinesUseParallelogram;
+    nonStrictWideLinesUseParallelogram = in_struct->nonStrictWideLinesUseParallelogram;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMaintenance5PropertiesKHR::initialize(const safe_VkPhysicalDeviceMaintenance5PropertiesKHR* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    earlyFragmentMultisampleCoverageAfterSampleCounting = copy_src->earlyFragmentMultisampleCoverageAfterSampleCounting;
+    earlyFragmentSampleMaskTestBeforeSampleCounting = copy_src->earlyFragmentSampleMaskTestBeforeSampleCounting;
+    depthStencilSwizzleOneSupport = copy_src->depthStencilSwizzleOneSupport;
+    polygonModePointSize = copy_src->polygonModePointSize;
+    nonStrictSinglePixelWideLinesUseParallelogram = copy_src->nonStrictSinglePixelWideLinesUseParallelogram;
+    nonStrictWideLinesUseParallelogram = copy_src->nonStrictWideLinesUseParallelogram;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkRenderingAreaInfoKHR::safe_VkRenderingAreaInfoKHR(const VkRenderingAreaInfoKHR* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      viewMask(in_struct->viewMask),
+      colorAttachmentCount(in_struct->colorAttachmentCount),
+      pColorAttachmentFormats(nullptr),
+      depthAttachmentFormat(in_struct->depthAttachmentFormat),
+      stencilAttachmentFormat(in_struct->stencilAttachmentFormat) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pColorAttachmentFormats) {
+        pColorAttachmentFormats = new VkFormat[in_struct->colorAttachmentCount];
+        memcpy((void*)pColorAttachmentFormats, (void*)in_struct->pColorAttachmentFormats,
+               sizeof(VkFormat) * in_struct->colorAttachmentCount);
+    }
+}
+
+safe_VkRenderingAreaInfoKHR::safe_VkRenderingAreaInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR),
+      pNext(nullptr),
+      viewMask(),
+      colorAttachmentCount(),
+      pColorAttachmentFormats(nullptr),
+      depthAttachmentFormat(),
+      stencilAttachmentFormat() {}
+
+safe_VkRenderingAreaInfoKHR::safe_VkRenderingAreaInfoKHR(const safe_VkRenderingAreaInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    viewMask = copy_src.viewMask;
+    colorAttachmentCount = copy_src.colorAttachmentCount;
+    pColorAttachmentFormats = nullptr;
+    depthAttachmentFormat = copy_src.depthAttachmentFormat;
+    stencilAttachmentFormat = copy_src.stencilAttachmentFormat;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pColorAttachmentFormats) {
+        pColorAttachmentFormats = new VkFormat[copy_src.colorAttachmentCount];
+        memcpy((void*)pColorAttachmentFormats, (void*)copy_src.pColorAttachmentFormats,
+               sizeof(VkFormat) * copy_src.colorAttachmentCount);
+    }
+}
+
+safe_VkRenderingAreaInfoKHR& safe_VkRenderingAreaInfoKHR::operator=(const safe_VkRenderingAreaInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pColorAttachmentFormats) delete[] pColorAttachmentFormats;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    viewMask = copy_src.viewMask;
+    colorAttachmentCount = copy_src.colorAttachmentCount;
+    pColorAttachmentFormats = nullptr;
+    depthAttachmentFormat = copy_src.depthAttachmentFormat;
+    stencilAttachmentFormat = copy_src.stencilAttachmentFormat;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pColorAttachmentFormats) {
+        pColorAttachmentFormats = new VkFormat[copy_src.colorAttachmentCount];
+        memcpy((void*)pColorAttachmentFormats, (void*)copy_src.pColorAttachmentFormats,
+               sizeof(VkFormat) * copy_src.colorAttachmentCount);
+    }
+
+    return *this;
+}
+
+safe_VkRenderingAreaInfoKHR::~safe_VkRenderingAreaInfoKHR() {
+    if (pColorAttachmentFormats) delete[] pColorAttachmentFormats;
+    FreePnextChain(pNext);
+}
+
+void safe_VkRenderingAreaInfoKHR::initialize(const VkRenderingAreaInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pColorAttachmentFormats) delete[] pColorAttachmentFormats;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    viewMask = in_struct->viewMask;
+    colorAttachmentCount = in_struct->colorAttachmentCount;
+    pColorAttachmentFormats = nullptr;
+    depthAttachmentFormat = in_struct->depthAttachmentFormat;
+    stencilAttachmentFormat = in_struct->stencilAttachmentFormat;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pColorAttachmentFormats) {
+        pColorAttachmentFormats = new VkFormat[in_struct->colorAttachmentCount];
+        memcpy((void*)pColorAttachmentFormats, (void*)in_struct->pColorAttachmentFormats,
+               sizeof(VkFormat) * in_struct->colorAttachmentCount);
+    }
+}
+
+void safe_VkRenderingAreaInfoKHR::initialize(const safe_VkRenderingAreaInfoKHR* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    viewMask = copy_src->viewMask;
+    colorAttachmentCount = copy_src->colorAttachmentCount;
+    pColorAttachmentFormats = nullptr;
+    depthAttachmentFormat = copy_src->depthAttachmentFormat;
+    stencilAttachmentFormat = copy_src->stencilAttachmentFormat;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pColorAttachmentFormats) {
+        pColorAttachmentFormats = new VkFormat[copy_src->colorAttachmentCount];
+        memcpy((void*)pColorAttachmentFormats, (void*)copy_src->pColorAttachmentFormats,
+               sizeof(VkFormat) * copy_src->colorAttachmentCount);
+    }
+}
+
+safe_VkImageSubresource2KHR::safe_VkImageSubresource2KHR(const VkImageSubresource2KHR* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), imageSubresource(in_struct->imageSubresource) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImageSubresource2KHR::safe_VkImageSubresource2KHR()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR), pNext(nullptr), imageSubresource() {}
+
+safe_VkImageSubresource2KHR::safe_VkImageSubresource2KHR(const safe_VkImageSubresource2KHR& copy_src) {
+    sType = copy_src.sType;
+    imageSubresource = copy_src.imageSubresource;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImageSubresource2KHR& safe_VkImageSubresource2KHR::operator=(const safe_VkImageSubresource2KHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    imageSubresource = copy_src.imageSubresource;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImageSubresource2KHR::~safe_VkImageSubresource2KHR() { FreePnextChain(pNext); }
+
+void safe_VkImageSubresource2KHR::initialize(const VkImageSubresource2KHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    imageSubresource = in_struct->imageSubresource;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImageSubresource2KHR::initialize(const safe_VkImageSubresource2KHR* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imageSubresource = copy_src->imageSubresource;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDeviceImageSubresourceInfoKHR::safe_VkDeviceImageSubresourceInfoKHR(const VkDeviceImageSubresourceInfoKHR* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), pCreateInfo(nullptr), pSubresource(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(in_struct->pCreateInfo);
+    if (in_struct->pSubresource) pSubresource = new safe_VkImageSubresource2KHR(in_struct->pSubresource);
+}
+
+safe_VkDeviceImageSubresourceInfoKHR::safe_VkDeviceImageSubresourceInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR), pNext(nullptr), pCreateInfo(nullptr), pSubresource(nullptr) {}
+
+safe_VkDeviceImageSubresourceInfoKHR::safe_VkDeviceImageSubresourceInfoKHR(const safe_VkDeviceImageSubresourceInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pCreateInfo = nullptr;
+    pSubresource = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(*copy_src.pCreateInfo);
+    if (copy_src.pSubresource) pSubresource = new safe_VkImageSubresource2KHR(*copy_src.pSubresource);
+}
+
+safe_VkDeviceImageSubresourceInfoKHR& safe_VkDeviceImageSubresourceInfoKHR::operator=(
+    const safe_VkDeviceImageSubresourceInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pCreateInfo) delete pCreateInfo;
+    if (pSubresource) delete pSubresource;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pCreateInfo = nullptr;
+    pSubresource = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(*copy_src.pCreateInfo);
+    if (copy_src.pSubresource) pSubresource = new safe_VkImageSubresource2KHR(*copy_src.pSubresource);
+
+    return *this;
+}
+
+safe_VkDeviceImageSubresourceInfoKHR::~safe_VkDeviceImageSubresourceInfoKHR() {
+    if (pCreateInfo) delete pCreateInfo;
+    if (pSubresource) delete pSubresource;
+    FreePnextChain(pNext);
+}
+
+void safe_VkDeviceImageSubresourceInfoKHR::initialize(const VkDeviceImageSubresourceInfoKHR* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pCreateInfo) delete pCreateInfo;
+    if (pSubresource) delete pSubresource;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pCreateInfo = nullptr;
+    pSubresource = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (in_struct->pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(in_struct->pCreateInfo);
+    if (in_struct->pSubresource) pSubresource = new safe_VkImageSubresource2KHR(in_struct->pSubresource);
+}
+
+void safe_VkDeviceImageSubresourceInfoKHR::initialize(const safe_VkDeviceImageSubresourceInfoKHR* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pCreateInfo = nullptr;
+    pSubresource = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (copy_src->pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(*copy_src->pCreateInfo);
+    if (copy_src->pSubresource) pSubresource = new safe_VkImageSubresource2KHR(*copy_src->pSubresource);
+}
+
+safe_VkSubresourceLayout2KHR::safe_VkSubresourceLayout2KHR(const VkSubresourceLayout2KHR* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), subresourceLayout(in_struct->subresourceLayout) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSubresourceLayout2KHR::safe_VkSubresourceLayout2KHR()
+    : sType(VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR), pNext(nullptr), subresourceLayout() {}
+
+safe_VkSubresourceLayout2KHR::safe_VkSubresourceLayout2KHR(const safe_VkSubresourceLayout2KHR& copy_src) {
+    sType = copy_src.sType;
+    subresourceLayout = copy_src.subresourceLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSubresourceLayout2KHR& safe_VkSubresourceLayout2KHR::operator=(const safe_VkSubresourceLayout2KHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    subresourceLayout = copy_src.subresourceLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSubresourceLayout2KHR::~safe_VkSubresourceLayout2KHR() { FreePnextChain(pNext); }
+
+void safe_VkSubresourceLayout2KHR::initialize(const VkSubresourceLayout2KHR* in_struct,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    subresourceLayout = in_struct->subresourceLayout;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSubresourceLayout2KHR::initialize(const safe_VkSubresourceLayout2KHR* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    subresourceLayout = copy_src->subresourceLayout;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineCreateFlags2CreateInfoKHR::safe_VkPipelineCreateFlags2CreateInfoKHR(
+    const VkPipelineCreateFlags2CreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPipelineCreateFlags2CreateInfoKHR::safe_VkPipelineCreateFlags2CreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR), pNext(nullptr), flags() {}
+
+safe_VkPipelineCreateFlags2CreateInfoKHR::safe_VkPipelineCreateFlags2CreateInfoKHR(
+    const safe_VkPipelineCreateFlags2CreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPipelineCreateFlags2CreateInfoKHR& safe_VkPipelineCreateFlags2CreateInfoKHR::operator=(
+    const safe_VkPipelineCreateFlags2CreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineCreateFlags2CreateInfoKHR::~safe_VkPipelineCreateFlags2CreateInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkPipelineCreateFlags2CreateInfoKHR::initialize(const VkPipelineCreateFlags2CreateInfoKHR* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPipelineCreateFlags2CreateInfoKHR::initialize(const safe_VkPipelineCreateFlags2CreateInfoKHR* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkBufferUsageFlags2CreateInfoKHR::safe_VkBufferUsageFlags2CreateInfoKHR(const VkBufferUsageFlags2CreateInfoKHR* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType), usage(in_struct->usage) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkBufferUsageFlags2CreateInfoKHR::safe_VkBufferUsageFlags2CreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR), pNext(nullptr), usage() {}
+
+safe_VkBufferUsageFlags2CreateInfoKHR::safe_VkBufferUsageFlags2CreateInfoKHR(
+    const safe_VkBufferUsageFlags2CreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    usage = copy_src.usage;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBufferUsageFlags2CreateInfoKHR& safe_VkBufferUsageFlags2CreateInfoKHR::operator=(
+    const safe_VkBufferUsageFlags2CreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    usage = copy_src.usage;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkBufferUsageFlags2CreateInfoKHR::~safe_VkBufferUsageFlags2CreateInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkBufferUsageFlags2CreateInfoKHR::initialize(const VkBufferUsageFlags2CreateInfoKHR* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    usage = in_struct->usage;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkBufferUsageFlags2CreateInfoKHR::initialize(const safe_VkBufferUsageFlags2CreateInfoKHR* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    usage = copy_src->usage;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
+    const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), rayTracingPositionFetch(in_struct->rayTracingPositionFetch) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR), pNext(nullptr), rayTracingPositionFetch() {}
+
+safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
+    const safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    rayTracingPositionFetch = copy_src.rayTracingPositionFetch;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    rayTracingPositionFetch = copy_src.rayTracingPositionFetch;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::~safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::initialize(
+    const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    rayTracingPositionFetch = in_struct->rayTracingPositionFetch;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::initialize(
+    const safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    rayTracingPositionFetch = copy_src->rayTracingPositionFetch;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkCooperativeMatrixPropertiesKHR::safe_VkCooperativeMatrixPropertiesKHR(const VkCooperativeMatrixPropertiesKHR* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType),
+      MSize(in_struct->MSize),
+      NSize(in_struct->NSize),
+      KSize(in_struct->KSize),
+      AType(in_struct->AType),
+      BType(in_struct->BType),
+      CType(in_struct->CType),
+      ResultType(in_struct->ResultType),
+      saturatingAccumulation(in_struct->saturatingAccumulation),
+      scope(in_struct->scope) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkCooperativeMatrixPropertiesKHR::safe_VkCooperativeMatrixPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR),
+      pNext(nullptr),
+      MSize(),
+      NSize(),
+      KSize(),
+      AType(),
+      BType(),
+      CType(),
+      ResultType(),
+      saturatingAccumulation(),
+      scope() {}
+
+safe_VkCooperativeMatrixPropertiesKHR::safe_VkCooperativeMatrixPropertiesKHR(
+    const safe_VkCooperativeMatrixPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    MSize = copy_src.MSize;
+    NSize = copy_src.NSize;
+    KSize = copy_src.KSize;
+    AType = copy_src.AType;
+    BType = copy_src.BType;
+    CType = copy_src.CType;
+    ResultType = copy_src.ResultType;
+    saturatingAccumulation = copy_src.saturatingAccumulation;
+    scope = copy_src.scope;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkCooperativeMatrixPropertiesKHR& safe_VkCooperativeMatrixPropertiesKHR::operator=(
+    const safe_VkCooperativeMatrixPropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    MSize = copy_src.MSize;
+    NSize = copy_src.NSize;
+    KSize = copy_src.KSize;
+    AType = copy_src.AType;
+    BType = copy_src.BType;
+    CType = copy_src.CType;
+    ResultType = copy_src.ResultType;
+    saturatingAccumulation = copy_src.saturatingAccumulation;
+    scope = copy_src.scope;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkCooperativeMatrixPropertiesKHR::~safe_VkCooperativeMatrixPropertiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkCooperativeMatrixPropertiesKHR::initialize(const VkCooperativeMatrixPropertiesKHR* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    MSize = in_struct->MSize;
+    NSize = in_struct->NSize;
+    KSize = in_struct->KSize;
+    AType = in_struct->AType;
+    BType = in_struct->BType;
+    CType = in_struct->CType;
+    ResultType = in_struct->ResultType;
+    saturatingAccumulation = in_struct->saturatingAccumulation;
+    scope = in_struct->scope;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkCooperativeMatrixPropertiesKHR::initialize(const safe_VkCooperativeMatrixPropertiesKHR* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    MSize = copy_src->MSize;
+    NSize = copy_src->NSize;
+    KSize = copy_src->KSize;
+    AType = copy_src->AType;
+    BType = copy_src->BType;
+    CType = copy_src->CType;
+    ResultType = copy_src->ResultType;
+    saturatingAccumulation = copy_src->saturatingAccumulation;
+    scope = copy_src->scope;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR(
+    const VkPhysicalDeviceCooperativeMatrixFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      cooperativeMatrix(in_struct->cooperativeMatrix),
+      cooperativeMatrixRobustBufferAccess(in_struct->cooperativeMatrixRobustBufferAccess) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR),
+      pNext(nullptr),
+      cooperativeMatrix(),
+      cooperativeMatrixRobustBufferAccess() {}
+
+safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR(
+    const safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    cooperativeMatrix = copy_src.cooperativeMatrix;
+    cooperativeMatrixRobustBufferAccess = copy_src.cooperativeMatrixRobustBufferAccess;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    cooperativeMatrix = copy_src.cooperativeMatrix;
+    cooperativeMatrixRobustBufferAccess = copy_src.cooperativeMatrixRobustBufferAccess;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::~safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::initialize(const VkPhysicalDeviceCooperativeMatrixFeaturesKHR* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    cooperativeMatrix = in_struct->cooperativeMatrix;
+    cooperativeMatrixRobustBufferAccess = in_struct->cooperativeMatrixRobustBufferAccess;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR::initialize(
+    const safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    cooperativeMatrix = copy_src->cooperativeMatrix;
+    cooperativeMatrixRobustBufferAccess = copy_src->cooperativeMatrixRobustBufferAccess;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR(
+    const VkPhysicalDeviceCooperativeMatrixPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), cooperativeMatrixSupportedStages(in_struct->cooperativeMatrixSupportedStages) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR),
+      pNext(nullptr),
+      cooperativeMatrixSupportedStages() {}
+
+safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR(
+    const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    cooperativeMatrixSupportedStages = copy_src.cooperativeMatrixSupportedStages;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::operator=(
+    const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    cooperativeMatrixSupportedStages = copy_src.cooperativeMatrixSupportedStages;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::~safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::initialize(
+    const VkPhysicalDeviceCooperativeMatrixPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    cooperativeMatrixSupportedStages = in_struct->cooperativeMatrixSupportedStages;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::initialize(
+    const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    cooperativeMatrixSupportedStages = copy_src->cooperativeMatrixSupportedStages;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoDecodeAV1ProfileInfoKHR::safe_VkVideoDecodeAV1ProfileInfoKHR(const VkVideoDecodeAV1ProfileInfoKHR* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType), stdProfile(in_struct->stdProfile), filmGrainSupport(in_struct->filmGrainSupport) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoDecodeAV1ProfileInfoKHR::safe_VkVideoDecodeAV1ProfileInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR), pNext(nullptr), stdProfile(), filmGrainSupport() {}
+
+safe_VkVideoDecodeAV1ProfileInfoKHR::safe_VkVideoDecodeAV1ProfileInfoKHR(const safe_VkVideoDecodeAV1ProfileInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    stdProfile = copy_src.stdProfile;
+    filmGrainSupport = copy_src.filmGrainSupport;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoDecodeAV1ProfileInfoKHR& safe_VkVideoDecodeAV1ProfileInfoKHR::operator=(
+    const safe_VkVideoDecodeAV1ProfileInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    stdProfile = copy_src.stdProfile;
+    filmGrainSupport = copy_src.filmGrainSupport;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoDecodeAV1ProfileInfoKHR::~safe_VkVideoDecodeAV1ProfileInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoDecodeAV1ProfileInfoKHR::initialize(const VkVideoDecodeAV1ProfileInfoKHR* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    stdProfile = in_struct->stdProfile;
+    filmGrainSupport = in_struct->filmGrainSupport;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoDecodeAV1ProfileInfoKHR::initialize(const safe_VkVideoDecodeAV1ProfileInfoKHR* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stdProfile = copy_src->stdProfile;
+    filmGrainSupport = copy_src->filmGrainSupport;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoDecodeAV1CapabilitiesKHR::safe_VkVideoDecodeAV1CapabilitiesKHR(const VkVideoDecodeAV1CapabilitiesKHR* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), maxLevel(in_struct->maxLevel) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoDecodeAV1CapabilitiesKHR::safe_VkVideoDecodeAV1CapabilitiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR), pNext(nullptr), maxLevel() {}
+
+safe_VkVideoDecodeAV1CapabilitiesKHR::safe_VkVideoDecodeAV1CapabilitiesKHR(const safe_VkVideoDecodeAV1CapabilitiesKHR& copy_src) {
+    sType = copy_src.sType;
+    maxLevel = copy_src.maxLevel;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoDecodeAV1CapabilitiesKHR& safe_VkVideoDecodeAV1CapabilitiesKHR::operator=(
+    const safe_VkVideoDecodeAV1CapabilitiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxLevel = copy_src.maxLevel;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoDecodeAV1CapabilitiesKHR::~safe_VkVideoDecodeAV1CapabilitiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoDecodeAV1CapabilitiesKHR::initialize(const VkVideoDecodeAV1CapabilitiesKHR* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxLevel = in_struct->maxLevel;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoDecodeAV1CapabilitiesKHR::initialize(const safe_VkVideoDecodeAV1CapabilitiesKHR* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxLevel = copy_src->maxLevel;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR(
+    const VkVideoDecodeAV1SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), pStdSequenceHeader(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pStdSequenceHeader) {
+        pStdSequenceHeader = new StdVideoAV1SequenceHeader(*in_struct->pStdSequenceHeader);
+    }
+}
+
+safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR), pNext(nullptr), pStdSequenceHeader(nullptr) {}
+
+safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR(
+    const safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pStdSequenceHeader = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdSequenceHeader) {
+        pStdSequenceHeader = new StdVideoAV1SequenceHeader(*copy_src.pStdSequenceHeader);
+    }
+}
+
+safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR& safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::operator=(
+    const safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pStdSequenceHeader) delete pStdSequenceHeader;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pStdSequenceHeader = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdSequenceHeader) {
+        pStdSequenceHeader = new StdVideoAV1SequenceHeader(*copy_src.pStdSequenceHeader);
+    }
+
+    return *this;
+}
+
+safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::~safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR() {
+    if (pStdSequenceHeader) delete pStdSequenceHeader;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::initialize(
+    const VkVideoDecodeAV1SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pStdSequenceHeader) delete pStdSequenceHeader;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pStdSequenceHeader = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pStdSequenceHeader) {
+        pStdSequenceHeader = new StdVideoAV1SequenceHeader(*in_struct->pStdSequenceHeader);
+    }
+}
+
+void safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR::initialize(
+    const safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pStdSequenceHeader = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pStdSequenceHeader) {
+        pStdSequenceHeader = new StdVideoAV1SequenceHeader(*copy_src->pStdSequenceHeader);
+    }
+}
+
+safe_VkVideoDecodeAV1PictureInfoKHR::safe_VkVideoDecodeAV1PictureInfoKHR(const VkVideoDecodeAV1PictureInfoKHR* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType),
+      pStdPictureInfo(nullptr),
+      frameHeaderOffset(in_struct->frameHeaderOffset),
+      tileCount(in_struct->tileCount),
+      pTileOffsets(nullptr),
+      pTileSizes(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoDecodeAV1PictureInfo(*in_struct->pStdPictureInfo);
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) {
+        referenceNameSlotIndices[i] = in_struct->referenceNameSlotIndices[i];
+    }
+
+    if (in_struct->pTileOffsets) {
+        pTileOffsets = new uint32_t[in_struct->tileCount];
+        memcpy((void*)pTileOffsets, (void*)in_struct->pTileOffsets, sizeof(uint32_t) * in_struct->tileCount);
+    }
+
+    if (in_struct->pTileSizes) {
+        pTileSizes = new uint32_t[in_struct->tileCount];
+        memcpy((void*)pTileSizes, (void*)in_struct->pTileSizes, sizeof(uint32_t) * in_struct->tileCount);
+    }
+}
+
+safe_VkVideoDecodeAV1PictureInfoKHR::safe_VkVideoDecodeAV1PictureInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR),
+      pNext(nullptr),
+      pStdPictureInfo(nullptr),
+      frameHeaderOffset(),
+      tileCount(),
+      pTileOffsets(nullptr),
+      pTileSizes(nullptr) {}
+
+safe_VkVideoDecodeAV1PictureInfoKHR::safe_VkVideoDecodeAV1PictureInfoKHR(const safe_VkVideoDecodeAV1PictureInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pStdPictureInfo = nullptr;
+    frameHeaderOffset = copy_src.frameHeaderOffset;
+    tileCount = copy_src.tileCount;
+    pTileOffsets = nullptr;
+    pTileSizes = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoDecodeAV1PictureInfo(*copy_src.pStdPictureInfo);
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) {
+        referenceNameSlotIndices[i] = copy_src.referenceNameSlotIndices[i];
+    }
+
+    if (copy_src.pTileOffsets) {
+        pTileOffsets = new uint32_t[copy_src.tileCount];
+        memcpy((void*)pTileOffsets, (void*)copy_src.pTileOffsets, sizeof(uint32_t) * copy_src.tileCount);
+    }
+
+    if (copy_src.pTileSizes) {
+        pTileSizes = new uint32_t[copy_src.tileCount];
+        memcpy((void*)pTileSizes, (void*)copy_src.pTileSizes, sizeof(uint32_t) * copy_src.tileCount);
+    }
+}
+
+safe_VkVideoDecodeAV1PictureInfoKHR& safe_VkVideoDecodeAV1PictureInfoKHR::operator=(
+    const safe_VkVideoDecodeAV1PictureInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pStdPictureInfo) delete pStdPictureInfo;
+    if (pTileOffsets) delete[] pTileOffsets;
+    if (pTileSizes) delete[] pTileSizes;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pStdPictureInfo = nullptr;
+    frameHeaderOffset = copy_src.frameHeaderOffset;
+    tileCount = copy_src.tileCount;
+    pTileOffsets = nullptr;
+    pTileSizes = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoDecodeAV1PictureInfo(*copy_src.pStdPictureInfo);
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) {
+        referenceNameSlotIndices[i] = copy_src.referenceNameSlotIndices[i];
+    }
+
+    if (copy_src.pTileOffsets) {
+        pTileOffsets = new uint32_t[copy_src.tileCount];
+        memcpy((void*)pTileOffsets, (void*)copy_src.pTileOffsets, sizeof(uint32_t) * copy_src.tileCount);
+    }
+
+    if (copy_src.pTileSizes) {
+        pTileSizes = new uint32_t[copy_src.tileCount];
+        memcpy((void*)pTileSizes, (void*)copy_src.pTileSizes, sizeof(uint32_t) * copy_src.tileCount);
+    }
+
+    return *this;
+}
+
+safe_VkVideoDecodeAV1PictureInfoKHR::~safe_VkVideoDecodeAV1PictureInfoKHR() {
+    if (pStdPictureInfo) delete pStdPictureInfo;
+    if (pTileOffsets) delete[] pTileOffsets;
+    if (pTileSizes) delete[] pTileSizes;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoDecodeAV1PictureInfoKHR::initialize(const VkVideoDecodeAV1PictureInfoKHR* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pStdPictureInfo) delete pStdPictureInfo;
+    if (pTileOffsets) delete[] pTileOffsets;
+    if (pTileSizes) delete[] pTileSizes;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pStdPictureInfo = nullptr;
+    frameHeaderOffset = in_struct->frameHeaderOffset;
+    tileCount = in_struct->tileCount;
+    pTileOffsets = nullptr;
+    pTileSizes = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoDecodeAV1PictureInfo(*in_struct->pStdPictureInfo);
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) {
+        referenceNameSlotIndices[i] = in_struct->referenceNameSlotIndices[i];
+    }
+
+    if (in_struct->pTileOffsets) {
+        pTileOffsets = new uint32_t[in_struct->tileCount];
+        memcpy((void*)pTileOffsets, (void*)in_struct->pTileOffsets, sizeof(uint32_t) * in_struct->tileCount);
+    }
+
+    if (in_struct->pTileSizes) {
+        pTileSizes = new uint32_t[in_struct->tileCount];
+        memcpy((void*)pTileSizes, (void*)in_struct->pTileSizes, sizeof(uint32_t) * in_struct->tileCount);
+    }
+}
+
+void safe_VkVideoDecodeAV1PictureInfoKHR::initialize(const safe_VkVideoDecodeAV1PictureInfoKHR* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pStdPictureInfo = nullptr;
+    frameHeaderOffset = copy_src->frameHeaderOffset;
+    tileCount = copy_src->tileCount;
+    pTileOffsets = nullptr;
+    pTileSizes = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoDecodeAV1PictureInfo(*copy_src->pStdPictureInfo);
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) {
+        referenceNameSlotIndices[i] = copy_src->referenceNameSlotIndices[i];
+    }
+
+    if (copy_src->pTileOffsets) {
+        pTileOffsets = new uint32_t[copy_src->tileCount];
+        memcpy((void*)pTileOffsets, (void*)copy_src->pTileOffsets, sizeof(uint32_t) * copy_src->tileCount);
+    }
+
+    if (copy_src->pTileSizes) {
+        pTileSizes = new uint32_t[copy_src->tileCount];
+        memcpy((void*)pTileSizes, (void*)copy_src->pTileSizes, sizeof(uint32_t) * copy_src->tileCount);
+    }
+}
+
+safe_VkVideoDecodeAV1DpbSlotInfoKHR::safe_VkVideoDecodeAV1DpbSlotInfoKHR(const VkVideoDecodeAV1DpbSlotInfoKHR* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType), pStdReferenceInfo(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoDecodeAV1ReferenceInfo(*in_struct->pStdReferenceInfo);
+    }
+}
+
+safe_VkVideoDecodeAV1DpbSlotInfoKHR::safe_VkVideoDecodeAV1DpbSlotInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR), pNext(nullptr), pStdReferenceInfo(nullptr) {}
+
+safe_VkVideoDecodeAV1DpbSlotInfoKHR::safe_VkVideoDecodeAV1DpbSlotInfoKHR(const safe_VkVideoDecodeAV1DpbSlotInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pStdReferenceInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoDecodeAV1ReferenceInfo(*copy_src.pStdReferenceInfo);
+    }
+}
+
+safe_VkVideoDecodeAV1DpbSlotInfoKHR& safe_VkVideoDecodeAV1DpbSlotInfoKHR::operator=(
+    const safe_VkVideoDecodeAV1DpbSlotInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pStdReferenceInfo) delete pStdReferenceInfo;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pStdReferenceInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoDecodeAV1ReferenceInfo(*copy_src.pStdReferenceInfo);
+    }
+
+    return *this;
+}
+
+safe_VkVideoDecodeAV1DpbSlotInfoKHR::~safe_VkVideoDecodeAV1DpbSlotInfoKHR() {
+    if (pStdReferenceInfo) delete pStdReferenceInfo;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoDecodeAV1DpbSlotInfoKHR::initialize(const VkVideoDecodeAV1DpbSlotInfoKHR* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pStdReferenceInfo) delete pStdReferenceInfo;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pStdReferenceInfo = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoDecodeAV1ReferenceInfo(*in_struct->pStdReferenceInfo);
+    }
+}
+
+void safe_VkVideoDecodeAV1DpbSlotInfoKHR::initialize(const safe_VkVideoDecodeAV1DpbSlotInfoKHR* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pStdReferenceInfo = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoDecodeAV1ReferenceInfo(*copy_src->pStdReferenceInfo);
+    }
+}
+
+safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(
+    const VkPhysicalDeviceVideoMaintenance1FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), videoMaintenance1(in_struct->videoMaintenance1) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR), pNext(nullptr), videoMaintenance1() {}
+
+safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(
+    const safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    videoMaintenance1 = copy_src.videoMaintenance1;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR& safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    videoMaintenance1 = copy_src.videoMaintenance1;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::~safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::initialize(const VkPhysicalDeviceVideoMaintenance1FeaturesKHR* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    videoMaintenance1 = in_struct->videoMaintenance1;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::initialize(
+    const safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    videoMaintenance1 = copy_src->videoMaintenance1;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoInlineQueryInfoKHR::safe_VkVideoInlineQueryInfoKHR(const VkVideoInlineQueryInfoKHR* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      queryPool(in_struct->queryPool),
+      firstQuery(in_struct->firstQuery),
+      queryCount(in_struct->queryCount) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoInlineQueryInfoKHR::safe_VkVideoInlineQueryInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR), pNext(nullptr), queryPool(), firstQuery(), queryCount() {}
+
+safe_VkVideoInlineQueryInfoKHR::safe_VkVideoInlineQueryInfoKHR(const safe_VkVideoInlineQueryInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    queryPool = copy_src.queryPool;
+    firstQuery = copy_src.firstQuery;
+    queryCount = copy_src.queryCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoInlineQueryInfoKHR& safe_VkVideoInlineQueryInfoKHR::operator=(const safe_VkVideoInlineQueryInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    queryPool = copy_src.queryPool;
+    firstQuery = copy_src.firstQuery;
+    queryCount = copy_src.queryCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoInlineQueryInfoKHR::~safe_VkVideoInlineQueryInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoInlineQueryInfoKHR::initialize(const VkVideoInlineQueryInfoKHR* in_struct,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    queryPool = in_struct->queryPool;
+    firstQuery = in_struct->firstQuery;
+    queryCount = in_struct->queryCount;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoInlineQueryInfoKHR::initialize(const safe_VkVideoInlineQueryInfoKHR* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    queryPool = copy_src->queryPool;
+    firstQuery = copy_src->firstQuery;
+    queryCount = copy_src->queryCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR(
+    const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      maxVertexAttribDivisor(in_struct->maxVertexAttribDivisor),
+      supportsNonZeroFirstInstance(in_struct->supportsNonZeroFirstInstance) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR),
+      pNext(nullptr),
+      maxVertexAttribDivisor(),
+      supportsNonZeroFirstInstance() {}
+
+safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR(
+    const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    maxVertexAttribDivisor = copy_src.maxVertexAttribDivisor;
+    supportsNonZeroFirstInstance = copy_src.supportsNonZeroFirstInstance;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::operator=(
+    const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxVertexAttribDivisor = copy_src.maxVertexAttribDivisor;
+    supportsNonZeroFirstInstance = copy_src.supportsNonZeroFirstInstance;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::~safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::initialize(
+    const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxVertexAttribDivisor = in_struct->maxVertexAttribDivisor;
+    supportsNonZeroFirstInstance = in_struct->supportsNonZeroFirstInstance;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::initialize(
+    const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxVertexAttribDivisor = copy_src->maxVertexAttribDivisor;
+    supportsNonZeroFirstInstance = copy_src->supportsNonZeroFirstInstance;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::safe_VkPipelineVertexInputDivisorStateCreateInfoKHR(
+    const VkPipelineVertexInputDivisorStateCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), vertexBindingDivisorCount(in_struct->vertexBindingDivisorCount), pVertexBindingDivisors(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pVertexBindingDivisors) {
+        pVertexBindingDivisors = new VkVertexInputBindingDivisorDescriptionKHR[in_struct->vertexBindingDivisorCount];
+        memcpy((void*)pVertexBindingDivisors, (void*)in_struct->pVertexBindingDivisors,
+               sizeof(VkVertexInputBindingDivisorDescriptionKHR) * in_struct->vertexBindingDivisorCount);
+    }
+}
+
+safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::safe_VkPipelineVertexInputDivisorStateCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR),
+      pNext(nullptr),
+      vertexBindingDivisorCount(),
+      pVertexBindingDivisors(nullptr) {}
+
+safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::safe_VkPipelineVertexInputDivisorStateCreateInfoKHR(
+    const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    vertexBindingDivisorCount = copy_src.vertexBindingDivisorCount;
+    pVertexBindingDivisors = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pVertexBindingDivisors) {
+        pVertexBindingDivisors = new VkVertexInputBindingDivisorDescriptionKHR[copy_src.vertexBindingDivisorCount];
+        memcpy((void*)pVertexBindingDivisors, (void*)copy_src.pVertexBindingDivisors,
+               sizeof(VkVertexInputBindingDivisorDescriptionKHR) * copy_src.vertexBindingDivisorCount);
+    }
+}
+
+safe_VkPipelineVertexInputDivisorStateCreateInfoKHR& safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::operator=(
+    const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pVertexBindingDivisors) delete[] pVertexBindingDivisors;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    vertexBindingDivisorCount = copy_src.vertexBindingDivisorCount;
+    pVertexBindingDivisors = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pVertexBindingDivisors) {
+        pVertexBindingDivisors = new VkVertexInputBindingDivisorDescriptionKHR[copy_src.vertexBindingDivisorCount];
+        memcpy((void*)pVertexBindingDivisors, (void*)copy_src.pVertexBindingDivisors,
+               sizeof(VkVertexInputBindingDivisorDescriptionKHR) * copy_src.vertexBindingDivisorCount);
+    }
+
+    return *this;
+}
+
+safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::~safe_VkPipelineVertexInputDivisorStateCreateInfoKHR() {
+    if (pVertexBindingDivisors) delete[] pVertexBindingDivisors;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::initialize(
+    const VkPipelineVertexInputDivisorStateCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pVertexBindingDivisors) delete[] pVertexBindingDivisors;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    vertexBindingDivisorCount = in_struct->vertexBindingDivisorCount;
+    pVertexBindingDivisors = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pVertexBindingDivisors) {
+        pVertexBindingDivisors = new VkVertexInputBindingDivisorDescriptionKHR[in_struct->vertexBindingDivisorCount];
+        memcpy((void*)pVertexBindingDivisors, (void*)in_struct->pVertexBindingDivisors,
+               sizeof(VkVertexInputBindingDivisorDescriptionKHR) * in_struct->vertexBindingDivisorCount);
+    }
+}
+
+void safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::initialize(
+    const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    vertexBindingDivisorCount = copy_src->vertexBindingDivisorCount;
+    pVertexBindingDivisors = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pVertexBindingDivisors) {
+        pVertexBindingDivisors = new VkVertexInputBindingDivisorDescriptionKHR[copy_src->vertexBindingDivisorCount];
+        memcpy((void*)pVertexBindingDivisors, (void*)copy_src->pVertexBindingDivisors,
+               sizeof(VkVertexInputBindingDivisorDescriptionKHR) * copy_src->vertexBindingDivisorCount);
+    }
+}
+
+safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR(
+    const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      vertexAttributeInstanceRateDivisor(in_struct->vertexAttributeInstanceRateDivisor),
+      vertexAttributeInstanceRateZeroDivisor(in_struct->vertexAttributeInstanceRateZeroDivisor) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR),
+      pNext(nullptr),
+      vertexAttributeInstanceRateDivisor(),
+      vertexAttributeInstanceRateZeroDivisor() {}
+
+safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR(
+    const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    vertexAttributeInstanceRateDivisor = copy_src.vertexAttributeInstanceRateDivisor;
+    vertexAttributeInstanceRateZeroDivisor = copy_src.vertexAttributeInstanceRateZeroDivisor;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    vertexAttributeInstanceRateDivisor = copy_src.vertexAttributeInstanceRateDivisor;
+    vertexAttributeInstanceRateZeroDivisor = copy_src.vertexAttributeInstanceRateZeroDivisor;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::~safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::initialize(
+    const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    vertexAttributeInstanceRateDivisor = in_struct->vertexAttributeInstanceRateDivisor;
+    vertexAttributeInstanceRateZeroDivisor = in_struct->vertexAttributeInstanceRateZeroDivisor;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::initialize(
+    const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    vertexAttributeInstanceRateDivisor = copy_src->vertexAttributeInstanceRateDivisor;
+    vertexAttributeInstanceRateZeroDivisor = copy_src->vertexAttributeInstanceRateZeroDivisor;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR(
+    const VkPhysicalDeviceShaderFloatControls2FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), shaderFloatControls2(in_struct->shaderFloatControls2) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR), pNext(nullptr), shaderFloatControls2() {}
+
+safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR(
+    const safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    shaderFloatControls2 = copy_src.shaderFloatControls2;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR& safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderFloatControls2 = copy_src.shaderFloatControls2;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::~safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::initialize(
+    const VkPhysicalDeviceShaderFloatControls2FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderFloatControls2 = in_struct->shaderFloatControls2;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::initialize(
+    const safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderFloatControls2 = copy_src->shaderFloatControls2;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR(
+    const VkPhysicalDeviceIndexTypeUint8FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), indexTypeUint8(in_struct->indexTypeUint8) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR), pNext(nullptr), indexTypeUint8() {}
+
+safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR(
+    const safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    indexTypeUint8 = copy_src.indexTypeUint8;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR& safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    indexTypeUint8 = copy_src.indexTypeUint8;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::~safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::initialize(const VkPhysicalDeviceIndexTypeUint8FeaturesKHR* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    indexTypeUint8 = in_struct->indexTypeUint8;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::initialize(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    indexTypeUint8 = copy_src->indexTypeUint8;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::safe_VkPhysicalDeviceLineRasterizationFeaturesKHR(
+    const VkPhysicalDeviceLineRasterizationFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      rectangularLines(in_struct->rectangularLines),
+      bresenhamLines(in_struct->bresenhamLines),
+      smoothLines(in_struct->smoothLines),
+      stippledRectangularLines(in_struct->stippledRectangularLines),
+      stippledBresenhamLines(in_struct->stippledBresenhamLines),
+      stippledSmoothLines(in_struct->stippledSmoothLines) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::safe_VkPhysicalDeviceLineRasterizationFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR),
+      pNext(nullptr),
+      rectangularLines(),
+      bresenhamLines(),
+      smoothLines(),
+      stippledRectangularLines(),
+      stippledBresenhamLines(),
+      stippledSmoothLines() {}
+
+safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::safe_VkPhysicalDeviceLineRasterizationFeaturesKHR(
+    const safe_VkPhysicalDeviceLineRasterizationFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    rectangularLines = copy_src.rectangularLines;
+    bresenhamLines = copy_src.bresenhamLines;
+    smoothLines = copy_src.smoothLines;
+    stippledRectangularLines = copy_src.stippledRectangularLines;
+    stippledBresenhamLines = copy_src.stippledBresenhamLines;
+    stippledSmoothLines = copy_src.stippledSmoothLines;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceLineRasterizationFeaturesKHR& safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceLineRasterizationFeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    rectangularLines = copy_src.rectangularLines;
+    bresenhamLines = copy_src.bresenhamLines;
+    smoothLines = copy_src.smoothLines;
+    stippledRectangularLines = copy_src.stippledRectangularLines;
+    stippledBresenhamLines = copy_src.stippledBresenhamLines;
+    stippledSmoothLines = copy_src.stippledSmoothLines;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::~safe_VkPhysicalDeviceLineRasterizationFeaturesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::initialize(const VkPhysicalDeviceLineRasterizationFeaturesKHR* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    rectangularLines = in_struct->rectangularLines;
+    bresenhamLines = in_struct->bresenhamLines;
+    smoothLines = in_struct->smoothLines;
+    stippledRectangularLines = in_struct->stippledRectangularLines;
+    stippledBresenhamLines = in_struct->stippledBresenhamLines;
+    stippledSmoothLines = in_struct->stippledSmoothLines;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::initialize(
+    const safe_VkPhysicalDeviceLineRasterizationFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    rectangularLines = copy_src->rectangularLines;
+    bresenhamLines = copy_src->bresenhamLines;
+    smoothLines = copy_src->smoothLines;
+    stippledRectangularLines = copy_src->stippledRectangularLines;
+    stippledBresenhamLines = copy_src->stippledBresenhamLines;
+    stippledSmoothLines = copy_src->stippledSmoothLines;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::safe_VkPhysicalDeviceLineRasterizationPropertiesKHR(
+    const VkPhysicalDeviceLineRasterizationPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), lineSubPixelPrecisionBits(in_struct->lineSubPixelPrecisionBits) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::safe_VkPhysicalDeviceLineRasterizationPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR), pNext(nullptr), lineSubPixelPrecisionBits() {}
+
+safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::safe_VkPhysicalDeviceLineRasterizationPropertiesKHR(
+    const safe_VkPhysicalDeviceLineRasterizationPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    lineSubPixelPrecisionBits = copy_src.lineSubPixelPrecisionBits;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceLineRasterizationPropertiesKHR& safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::operator=(
+    const safe_VkPhysicalDeviceLineRasterizationPropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    lineSubPixelPrecisionBits = copy_src.lineSubPixelPrecisionBits;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::~safe_VkPhysicalDeviceLineRasterizationPropertiesKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::initialize(
+    const VkPhysicalDeviceLineRasterizationPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    lineSubPixelPrecisionBits = in_struct->lineSubPixelPrecisionBits;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::initialize(
+    const safe_VkPhysicalDeviceLineRasterizationPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    lineSubPixelPrecisionBits = copy_src->lineSubPixelPrecisionBits;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineRasterizationLineStateCreateInfoKHR::safe_VkPipelineRasterizationLineStateCreateInfoKHR(
+    const VkPipelineRasterizationLineStateCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      lineRasterizationMode(in_struct->lineRasterizationMode),
+      stippledLineEnable(in_struct->stippledLineEnable),
+      lineStippleFactor(in_struct->lineStippleFactor),
+      lineStipplePattern(in_struct->lineStipplePattern) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPipelineRasterizationLineStateCreateInfoKHR::safe_VkPipelineRasterizationLineStateCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR),
+      pNext(nullptr),
+      lineRasterizationMode(),
+      stippledLineEnable(),
+      lineStippleFactor(),
+      lineStipplePattern() {}
+
+safe_VkPipelineRasterizationLineStateCreateInfoKHR::safe_VkPipelineRasterizationLineStateCreateInfoKHR(
+    const safe_VkPipelineRasterizationLineStateCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    lineRasterizationMode = copy_src.lineRasterizationMode;
+    stippledLineEnable = copy_src.stippledLineEnable;
+    lineStippleFactor = copy_src.lineStippleFactor;
+    lineStipplePattern = copy_src.lineStipplePattern;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPipelineRasterizationLineStateCreateInfoKHR& safe_VkPipelineRasterizationLineStateCreateInfoKHR::operator=(
+    const safe_VkPipelineRasterizationLineStateCreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    lineRasterizationMode = copy_src.lineRasterizationMode;
+    stippledLineEnable = copy_src.stippledLineEnable;
+    lineStippleFactor = copy_src.lineStippleFactor;
+    lineStipplePattern = copy_src.lineStipplePattern;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineRasterizationLineStateCreateInfoKHR::~safe_VkPipelineRasterizationLineStateCreateInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkPipelineRasterizationLineStateCreateInfoKHR::initialize(const VkPipelineRasterizationLineStateCreateInfoKHR* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    lineRasterizationMode = in_struct->lineRasterizationMode;
+    stippledLineEnable = in_struct->stippledLineEnable;
+    lineStippleFactor = in_struct->lineStippleFactor;
+    lineStipplePattern = in_struct->lineStipplePattern;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPipelineRasterizationLineStateCreateInfoKHR::initialize(
+    const safe_VkPipelineRasterizationLineStateCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    lineRasterizationMode = copy_src->lineRasterizationMode;
+    stippledLineEnable = copy_src->stippledLineEnable;
+    lineStippleFactor = copy_src->lineStippleFactor;
+    lineStipplePattern = copy_src->lineStipplePattern;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkCalibratedTimestampInfoKHR::safe_VkCalibratedTimestampInfoKHR(const VkCalibratedTimestampInfoKHR* in_struct,
+                                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), timeDomain(in_struct->timeDomain) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkCalibratedTimestampInfoKHR::safe_VkCalibratedTimestampInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR), pNext(nullptr), timeDomain() {}
+
+safe_VkCalibratedTimestampInfoKHR::safe_VkCalibratedTimestampInfoKHR(const safe_VkCalibratedTimestampInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    timeDomain = copy_src.timeDomain;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkCalibratedTimestampInfoKHR& safe_VkCalibratedTimestampInfoKHR::operator=(const safe_VkCalibratedTimestampInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    timeDomain = copy_src.timeDomain;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkCalibratedTimestampInfoKHR::~safe_VkCalibratedTimestampInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkCalibratedTimestampInfoKHR::initialize(const VkCalibratedTimestampInfoKHR* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    timeDomain = in_struct->timeDomain;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkCalibratedTimestampInfoKHR::initialize(const safe_VkCalibratedTimestampInfoKHR* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    timeDomain = copy_src->timeDomain;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR(
+    const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), shaderExpectAssume(in_struct->shaderExpectAssume) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR), pNext(nullptr), shaderExpectAssume() {}
+
+safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR(
+    const safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    shaderExpectAssume = copy_src.shaderExpectAssume;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR& safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderExpectAssume = copy_src.shaderExpectAssume;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::~safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::initialize(const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderExpectAssume = in_struct->shaderExpectAssume;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::initialize(
+    const safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderExpectAssume = copy_src->shaderExpectAssume;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceMaintenance6FeaturesKHR::safe_VkPhysicalDeviceMaintenance6FeaturesKHR(
+    const VkPhysicalDeviceMaintenance6FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), maintenance6(in_struct->maintenance6) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMaintenance6FeaturesKHR::safe_VkPhysicalDeviceMaintenance6FeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR), pNext(nullptr), maintenance6() {}
+
+safe_VkPhysicalDeviceMaintenance6FeaturesKHR::safe_VkPhysicalDeviceMaintenance6FeaturesKHR(
+    const safe_VkPhysicalDeviceMaintenance6FeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    maintenance6 = copy_src.maintenance6;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMaintenance6FeaturesKHR& safe_VkPhysicalDeviceMaintenance6FeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceMaintenance6FeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maintenance6 = copy_src.maintenance6;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMaintenance6FeaturesKHR::~safe_VkPhysicalDeviceMaintenance6FeaturesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceMaintenance6FeaturesKHR::initialize(const VkPhysicalDeviceMaintenance6FeaturesKHR* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maintenance6 = in_struct->maintenance6;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMaintenance6FeaturesKHR::initialize(const safe_VkPhysicalDeviceMaintenance6FeaturesKHR* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maintenance6 = copy_src->maintenance6;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceMaintenance6PropertiesKHR::safe_VkPhysicalDeviceMaintenance6PropertiesKHR(
+    const VkPhysicalDeviceMaintenance6PropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      blockTexelViewCompatibleMultipleLayers(in_struct->blockTexelViewCompatibleMultipleLayers),
+      maxCombinedImageSamplerDescriptorCount(in_struct->maxCombinedImageSamplerDescriptorCount),
+      fragmentShadingRateClampCombinerInputs(in_struct->fragmentShadingRateClampCombinerInputs) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMaintenance6PropertiesKHR::safe_VkPhysicalDeviceMaintenance6PropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR),
+      pNext(nullptr),
+      blockTexelViewCompatibleMultipleLayers(),
+      maxCombinedImageSamplerDescriptorCount(),
+      fragmentShadingRateClampCombinerInputs() {}
+
+safe_VkPhysicalDeviceMaintenance6PropertiesKHR::safe_VkPhysicalDeviceMaintenance6PropertiesKHR(
+    const safe_VkPhysicalDeviceMaintenance6PropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    blockTexelViewCompatibleMultipleLayers = copy_src.blockTexelViewCompatibleMultipleLayers;
+    maxCombinedImageSamplerDescriptorCount = copy_src.maxCombinedImageSamplerDescriptorCount;
+    fragmentShadingRateClampCombinerInputs = copy_src.fragmentShadingRateClampCombinerInputs;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMaintenance6PropertiesKHR& safe_VkPhysicalDeviceMaintenance6PropertiesKHR::operator=(
+    const safe_VkPhysicalDeviceMaintenance6PropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    blockTexelViewCompatibleMultipleLayers = copy_src.blockTexelViewCompatibleMultipleLayers;
+    maxCombinedImageSamplerDescriptorCount = copy_src.maxCombinedImageSamplerDescriptorCount;
+    fragmentShadingRateClampCombinerInputs = copy_src.fragmentShadingRateClampCombinerInputs;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMaintenance6PropertiesKHR::~safe_VkPhysicalDeviceMaintenance6PropertiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceMaintenance6PropertiesKHR::initialize(const VkPhysicalDeviceMaintenance6PropertiesKHR* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    blockTexelViewCompatibleMultipleLayers = in_struct->blockTexelViewCompatibleMultipleLayers;
+    maxCombinedImageSamplerDescriptorCount = in_struct->maxCombinedImageSamplerDescriptorCount;
+    fragmentShadingRateClampCombinerInputs = in_struct->fragmentShadingRateClampCombinerInputs;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMaintenance6PropertiesKHR::initialize(const safe_VkPhysicalDeviceMaintenance6PropertiesKHR* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    blockTexelViewCompatibleMultipleLayers = copy_src->blockTexelViewCompatibleMultipleLayers;
+    maxCombinedImageSamplerDescriptorCount = copy_src->maxCombinedImageSamplerDescriptorCount;
+    fragmentShadingRateClampCombinerInputs = copy_src->fragmentShadingRateClampCombinerInputs;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkBindMemoryStatusKHR::safe_VkBindMemoryStatusKHR(const VkBindMemoryStatusKHR* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), pResult(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pResult) {
+        pResult = new VkResult(*in_struct->pResult);
+    }
+}
+
+safe_VkBindMemoryStatusKHR::safe_VkBindMemoryStatusKHR()
+    : sType(VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR), pNext(nullptr), pResult(nullptr) {}
+
+safe_VkBindMemoryStatusKHR::safe_VkBindMemoryStatusKHR(const safe_VkBindMemoryStatusKHR& copy_src) {
+    sType = copy_src.sType;
+    pResult = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pResult) {
+        pResult = new VkResult(*copy_src.pResult);
+    }
+}
+
+safe_VkBindMemoryStatusKHR& safe_VkBindMemoryStatusKHR::operator=(const safe_VkBindMemoryStatusKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pResult) delete pResult;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pResult = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pResult) {
+        pResult = new VkResult(*copy_src.pResult);
+    }
+
+    return *this;
+}
+
+safe_VkBindMemoryStatusKHR::~safe_VkBindMemoryStatusKHR() {
+    if (pResult) delete pResult;
+    FreePnextChain(pNext);
+}
+
+void safe_VkBindMemoryStatusKHR::initialize(const VkBindMemoryStatusKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pResult) delete pResult;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pResult = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pResult) {
+        pResult = new VkResult(*in_struct->pResult);
+    }
+}
+
+void safe_VkBindMemoryStatusKHR::initialize(const safe_VkBindMemoryStatusKHR* copy_src,
+                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pResult = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pResult) {
+        pResult = new VkResult(*copy_src->pResult);
+    }
+}
+
+safe_VkBindDescriptorSetsInfoKHR::safe_VkBindDescriptorSetsInfoKHR(const VkBindDescriptorSetsInfoKHR* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      stageFlags(in_struct->stageFlags),
+      layout(in_struct->layout),
+      firstSet(in_struct->firstSet),
+      descriptorSetCount(in_struct->descriptorSetCount),
+      pDescriptorSets(nullptr),
+      dynamicOffsetCount(in_struct->dynamicOffsetCount),
+      pDynamicOffsets(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (descriptorSetCount && in_struct->pDescriptorSets) {
+        pDescriptorSets = new VkDescriptorSet[descriptorSetCount];
+        for (uint32_t i = 0; i < descriptorSetCount; ++i) {
+            pDescriptorSets[i] = in_struct->pDescriptorSets[i];
+        }
+    }
+
+    if (in_struct->pDynamicOffsets) {
+        pDynamicOffsets = new uint32_t[in_struct->dynamicOffsetCount];
+        memcpy((void*)pDynamicOffsets, (void*)in_struct->pDynamicOffsets, sizeof(uint32_t) * in_struct->dynamicOffsetCount);
+    }
+}
+
+safe_VkBindDescriptorSetsInfoKHR::safe_VkBindDescriptorSetsInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR),
+      pNext(nullptr),
+      stageFlags(),
+      layout(),
+      firstSet(),
+      descriptorSetCount(),
+      pDescriptorSets(nullptr),
+      dynamicOffsetCount(),
+      pDynamicOffsets(nullptr) {}
+
+safe_VkBindDescriptorSetsInfoKHR::safe_VkBindDescriptorSetsInfoKHR(const safe_VkBindDescriptorSetsInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    stageFlags = copy_src.stageFlags;
+    layout = copy_src.layout;
+    firstSet = copy_src.firstSet;
+    descriptorSetCount = copy_src.descriptorSetCount;
+    pDescriptorSets = nullptr;
+    dynamicOffsetCount = copy_src.dynamicOffsetCount;
+    pDynamicOffsets = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (descriptorSetCount && copy_src.pDescriptorSets) {
+        pDescriptorSets = new VkDescriptorSet[descriptorSetCount];
+        for (uint32_t i = 0; i < descriptorSetCount; ++i) {
+            pDescriptorSets[i] = copy_src.pDescriptorSets[i];
+        }
+    }
+
+    if (copy_src.pDynamicOffsets) {
+        pDynamicOffsets = new uint32_t[copy_src.dynamicOffsetCount];
+        memcpy((void*)pDynamicOffsets, (void*)copy_src.pDynamicOffsets, sizeof(uint32_t) * copy_src.dynamicOffsetCount);
+    }
+}
+
+safe_VkBindDescriptorSetsInfoKHR& safe_VkBindDescriptorSetsInfoKHR::operator=(const safe_VkBindDescriptorSetsInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pDescriptorSets) delete[] pDescriptorSets;
+    if (pDynamicOffsets) delete[] pDynamicOffsets;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    stageFlags = copy_src.stageFlags;
+    layout = copy_src.layout;
+    firstSet = copy_src.firstSet;
+    descriptorSetCount = copy_src.descriptorSetCount;
+    pDescriptorSets = nullptr;
+    dynamicOffsetCount = copy_src.dynamicOffsetCount;
+    pDynamicOffsets = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (descriptorSetCount && copy_src.pDescriptorSets) {
+        pDescriptorSets = new VkDescriptorSet[descriptorSetCount];
+        for (uint32_t i = 0; i < descriptorSetCount; ++i) {
+            pDescriptorSets[i] = copy_src.pDescriptorSets[i];
+        }
+    }
+
+    if (copy_src.pDynamicOffsets) {
+        pDynamicOffsets = new uint32_t[copy_src.dynamicOffsetCount];
+        memcpy((void*)pDynamicOffsets, (void*)copy_src.pDynamicOffsets, sizeof(uint32_t) * copy_src.dynamicOffsetCount);
+    }
+
+    return *this;
+}
+
+safe_VkBindDescriptorSetsInfoKHR::~safe_VkBindDescriptorSetsInfoKHR() {
+    if (pDescriptorSets) delete[] pDescriptorSets;
+    if (pDynamicOffsets) delete[] pDynamicOffsets;
+    FreePnextChain(pNext);
+}
+
+void safe_VkBindDescriptorSetsInfoKHR::initialize(const VkBindDescriptorSetsInfoKHR* in_struct,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pDescriptorSets) delete[] pDescriptorSets;
+    if (pDynamicOffsets) delete[] pDynamicOffsets;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    stageFlags = in_struct->stageFlags;
+    layout = in_struct->layout;
+    firstSet = in_struct->firstSet;
+    descriptorSetCount = in_struct->descriptorSetCount;
+    pDescriptorSets = nullptr;
+    dynamicOffsetCount = in_struct->dynamicOffsetCount;
+    pDynamicOffsets = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (descriptorSetCount && in_struct->pDescriptorSets) {
+        pDescriptorSets = new VkDescriptorSet[descriptorSetCount];
+        for (uint32_t i = 0; i < descriptorSetCount; ++i) {
+            pDescriptorSets[i] = in_struct->pDescriptorSets[i];
+        }
+    }
+
+    if (in_struct->pDynamicOffsets) {
+        pDynamicOffsets = new uint32_t[in_struct->dynamicOffsetCount];
+        memcpy((void*)pDynamicOffsets, (void*)in_struct->pDynamicOffsets, sizeof(uint32_t) * in_struct->dynamicOffsetCount);
+    }
+}
+
+void safe_VkBindDescriptorSetsInfoKHR::initialize(const safe_VkBindDescriptorSetsInfoKHR* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stageFlags = copy_src->stageFlags;
+    layout = copy_src->layout;
+    firstSet = copy_src->firstSet;
+    descriptorSetCount = copy_src->descriptorSetCount;
+    pDescriptorSets = nullptr;
+    dynamicOffsetCount = copy_src->dynamicOffsetCount;
+    pDynamicOffsets = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (descriptorSetCount && copy_src->pDescriptorSets) {
+        pDescriptorSets = new VkDescriptorSet[descriptorSetCount];
+        for (uint32_t i = 0; i < descriptorSetCount; ++i) {
+            pDescriptorSets[i] = copy_src->pDescriptorSets[i];
+        }
+    }
+
+    if (copy_src->pDynamicOffsets) {
+        pDynamicOffsets = new uint32_t[copy_src->dynamicOffsetCount];
+        memcpy((void*)pDynamicOffsets, (void*)copy_src->pDynamicOffsets, sizeof(uint32_t) * copy_src->dynamicOffsetCount);
+    }
+}
+
+safe_VkPushConstantsInfoKHR::safe_VkPushConstantsInfoKHR(const VkPushConstantsInfoKHR* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      layout(in_struct->layout),
+      stageFlags(in_struct->stageFlags),
+      offset(in_struct->offset),
+      size(in_struct->size),
+      pValues(in_struct->pValues) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPushConstantsInfoKHR::safe_VkPushConstantsInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR),
+      pNext(nullptr),
+      layout(),
+      stageFlags(),
+      offset(),
+      size(),
+      pValues(nullptr) {}
+
+safe_VkPushConstantsInfoKHR::safe_VkPushConstantsInfoKHR(const safe_VkPushConstantsInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    layout = copy_src.layout;
+    stageFlags = copy_src.stageFlags;
+    offset = copy_src.offset;
+    size = copy_src.size;
+    pValues = copy_src.pValues;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPushConstantsInfoKHR& safe_VkPushConstantsInfoKHR::operator=(const safe_VkPushConstantsInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    layout = copy_src.layout;
+    stageFlags = copy_src.stageFlags;
+    offset = copy_src.offset;
+    size = copy_src.size;
+    pValues = copy_src.pValues;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPushConstantsInfoKHR::~safe_VkPushConstantsInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkPushConstantsInfoKHR::initialize(const VkPushConstantsInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    layout = in_struct->layout;
+    stageFlags = in_struct->stageFlags;
+    offset = in_struct->offset;
+    size = in_struct->size;
+    pValues = in_struct->pValues;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPushConstantsInfoKHR::initialize(const safe_VkPushConstantsInfoKHR* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    layout = copy_src->layout;
+    stageFlags = copy_src->stageFlags;
+    offset = copy_src->offset;
+    size = copy_src->size;
+    pValues = copy_src->pValues;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPushDescriptorSetInfoKHR::safe_VkPushDescriptorSetInfoKHR(const VkPushDescriptorSetInfoKHR* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      stageFlags(in_struct->stageFlags),
+      layout(in_struct->layout),
+      set(in_struct->set),
+      descriptorWriteCount(in_struct->descriptorWriteCount),
+      pDescriptorWrites(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (descriptorWriteCount && in_struct->pDescriptorWrites) {
+        pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount];
+        for (uint32_t i = 0; i < descriptorWriteCount; ++i) {
+            pDescriptorWrites[i].initialize(&in_struct->pDescriptorWrites[i]);
+        }
+    }
+}
+
+safe_VkPushDescriptorSetInfoKHR::safe_VkPushDescriptorSetInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR),
+      pNext(nullptr),
+      stageFlags(),
+      layout(),
+      set(),
+      descriptorWriteCount(),
+      pDescriptorWrites(nullptr) {}
+
+safe_VkPushDescriptorSetInfoKHR::safe_VkPushDescriptorSetInfoKHR(const safe_VkPushDescriptorSetInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    stageFlags = copy_src.stageFlags;
+    layout = copy_src.layout;
+    set = copy_src.set;
+    descriptorWriteCount = copy_src.descriptorWriteCount;
+    pDescriptorWrites = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (descriptorWriteCount && copy_src.pDescriptorWrites) {
+        pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount];
+        for (uint32_t i = 0; i < descriptorWriteCount; ++i) {
+            pDescriptorWrites[i].initialize(&copy_src.pDescriptorWrites[i]);
+        }
+    }
+}
+
+safe_VkPushDescriptorSetInfoKHR& safe_VkPushDescriptorSetInfoKHR::operator=(const safe_VkPushDescriptorSetInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pDescriptorWrites) delete[] pDescriptorWrites;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    stageFlags = copy_src.stageFlags;
+    layout = copy_src.layout;
+    set = copy_src.set;
+    descriptorWriteCount = copy_src.descriptorWriteCount;
+    pDescriptorWrites = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (descriptorWriteCount && copy_src.pDescriptorWrites) {
+        pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount];
+        for (uint32_t i = 0; i < descriptorWriteCount; ++i) {
+            pDescriptorWrites[i].initialize(&copy_src.pDescriptorWrites[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkPushDescriptorSetInfoKHR::~safe_VkPushDescriptorSetInfoKHR() {
+    if (pDescriptorWrites) delete[] pDescriptorWrites;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPushDescriptorSetInfoKHR::initialize(const VkPushDescriptorSetInfoKHR* in_struct,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pDescriptorWrites) delete[] pDescriptorWrites;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    stageFlags = in_struct->stageFlags;
+    layout = in_struct->layout;
+    set = in_struct->set;
+    descriptorWriteCount = in_struct->descriptorWriteCount;
+    pDescriptorWrites = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (descriptorWriteCount && in_struct->pDescriptorWrites) {
+        pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount];
+        for (uint32_t i = 0; i < descriptorWriteCount; ++i) {
+            pDescriptorWrites[i].initialize(&in_struct->pDescriptorWrites[i]);
+        }
+    }
+}
+
+void safe_VkPushDescriptorSetInfoKHR::initialize(const safe_VkPushDescriptorSetInfoKHR* copy_src,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stageFlags = copy_src->stageFlags;
+    layout = copy_src->layout;
+    set = copy_src->set;
+    descriptorWriteCount = copy_src->descriptorWriteCount;
+    pDescriptorWrites = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (descriptorWriteCount && copy_src->pDescriptorWrites) {
+        pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount];
+        for (uint32_t i = 0; i < descriptorWriteCount; ++i) {
+            pDescriptorWrites[i].initialize(&copy_src->pDescriptorWrites[i]);
+        }
+    }
+}
+
+safe_VkPushDescriptorSetWithTemplateInfoKHR::safe_VkPushDescriptorSetWithTemplateInfoKHR(
+    const VkPushDescriptorSetWithTemplateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      descriptorUpdateTemplate(in_struct->descriptorUpdateTemplate),
+      layout(in_struct->layout),
+      set(in_struct->set),
+      pData(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPushDescriptorSetWithTemplateInfoKHR::safe_VkPushDescriptorSetWithTemplateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR),
+      pNext(nullptr),
+      descriptorUpdateTemplate(),
+      layout(),
+      set(),
+      pData(nullptr) {}
+
+safe_VkPushDescriptorSetWithTemplateInfoKHR::safe_VkPushDescriptorSetWithTemplateInfoKHR(
+    const safe_VkPushDescriptorSetWithTemplateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    descriptorUpdateTemplate = copy_src.descriptorUpdateTemplate;
+    layout = copy_src.layout;
+    set = copy_src.set;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPushDescriptorSetWithTemplateInfoKHR& safe_VkPushDescriptorSetWithTemplateInfoKHR::operator=(
+    const safe_VkPushDescriptorSetWithTemplateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pData != nullptr) {
+        auto temp = reinterpret_cast<const std::byte*>(pData);
+        delete[] temp;
+    }
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    descriptorUpdateTemplate = copy_src.descriptorUpdateTemplate;
+    layout = copy_src.layout;
+    set = copy_src.set;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPushDescriptorSetWithTemplateInfoKHR::~safe_VkPushDescriptorSetWithTemplateInfoKHR() {
+    if (pData != nullptr) {
+        auto temp = reinterpret_cast<const std::byte*>(pData);
+        delete[] temp;
+    }
+    FreePnextChain(pNext);
+}
+
+void safe_VkPushDescriptorSetWithTemplateInfoKHR::initialize(const VkPushDescriptorSetWithTemplateInfoKHR* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pData != nullptr) {
+        auto temp = reinterpret_cast<const std::byte*>(pData);
+        delete[] temp;
+    }
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    descriptorUpdateTemplate = in_struct->descriptorUpdateTemplate;
+    layout = in_struct->layout;
+    set = in_struct->set;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPushDescriptorSetWithTemplateInfoKHR::initialize(const safe_VkPushDescriptorSetWithTemplateInfoKHR* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    descriptorUpdateTemplate = copy_src->descriptorUpdateTemplate;
+    layout = copy_src->layout;
+    set = copy_src->set;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDeviceOrHostAddressConstKHR::safe_VkDeviceOrHostAddressConstKHR(const VkDeviceOrHostAddressConstKHR* in_struct,
+                                                                       PNextCopyState*) {
+    initialize(in_struct);
+}
+
+safe_VkDeviceOrHostAddressConstKHR::safe_VkDeviceOrHostAddressConstKHR() : hostAddress(nullptr) {}
+
+safe_VkDeviceOrHostAddressConstKHR::safe_VkDeviceOrHostAddressConstKHR(const safe_VkDeviceOrHostAddressConstKHR& copy_src) {
+    deviceAddress = copy_src.deviceAddress;
+    hostAddress = copy_src.hostAddress;
+}
+
+safe_VkDeviceOrHostAddressConstKHR& safe_VkDeviceOrHostAddressConstKHR::operator=(
+    const safe_VkDeviceOrHostAddressConstKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    deviceAddress = copy_src.deviceAddress;
+    hostAddress = copy_src.hostAddress;
+
+    return *this;
+}
+
+safe_VkDeviceOrHostAddressConstKHR::~safe_VkDeviceOrHostAddressConstKHR() {}
+
+void safe_VkDeviceOrHostAddressConstKHR::initialize(const VkDeviceOrHostAddressConstKHR* in_struct,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    deviceAddress = in_struct->deviceAddress;
+    hostAddress = in_struct->hostAddress;
+}
+
+void safe_VkDeviceOrHostAddressConstKHR::initialize(const safe_VkDeviceOrHostAddressConstKHR* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    deviceAddress = copy_src->deviceAddress;
+    hostAddress = copy_src->hostAddress;
+}
+
+safe_VkDeviceOrHostAddressKHR::safe_VkDeviceOrHostAddressKHR(const VkDeviceOrHostAddressKHR* in_struct, PNextCopyState*) {
+    initialize(in_struct);
+}
+
+safe_VkDeviceOrHostAddressKHR::safe_VkDeviceOrHostAddressKHR() : hostAddress(nullptr) {}
+
+safe_VkDeviceOrHostAddressKHR::safe_VkDeviceOrHostAddressKHR(const safe_VkDeviceOrHostAddressKHR& copy_src) {
+    deviceAddress = copy_src.deviceAddress;
+    hostAddress = copy_src.hostAddress;
+}
+
+safe_VkDeviceOrHostAddressKHR& safe_VkDeviceOrHostAddressKHR::operator=(const safe_VkDeviceOrHostAddressKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    deviceAddress = copy_src.deviceAddress;
+    hostAddress = copy_src.hostAddress;
+
+    return *this;
+}
+
+safe_VkDeviceOrHostAddressKHR::~safe_VkDeviceOrHostAddressKHR() {}
+
+void safe_VkDeviceOrHostAddressKHR::initialize(const VkDeviceOrHostAddressKHR* in_struct,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    deviceAddress = in_struct->deviceAddress;
+    hostAddress = in_struct->hostAddress;
+}
+
+void safe_VkDeviceOrHostAddressKHR::initialize(const safe_VkDeviceOrHostAddressKHR* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    deviceAddress = copy_src->deviceAddress;
+    hostAddress = copy_src->hostAddress;
+}
+
+safe_VkAccelerationStructureGeometryTrianglesDataKHR::safe_VkAccelerationStructureGeometryTrianglesDataKHR(
+    const VkAccelerationStructureGeometryTrianglesDataKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      vertexFormat(in_struct->vertexFormat),
+      vertexData(&in_struct->vertexData),
+      vertexStride(in_struct->vertexStride),
+      maxVertex(in_struct->maxVertex),
+      indexType(in_struct->indexType),
+      indexData(&in_struct->indexData),
+      transformData(&in_struct->transformData) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkAccelerationStructureGeometryTrianglesDataKHR::safe_VkAccelerationStructureGeometryTrianglesDataKHR()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR),
+      pNext(nullptr),
+      vertexFormat(),
+      vertexStride(),
+      maxVertex(),
+      indexType() {}
+
+safe_VkAccelerationStructureGeometryTrianglesDataKHR::safe_VkAccelerationStructureGeometryTrianglesDataKHR(
+    const safe_VkAccelerationStructureGeometryTrianglesDataKHR& copy_src) {
+    sType = copy_src.sType;
+    vertexFormat = copy_src.vertexFormat;
+    vertexData.initialize(&copy_src.vertexData);
+    vertexStride = copy_src.vertexStride;
+    maxVertex = copy_src.maxVertex;
+    indexType = copy_src.indexType;
+    indexData.initialize(&copy_src.indexData);
+    transformData.initialize(&copy_src.transformData);
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkAccelerationStructureGeometryTrianglesDataKHR& safe_VkAccelerationStructureGeometryTrianglesDataKHR::operator=(
+    const safe_VkAccelerationStructureGeometryTrianglesDataKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    vertexFormat = copy_src.vertexFormat;
+    vertexData.initialize(&copy_src.vertexData);
+    vertexStride = copy_src.vertexStride;
+    maxVertex = copy_src.maxVertex;
+    indexType = copy_src.indexType;
+    indexData.initialize(&copy_src.indexData);
+    transformData.initialize(&copy_src.transformData);
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkAccelerationStructureGeometryTrianglesDataKHR::~safe_VkAccelerationStructureGeometryTrianglesDataKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkAccelerationStructureGeometryTrianglesDataKHR::initialize(
+    const VkAccelerationStructureGeometryTrianglesDataKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    vertexFormat = in_struct->vertexFormat;
+    vertexData.initialize(&in_struct->vertexData);
+    vertexStride = in_struct->vertexStride;
+    maxVertex = in_struct->maxVertex;
+    indexType = in_struct->indexType;
+    indexData.initialize(&in_struct->indexData);
+    transformData.initialize(&in_struct->transformData);
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkAccelerationStructureGeometryTrianglesDataKHR::initialize(
+    const safe_VkAccelerationStructureGeometryTrianglesDataKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    vertexFormat = copy_src->vertexFormat;
+    vertexData.initialize(&copy_src->vertexData);
+    vertexStride = copy_src->vertexStride;
+    maxVertex = copy_src->maxVertex;
+    indexType = copy_src->indexType;
+    indexData.initialize(&copy_src->indexData);
+    transformData.initialize(&copy_src->transformData);
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkAccelerationStructureGeometryAabbsDataKHR::safe_VkAccelerationStructureGeometryAabbsDataKHR(
+    const VkAccelerationStructureGeometryAabbsDataKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), data(&in_struct->data), stride(in_struct->stride) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkAccelerationStructureGeometryAabbsDataKHR::safe_VkAccelerationStructureGeometryAabbsDataKHR()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR), pNext(nullptr), stride() {}
+
+safe_VkAccelerationStructureGeometryAabbsDataKHR::safe_VkAccelerationStructureGeometryAabbsDataKHR(
+    const safe_VkAccelerationStructureGeometryAabbsDataKHR& copy_src) {
+    sType = copy_src.sType;
+    data.initialize(&copy_src.data);
+    stride = copy_src.stride;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkAccelerationStructureGeometryAabbsDataKHR& safe_VkAccelerationStructureGeometryAabbsDataKHR::operator=(
+    const safe_VkAccelerationStructureGeometryAabbsDataKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    data.initialize(&copy_src.data);
+    stride = copy_src.stride;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkAccelerationStructureGeometryAabbsDataKHR::~safe_VkAccelerationStructureGeometryAabbsDataKHR() { FreePnextChain(pNext); }
+
+void safe_VkAccelerationStructureGeometryAabbsDataKHR::initialize(const VkAccelerationStructureGeometryAabbsDataKHR* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    data.initialize(&in_struct->data);
+    stride = in_struct->stride;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkAccelerationStructureGeometryAabbsDataKHR::initialize(const safe_VkAccelerationStructureGeometryAabbsDataKHR* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    data.initialize(&copy_src->data);
+    stride = copy_src->stride;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkAccelerationStructureGeometryInstancesDataKHR::safe_VkAccelerationStructureGeometryInstancesDataKHR(
+    const VkAccelerationStructureGeometryInstancesDataKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), arrayOfPointers(in_struct->arrayOfPointers), data(&in_struct->data) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkAccelerationStructureGeometryInstancesDataKHR::safe_VkAccelerationStructureGeometryInstancesDataKHR()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR), pNext(nullptr), arrayOfPointers() {}
+
+safe_VkAccelerationStructureGeometryInstancesDataKHR::safe_VkAccelerationStructureGeometryInstancesDataKHR(
+    const safe_VkAccelerationStructureGeometryInstancesDataKHR& copy_src) {
+    sType = copy_src.sType;
+    arrayOfPointers = copy_src.arrayOfPointers;
+    data.initialize(&copy_src.data);
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkAccelerationStructureGeometryInstancesDataKHR& safe_VkAccelerationStructureGeometryInstancesDataKHR::operator=(
+    const safe_VkAccelerationStructureGeometryInstancesDataKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    arrayOfPointers = copy_src.arrayOfPointers;
+    data.initialize(&copy_src.data);
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkAccelerationStructureGeometryInstancesDataKHR::~safe_VkAccelerationStructureGeometryInstancesDataKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkAccelerationStructureGeometryInstancesDataKHR::initialize(
+    const VkAccelerationStructureGeometryInstancesDataKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    arrayOfPointers = in_struct->arrayOfPointers;
+    data.initialize(&in_struct->data);
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkAccelerationStructureGeometryInstancesDataKHR::initialize(
+    const safe_VkAccelerationStructureGeometryInstancesDataKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    arrayOfPointers = copy_src->arrayOfPointers;
+    data.initialize(&copy_src->data);
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkAccelerationStructureCreateInfoKHR::safe_VkAccelerationStructureCreateInfoKHR(
+    const VkAccelerationStructureCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      createFlags(in_struct->createFlags),
+      buffer(in_struct->buffer),
+      offset(in_struct->offset),
+      size(in_struct->size),
+      type(in_struct->type),
+      deviceAddress(in_struct->deviceAddress) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkAccelerationStructureCreateInfoKHR::safe_VkAccelerationStructureCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR),
+      pNext(nullptr),
+      createFlags(),
+      buffer(),
+      offset(),
+      size(),
+      type(),
+      deviceAddress() {}
+
+safe_VkAccelerationStructureCreateInfoKHR::safe_VkAccelerationStructureCreateInfoKHR(
+    const safe_VkAccelerationStructureCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    createFlags = copy_src.createFlags;
+    buffer = copy_src.buffer;
+    offset = copy_src.offset;
+    size = copy_src.size;
+    type = copy_src.type;
+    deviceAddress = copy_src.deviceAddress;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkAccelerationStructureCreateInfoKHR& safe_VkAccelerationStructureCreateInfoKHR::operator=(
+    const safe_VkAccelerationStructureCreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    createFlags = copy_src.createFlags;
+    buffer = copy_src.buffer;
+    offset = copy_src.offset;
+    size = copy_src.size;
+    type = copy_src.type;
+    deviceAddress = copy_src.deviceAddress;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkAccelerationStructureCreateInfoKHR::~safe_VkAccelerationStructureCreateInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkAccelerationStructureCreateInfoKHR::initialize(const VkAccelerationStructureCreateInfoKHR* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    createFlags = in_struct->createFlags;
+    buffer = in_struct->buffer;
+    offset = in_struct->offset;
+    size = in_struct->size;
+    type = in_struct->type;
+    deviceAddress = in_struct->deviceAddress;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkAccelerationStructureCreateInfoKHR::initialize(const safe_VkAccelerationStructureCreateInfoKHR* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    createFlags = copy_src->createFlags;
+    buffer = copy_src->buffer;
+    offset = copy_src->offset;
+    size = copy_src->size;
+    type = copy_src->type;
+    deviceAddress = copy_src->deviceAddress;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkWriteDescriptorSetAccelerationStructureKHR::safe_VkWriteDescriptorSetAccelerationStructureKHR(
+    const VkWriteDescriptorSetAccelerationStructureKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), accelerationStructureCount(in_struct->accelerationStructureCount), pAccelerationStructures(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (accelerationStructureCount && in_struct->pAccelerationStructures) {
+        pAccelerationStructures = new VkAccelerationStructureKHR[accelerationStructureCount];
+        for (uint32_t i = 0; i < accelerationStructureCount; ++i) {
+            pAccelerationStructures[i] = in_struct->pAccelerationStructures[i];
+        }
+    }
+}
+
+safe_VkWriteDescriptorSetAccelerationStructureKHR::safe_VkWriteDescriptorSetAccelerationStructureKHR()
+    : sType(VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR),
+      pNext(nullptr),
+      accelerationStructureCount(),
+      pAccelerationStructures(nullptr) {}
+
+safe_VkWriteDescriptorSetAccelerationStructureKHR::safe_VkWriteDescriptorSetAccelerationStructureKHR(
+    const safe_VkWriteDescriptorSetAccelerationStructureKHR& copy_src) {
+    sType = copy_src.sType;
+    accelerationStructureCount = copy_src.accelerationStructureCount;
+    pAccelerationStructures = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (accelerationStructureCount && copy_src.pAccelerationStructures) {
+        pAccelerationStructures = new VkAccelerationStructureKHR[accelerationStructureCount];
+        for (uint32_t i = 0; i < accelerationStructureCount; ++i) {
+            pAccelerationStructures[i] = copy_src.pAccelerationStructures[i];
+        }
+    }
+}
+
+safe_VkWriteDescriptorSetAccelerationStructureKHR& safe_VkWriteDescriptorSetAccelerationStructureKHR::operator=(
+    const safe_VkWriteDescriptorSetAccelerationStructureKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pAccelerationStructures) delete[] pAccelerationStructures;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    accelerationStructureCount = copy_src.accelerationStructureCount;
+    pAccelerationStructures = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (accelerationStructureCount && copy_src.pAccelerationStructures) {
+        pAccelerationStructures = new VkAccelerationStructureKHR[accelerationStructureCount];
+        for (uint32_t i = 0; i < accelerationStructureCount; ++i) {
+            pAccelerationStructures[i] = copy_src.pAccelerationStructures[i];
+        }
+    }
+
+    return *this;
+}
+
+safe_VkWriteDescriptorSetAccelerationStructureKHR::~safe_VkWriteDescriptorSetAccelerationStructureKHR() {
+    if (pAccelerationStructures) delete[] pAccelerationStructures;
+    FreePnextChain(pNext);
+}
+
+void safe_VkWriteDescriptorSetAccelerationStructureKHR::initialize(const VkWriteDescriptorSetAccelerationStructureKHR* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pAccelerationStructures) delete[] pAccelerationStructures;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    accelerationStructureCount = in_struct->accelerationStructureCount;
+    pAccelerationStructures = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (accelerationStructureCount && in_struct->pAccelerationStructures) {
+        pAccelerationStructures = new VkAccelerationStructureKHR[accelerationStructureCount];
+        for (uint32_t i = 0; i < accelerationStructureCount; ++i) {
+            pAccelerationStructures[i] = in_struct->pAccelerationStructures[i];
+        }
+    }
+}
+
+void safe_VkWriteDescriptorSetAccelerationStructureKHR::initialize(
+    const safe_VkWriteDescriptorSetAccelerationStructureKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    accelerationStructureCount = copy_src->accelerationStructureCount;
+    pAccelerationStructures = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (accelerationStructureCount && copy_src->pAccelerationStructures) {
+        pAccelerationStructures = new VkAccelerationStructureKHR[accelerationStructureCount];
+        for (uint32_t i = 0; i < accelerationStructureCount; ++i) {
+            pAccelerationStructures[i] = copy_src->pAccelerationStructures[i];
+        }
+    }
+}
+
+safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR::safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
+    const VkPhysicalDeviceAccelerationStructureFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      accelerationStructure(in_struct->accelerationStructure),
+      accelerationStructureCaptureReplay(in_struct->accelerationStructureCaptureReplay),
+      accelerationStructureIndirectBuild(in_struct->accelerationStructureIndirectBuild),
+      accelerationStructureHostCommands(in_struct->accelerationStructureHostCommands),
+      descriptorBindingAccelerationStructureUpdateAfterBind(in_struct->descriptorBindingAccelerationStructureUpdateAfterBind) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR::safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR),
+      pNext(nullptr),
+      accelerationStructure(),
+      accelerationStructureCaptureReplay(),
+      accelerationStructureIndirectBuild(),
+      accelerationStructureHostCommands(),
+      descriptorBindingAccelerationStructureUpdateAfterBind() {}
+
+safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR::safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
+    const safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    accelerationStructure = copy_src.accelerationStructure;
+    accelerationStructureCaptureReplay = copy_src.accelerationStructureCaptureReplay;
+    accelerationStructureIndirectBuild = copy_src.accelerationStructureIndirectBuild;
+    accelerationStructureHostCommands = copy_src.accelerationStructureHostCommands;
+    descriptorBindingAccelerationStructureUpdateAfterBind = copy_src.descriptorBindingAccelerationStructureUpdateAfterBind;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR& safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    accelerationStructure = copy_src.accelerationStructure;
+    accelerationStructureCaptureReplay = copy_src.accelerationStructureCaptureReplay;
+    accelerationStructureIndirectBuild = copy_src.accelerationStructureIndirectBuild;
+    accelerationStructureHostCommands = copy_src.accelerationStructureHostCommands;
+    descriptorBindingAccelerationStructureUpdateAfterBind = copy_src.descriptorBindingAccelerationStructureUpdateAfterBind;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR::~safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR::initialize(
+    const VkPhysicalDeviceAccelerationStructureFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    accelerationStructure = in_struct->accelerationStructure;
+    accelerationStructureCaptureReplay = in_struct->accelerationStructureCaptureReplay;
+    accelerationStructureIndirectBuild = in_struct->accelerationStructureIndirectBuild;
+    accelerationStructureHostCommands = in_struct->accelerationStructureHostCommands;
+    descriptorBindingAccelerationStructureUpdateAfterBind = in_struct->descriptorBindingAccelerationStructureUpdateAfterBind;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR::initialize(
+    const safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    accelerationStructure = copy_src->accelerationStructure;
+    accelerationStructureCaptureReplay = copy_src->accelerationStructureCaptureReplay;
+    accelerationStructureIndirectBuild = copy_src->accelerationStructureIndirectBuild;
+    accelerationStructureHostCommands = copy_src->accelerationStructureHostCommands;
+    descriptorBindingAccelerationStructureUpdateAfterBind = copy_src->descriptorBindingAccelerationStructureUpdateAfterBind;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR::safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
+    const VkPhysicalDeviceAccelerationStructurePropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      maxGeometryCount(in_struct->maxGeometryCount),
+      maxInstanceCount(in_struct->maxInstanceCount),
+      maxPrimitiveCount(in_struct->maxPrimitiveCount),
+      maxPerStageDescriptorAccelerationStructures(in_struct->maxPerStageDescriptorAccelerationStructures),
+      maxPerStageDescriptorUpdateAfterBindAccelerationStructures(
+          in_struct->maxPerStageDescriptorUpdateAfterBindAccelerationStructures),
+      maxDescriptorSetAccelerationStructures(in_struct->maxDescriptorSetAccelerationStructures),
+      maxDescriptorSetUpdateAfterBindAccelerationStructures(in_struct->maxDescriptorSetUpdateAfterBindAccelerationStructures),
+      minAccelerationStructureScratchOffsetAlignment(in_struct->minAccelerationStructureScratchOffsetAlignment) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR::safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR),
+      pNext(nullptr),
+      maxGeometryCount(),
+      maxInstanceCount(),
+      maxPrimitiveCount(),
+      maxPerStageDescriptorAccelerationStructures(),
+      maxPerStageDescriptorUpdateAfterBindAccelerationStructures(),
+      maxDescriptorSetAccelerationStructures(),
+      maxDescriptorSetUpdateAfterBindAccelerationStructures(),
+      minAccelerationStructureScratchOffsetAlignment() {}
+
+safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR::safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
+    const safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    maxGeometryCount = copy_src.maxGeometryCount;
+    maxInstanceCount = copy_src.maxInstanceCount;
+    maxPrimitiveCount = copy_src.maxPrimitiveCount;
+    maxPerStageDescriptorAccelerationStructures = copy_src.maxPerStageDescriptorAccelerationStructures;
+    maxPerStageDescriptorUpdateAfterBindAccelerationStructures =
+        copy_src.maxPerStageDescriptorUpdateAfterBindAccelerationStructures;
+    maxDescriptorSetAccelerationStructures = copy_src.maxDescriptorSetAccelerationStructures;
+    maxDescriptorSetUpdateAfterBindAccelerationStructures = copy_src.maxDescriptorSetUpdateAfterBindAccelerationStructures;
+    minAccelerationStructureScratchOffsetAlignment = copy_src.minAccelerationStructureScratchOffsetAlignment;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR& safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR::operator=(
+    const safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxGeometryCount = copy_src.maxGeometryCount;
+    maxInstanceCount = copy_src.maxInstanceCount;
+    maxPrimitiveCount = copy_src.maxPrimitiveCount;
+    maxPerStageDescriptorAccelerationStructures = copy_src.maxPerStageDescriptorAccelerationStructures;
+    maxPerStageDescriptorUpdateAfterBindAccelerationStructures =
+        copy_src.maxPerStageDescriptorUpdateAfterBindAccelerationStructures;
+    maxDescriptorSetAccelerationStructures = copy_src.maxDescriptorSetAccelerationStructures;
+    maxDescriptorSetUpdateAfterBindAccelerationStructures = copy_src.maxDescriptorSetUpdateAfterBindAccelerationStructures;
+    minAccelerationStructureScratchOffsetAlignment = copy_src.minAccelerationStructureScratchOffsetAlignment;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR::~safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR::initialize(
+    const VkPhysicalDeviceAccelerationStructurePropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxGeometryCount = in_struct->maxGeometryCount;
+    maxInstanceCount = in_struct->maxInstanceCount;
+    maxPrimitiveCount = in_struct->maxPrimitiveCount;
+    maxPerStageDescriptorAccelerationStructures = in_struct->maxPerStageDescriptorAccelerationStructures;
+    maxPerStageDescriptorUpdateAfterBindAccelerationStructures =
+        in_struct->maxPerStageDescriptorUpdateAfterBindAccelerationStructures;
+    maxDescriptorSetAccelerationStructures = in_struct->maxDescriptorSetAccelerationStructures;
+    maxDescriptorSetUpdateAfterBindAccelerationStructures = in_struct->maxDescriptorSetUpdateAfterBindAccelerationStructures;
+    minAccelerationStructureScratchOffsetAlignment = in_struct->minAccelerationStructureScratchOffsetAlignment;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR::initialize(
+    const safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxGeometryCount = copy_src->maxGeometryCount;
+    maxInstanceCount = copy_src->maxInstanceCount;
+    maxPrimitiveCount = copy_src->maxPrimitiveCount;
+    maxPerStageDescriptorAccelerationStructures = copy_src->maxPerStageDescriptorAccelerationStructures;
+    maxPerStageDescriptorUpdateAfterBindAccelerationStructures =
+        copy_src->maxPerStageDescriptorUpdateAfterBindAccelerationStructures;
+    maxDescriptorSetAccelerationStructures = copy_src->maxDescriptorSetAccelerationStructures;
+    maxDescriptorSetUpdateAfterBindAccelerationStructures = copy_src->maxDescriptorSetUpdateAfterBindAccelerationStructures;
+    minAccelerationStructureScratchOffsetAlignment = copy_src->minAccelerationStructureScratchOffsetAlignment;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkAccelerationStructureDeviceAddressInfoKHR::safe_VkAccelerationStructureDeviceAddressInfoKHR(
+    const VkAccelerationStructureDeviceAddressInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), accelerationStructure(in_struct->accelerationStructure) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkAccelerationStructureDeviceAddressInfoKHR::safe_VkAccelerationStructureDeviceAddressInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR), pNext(nullptr), accelerationStructure() {}
+
+safe_VkAccelerationStructureDeviceAddressInfoKHR::safe_VkAccelerationStructureDeviceAddressInfoKHR(
+    const safe_VkAccelerationStructureDeviceAddressInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    accelerationStructure = copy_src.accelerationStructure;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkAccelerationStructureDeviceAddressInfoKHR& safe_VkAccelerationStructureDeviceAddressInfoKHR::operator=(
+    const safe_VkAccelerationStructureDeviceAddressInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    accelerationStructure = copy_src.accelerationStructure;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkAccelerationStructureDeviceAddressInfoKHR::~safe_VkAccelerationStructureDeviceAddressInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkAccelerationStructureDeviceAddressInfoKHR::initialize(const VkAccelerationStructureDeviceAddressInfoKHR* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    accelerationStructure = in_struct->accelerationStructure;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkAccelerationStructureDeviceAddressInfoKHR::initialize(const safe_VkAccelerationStructureDeviceAddressInfoKHR* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    accelerationStructure = copy_src->accelerationStructure;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkAccelerationStructureVersionInfoKHR::safe_VkAccelerationStructureVersionInfoKHR(
+    const VkAccelerationStructureVersionInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), pVersionData(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pVersionData) {
+        pVersionData = new uint8_t[2 * VK_UUID_SIZE];
+        memcpy((void*)pVersionData, (void*)in_struct->pVersionData, sizeof(uint8_t) * 2 * VK_UUID_SIZE);
+    }
+}
+
+safe_VkAccelerationStructureVersionInfoKHR::safe_VkAccelerationStructureVersionInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR), pNext(nullptr), pVersionData(nullptr) {}
+
+safe_VkAccelerationStructureVersionInfoKHR::safe_VkAccelerationStructureVersionInfoKHR(
+    const safe_VkAccelerationStructureVersionInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pVersionData = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pVersionData) {
+        pVersionData = new uint8_t[2 * VK_UUID_SIZE];
+        memcpy((void*)pVersionData, (void*)copy_src.pVersionData, sizeof(uint8_t) * 2 * VK_UUID_SIZE);
+    }
+}
+
+safe_VkAccelerationStructureVersionInfoKHR& safe_VkAccelerationStructureVersionInfoKHR::operator=(
+    const safe_VkAccelerationStructureVersionInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pVersionData) delete[] pVersionData;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pVersionData = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pVersionData) {
+        pVersionData = new uint8_t[2 * VK_UUID_SIZE];
+        memcpy((void*)pVersionData, (void*)copy_src.pVersionData, sizeof(uint8_t) * 2 * VK_UUID_SIZE);
+    }
+
+    return *this;
+}
+
+safe_VkAccelerationStructureVersionInfoKHR::~safe_VkAccelerationStructureVersionInfoKHR() {
+    if (pVersionData) delete[] pVersionData;
+    FreePnextChain(pNext);
+}
+
+void safe_VkAccelerationStructureVersionInfoKHR::initialize(const VkAccelerationStructureVersionInfoKHR* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pVersionData) delete[] pVersionData;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pVersionData = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pVersionData) {
+        pVersionData = new uint8_t[2 * VK_UUID_SIZE];
+        memcpy((void*)pVersionData, (void*)in_struct->pVersionData, sizeof(uint8_t) * 2 * VK_UUID_SIZE);
+    }
+}
+
+void safe_VkAccelerationStructureVersionInfoKHR::initialize(const safe_VkAccelerationStructureVersionInfoKHR* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pVersionData = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pVersionData) {
+        pVersionData = new uint8_t[2 * VK_UUID_SIZE];
+        memcpy((void*)pVersionData, (void*)copy_src->pVersionData, sizeof(uint8_t) * 2 * VK_UUID_SIZE);
+    }
+}
+
+safe_VkCopyAccelerationStructureToMemoryInfoKHR::safe_VkCopyAccelerationStructureToMemoryInfoKHR(
+    const VkCopyAccelerationStructureToMemoryInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), src(in_struct->src), dst(&in_struct->dst), mode(in_struct->mode) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkCopyAccelerationStructureToMemoryInfoKHR::safe_VkCopyAccelerationStructureToMemoryInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR), pNext(nullptr), src(), mode() {}
+
+safe_VkCopyAccelerationStructureToMemoryInfoKHR::safe_VkCopyAccelerationStructureToMemoryInfoKHR(
+    const safe_VkCopyAccelerationStructureToMemoryInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    src = copy_src.src;
+    dst.initialize(&copy_src.dst);
+    mode = copy_src.mode;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkCopyAccelerationStructureToMemoryInfoKHR& safe_VkCopyAccelerationStructureToMemoryInfoKHR::operator=(
+    const safe_VkCopyAccelerationStructureToMemoryInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    src = copy_src.src;
+    dst.initialize(&copy_src.dst);
+    mode = copy_src.mode;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkCopyAccelerationStructureToMemoryInfoKHR::~safe_VkCopyAccelerationStructureToMemoryInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkCopyAccelerationStructureToMemoryInfoKHR::initialize(const VkCopyAccelerationStructureToMemoryInfoKHR* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    src = in_struct->src;
+    dst.initialize(&in_struct->dst);
+    mode = in_struct->mode;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkCopyAccelerationStructureToMemoryInfoKHR::initialize(const safe_VkCopyAccelerationStructureToMemoryInfoKHR* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    src = copy_src->src;
+    dst.initialize(&copy_src->dst);
+    mode = copy_src->mode;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkCopyMemoryToAccelerationStructureInfoKHR::safe_VkCopyMemoryToAccelerationStructureInfoKHR(
+    const VkCopyMemoryToAccelerationStructureInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), src(&in_struct->src), dst(in_struct->dst), mode(in_struct->mode) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkCopyMemoryToAccelerationStructureInfoKHR::safe_VkCopyMemoryToAccelerationStructureInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR), pNext(nullptr), dst(), mode() {}
+
+safe_VkCopyMemoryToAccelerationStructureInfoKHR::safe_VkCopyMemoryToAccelerationStructureInfoKHR(
+    const safe_VkCopyMemoryToAccelerationStructureInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    src.initialize(&copy_src.src);
+    dst = copy_src.dst;
+    mode = copy_src.mode;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkCopyMemoryToAccelerationStructureInfoKHR& safe_VkCopyMemoryToAccelerationStructureInfoKHR::operator=(
+    const safe_VkCopyMemoryToAccelerationStructureInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    src.initialize(&copy_src.src);
+    dst = copy_src.dst;
+    mode = copy_src.mode;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkCopyMemoryToAccelerationStructureInfoKHR::~safe_VkCopyMemoryToAccelerationStructureInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkCopyMemoryToAccelerationStructureInfoKHR::initialize(const VkCopyMemoryToAccelerationStructureInfoKHR* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    src.initialize(&in_struct->src);
+    dst = in_struct->dst;
+    mode = in_struct->mode;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkCopyMemoryToAccelerationStructureInfoKHR::initialize(const safe_VkCopyMemoryToAccelerationStructureInfoKHR* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    src.initialize(&copy_src->src);
+    dst = copy_src->dst;
+    mode = copy_src->mode;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkCopyAccelerationStructureInfoKHR::safe_VkCopyAccelerationStructureInfoKHR(
+    const VkCopyAccelerationStructureInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), src(in_struct->src), dst(in_struct->dst), mode(in_struct->mode) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkCopyAccelerationStructureInfoKHR::safe_VkCopyAccelerationStructureInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR), pNext(nullptr), src(), dst(), mode() {}
+
+safe_VkCopyAccelerationStructureInfoKHR::safe_VkCopyAccelerationStructureInfoKHR(
+    const safe_VkCopyAccelerationStructureInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    src = copy_src.src;
+    dst = copy_src.dst;
+    mode = copy_src.mode;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkCopyAccelerationStructureInfoKHR& safe_VkCopyAccelerationStructureInfoKHR::operator=(
+    const safe_VkCopyAccelerationStructureInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    src = copy_src.src;
+    dst = copy_src.dst;
+    mode = copy_src.mode;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkCopyAccelerationStructureInfoKHR::~safe_VkCopyAccelerationStructureInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkCopyAccelerationStructureInfoKHR::initialize(const VkCopyAccelerationStructureInfoKHR* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    src = in_struct->src;
+    dst = in_struct->dst;
+    mode = in_struct->mode;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkCopyAccelerationStructureInfoKHR::initialize(const safe_VkCopyAccelerationStructureInfoKHR* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    src = copy_src->src;
+    dst = copy_src->dst;
+    mode = copy_src->mode;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkAccelerationStructureBuildSizesInfoKHR::safe_VkAccelerationStructureBuildSizesInfoKHR(
+    const VkAccelerationStructureBuildSizesInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      accelerationStructureSize(in_struct->accelerationStructureSize),
+      updateScratchSize(in_struct->updateScratchSize),
+      buildScratchSize(in_struct->buildScratchSize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkAccelerationStructureBuildSizesInfoKHR::safe_VkAccelerationStructureBuildSizesInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR),
+      pNext(nullptr),
+      accelerationStructureSize(),
+      updateScratchSize(),
+      buildScratchSize() {}
+
+safe_VkAccelerationStructureBuildSizesInfoKHR::safe_VkAccelerationStructureBuildSizesInfoKHR(
+    const safe_VkAccelerationStructureBuildSizesInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    accelerationStructureSize = copy_src.accelerationStructureSize;
+    updateScratchSize = copy_src.updateScratchSize;
+    buildScratchSize = copy_src.buildScratchSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkAccelerationStructureBuildSizesInfoKHR& safe_VkAccelerationStructureBuildSizesInfoKHR::operator=(
+    const safe_VkAccelerationStructureBuildSizesInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    accelerationStructureSize = copy_src.accelerationStructureSize;
+    updateScratchSize = copy_src.updateScratchSize;
+    buildScratchSize = copy_src.buildScratchSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkAccelerationStructureBuildSizesInfoKHR::~safe_VkAccelerationStructureBuildSizesInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkAccelerationStructureBuildSizesInfoKHR::initialize(const VkAccelerationStructureBuildSizesInfoKHR* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    accelerationStructureSize = in_struct->accelerationStructureSize;
+    updateScratchSize = in_struct->updateScratchSize;
+    buildScratchSize = in_struct->buildScratchSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkAccelerationStructureBuildSizesInfoKHR::initialize(const safe_VkAccelerationStructureBuildSizesInfoKHR* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    accelerationStructureSize = copy_src->accelerationStructureSize;
+    updateScratchSize = copy_src->updateScratchSize;
+    buildScratchSize = copy_src->buildScratchSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkRayTracingShaderGroupCreateInfoKHR::safe_VkRayTracingShaderGroupCreateInfoKHR(
+    const VkRayTracingShaderGroupCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      type(in_struct->type),
+      generalShader(in_struct->generalShader),
+      closestHitShader(in_struct->closestHitShader),
+      anyHitShader(in_struct->anyHitShader),
+      intersectionShader(in_struct->intersectionShader),
+      pShaderGroupCaptureReplayHandle(in_struct->pShaderGroupCaptureReplayHandle) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkRayTracingShaderGroupCreateInfoKHR::safe_VkRayTracingShaderGroupCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR),
+      pNext(nullptr),
+      type(),
+      generalShader(),
+      closestHitShader(),
+      anyHitShader(),
+      intersectionShader(),
+      pShaderGroupCaptureReplayHandle(nullptr) {}
+
+safe_VkRayTracingShaderGroupCreateInfoKHR::safe_VkRayTracingShaderGroupCreateInfoKHR(
+    const safe_VkRayTracingShaderGroupCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    type = copy_src.type;
+    generalShader = copy_src.generalShader;
+    closestHitShader = copy_src.closestHitShader;
+    anyHitShader = copy_src.anyHitShader;
+    intersectionShader = copy_src.intersectionShader;
+    pShaderGroupCaptureReplayHandle = copy_src.pShaderGroupCaptureReplayHandle;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkRayTracingShaderGroupCreateInfoKHR& safe_VkRayTracingShaderGroupCreateInfoKHR::operator=(
+    const safe_VkRayTracingShaderGroupCreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    type = copy_src.type;
+    generalShader = copy_src.generalShader;
+    closestHitShader = copy_src.closestHitShader;
+    anyHitShader = copy_src.anyHitShader;
+    intersectionShader = copy_src.intersectionShader;
+    pShaderGroupCaptureReplayHandle = copy_src.pShaderGroupCaptureReplayHandle;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkRayTracingShaderGroupCreateInfoKHR::~safe_VkRayTracingShaderGroupCreateInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkRayTracingShaderGroupCreateInfoKHR::initialize(const VkRayTracingShaderGroupCreateInfoKHR* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    type = in_struct->type;
+    generalShader = in_struct->generalShader;
+    closestHitShader = in_struct->closestHitShader;
+    anyHitShader = in_struct->anyHitShader;
+    intersectionShader = in_struct->intersectionShader;
+    pShaderGroupCaptureReplayHandle = in_struct->pShaderGroupCaptureReplayHandle;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkRayTracingShaderGroupCreateInfoKHR::initialize(const safe_VkRayTracingShaderGroupCreateInfoKHR* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    type = copy_src->type;
+    generalShader = copy_src->generalShader;
+    closestHitShader = copy_src->closestHitShader;
+    anyHitShader = copy_src->anyHitShader;
+    intersectionShader = copy_src->intersectionShader;
+    pShaderGroupCaptureReplayHandle = copy_src->pShaderGroupCaptureReplayHandle;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkRayTracingPipelineInterfaceCreateInfoKHR::safe_VkRayTracingPipelineInterfaceCreateInfoKHR(
+    const VkRayTracingPipelineInterfaceCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      maxPipelineRayPayloadSize(in_struct->maxPipelineRayPayloadSize),
+      maxPipelineRayHitAttributeSize(in_struct->maxPipelineRayHitAttributeSize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkRayTracingPipelineInterfaceCreateInfoKHR::safe_VkRayTracingPipelineInterfaceCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR),
+      pNext(nullptr),
+      maxPipelineRayPayloadSize(),
+      maxPipelineRayHitAttributeSize() {}
+
+safe_VkRayTracingPipelineInterfaceCreateInfoKHR::safe_VkRayTracingPipelineInterfaceCreateInfoKHR(
+    const safe_VkRayTracingPipelineInterfaceCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    maxPipelineRayPayloadSize = copy_src.maxPipelineRayPayloadSize;
+    maxPipelineRayHitAttributeSize = copy_src.maxPipelineRayHitAttributeSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkRayTracingPipelineInterfaceCreateInfoKHR& safe_VkRayTracingPipelineInterfaceCreateInfoKHR::operator=(
+    const safe_VkRayTracingPipelineInterfaceCreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxPipelineRayPayloadSize = copy_src.maxPipelineRayPayloadSize;
+    maxPipelineRayHitAttributeSize = copy_src.maxPipelineRayHitAttributeSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkRayTracingPipelineInterfaceCreateInfoKHR::~safe_VkRayTracingPipelineInterfaceCreateInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkRayTracingPipelineInterfaceCreateInfoKHR::initialize(const VkRayTracingPipelineInterfaceCreateInfoKHR* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxPipelineRayPayloadSize = in_struct->maxPipelineRayPayloadSize;
+    maxPipelineRayHitAttributeSize = in_struct->maxPipelineRayHitAttributeSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkRayTracingPipelineInterfaceCreateInfoKHR::initialize(const safe_VkRayTracingPipelineInterfaceCreateInfoKHR* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxPipelineRayPayloadSize = copy_src->maxPipelineRayPayloadSize;
+    maxPipelineRayHitAttributeSize = copy_src->maxPipelineRayHitAttributeSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkRayTracingPipelineCreateInfoKHR::safe_VkRayTracingPipelineCreateInfoKHR(const VkRayTracingPipelineCreateInfoKHR* in_struct,
+                                                                               [[maybe_unused]] PNextCopyState* copy_state,
+                                                                               bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      stageCount(in_struct->stageCount),
+      pStages(nullptr),
+      groupCount(in_struct->groupCount),
+      pGroups(nullptr),
+      maxPipelineRayRecursionDepth(in_struct->maxPipelineRayRecursionDepth),
+      pLibraryInfo(nullptr),
+      pLibraryInterface(nullptr),
+      pDynamicState(nullptr),
+      layout(in_struct->layout),
+      basePipelineHandle(in_struct->basePipelineHandle),
+      basePipelineIndex(in_struct->basePipelineIndex) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (stageCount && in_struct->pStages) {
+        pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&in_struct->pStages[i]);
+        }
+    }
+    if (groupCount && in_struct->pGroups) {
+        pGroups = new safe_VkRayTracingShaderGroupCreateInfoKHR[groupCount];
+        for (uint32_t i = 0; i < groupCount; ++i) {
+            pGroups[i].initialize(&in_struct->pGroups[i]);
+        }
+    }
+    if (in_struct->pLibraryInfo) pLibraryInfo = new safe_VkPipelineLibraryCreateInfoKHR(in_struct->pLibraryInfo);
+    if (in_struct->pLibraryInterface)
+        pLibraryInterface = new safe_VkRayTracingPipelineInterfaceCreateInfoKHR(in_struct->pLibraryInterface);
+    if (in_struct->pDynamicState) pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(in_struct->pDynamicState);
+}
+
+safe_VkRayTracingPipelineCreateInfoKHR::safe_VkRayTracingPipelineCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR),
+      pNext(nullptr),
+      flags(),
+      stageCount(),
+      pStages(nullptr),
+      groupCount(),
+      pGroups(nullptr),
+      maxPipelineRayRecursionDepth(),
+      pLibraryInfo(nullptr),
+      pLibraryInterface(nullptr),
+      pDynamicState(nullptr),
+      layout(),
+      basePipelineHandle(),
+      basePipelineIndex() {}
+
+safe_VkRayTracingPipelineCreateInfoKHR::safe_VkRayTracingPipelineCreateInfoKHR(
+    const safe_VkRayTracingPipelineCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    stageCount = copy_src.stageCount;
+    pStages = nullptr;
+    groupCount = copy_src.groupCount;
+    pGroups = nullptr;
+    maxPipelineRayRecursionDepth = copy_src.maxPipelineRayRecursionDepth;
+    pLibraryInfo = nullptr;
+    pLibraryInterface = nullptr;
+    pDynamicState = nullptr;
+    layout = copy_src.layout;
+    basePipelineHandle = copy_src.basePipelineHandle;
+    basePipelineIndex = copy_src.basePipelineIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (stageCount && copy_src.pStages) {
+        pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&copy_src.pStages[i]);
+        }
+    }
+    if (groupCount && copy_src.pGroups) {
+        pGroups = new safe_VkRayTracingShaderGroupCreateInfoKHR[groupCount];
+        for (uint32_t i = 0; i < groupCount; ++i) {
+            pGroups[i].initialize(&copy_src.pGroups[i]);
+        }
+    }
+    if (copy_src.pLibraryInfo) pLibraryInfo = new safe_VkPipelineLibraryCreateInfoKHR(*copy_src.pLibraryInfo);
+    if (copy_src.pLibraryInterface)
+        pLibraryInterface = new safe_VkRayTracingPipelineInterfaceCreateInfoKHR(*copy_src.pLibraryInterface);
+    if (copy_src.pDynamicState) pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(*copy_src.pDynamicState);
+}
+
+safe_VkRayTracingPipelineCreateInfoKHR& safe_VkRayTracingPipelineCreateInfoKHR::operator=(
+    const safe_VkRayTracingPipelineCreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pStages) delete[] pStages;
+    if (pGroups) delete[] pGroups;
+    if (pLibraryInfo) delete pLibraryInfo;
+    if (pLibraryInterface) delete pLibraryInterface;
+    if (pDynamicState) delete pDynamicState;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    stageCount = copy_src.stageCount;
+    pStages = nullptr;
+    groupCount = copy_src.groupCount;
+    pGroups = nullptr;
+    maxPipelineRayRecursionDepth = copy_src.maxPipelineRayRecursionDepth;
+    pLibraryInfo = nullptr;
+    pLibraryInterface = nullptr;
+    pDynamicState = nullptr;
+    layout = copy_src.layout;
+    basePipelineHandle = copy_src.basePipelineHandle;
+    basePipelineIndex = copy_src.basePipelineIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (stageCount && copy_src.pStages) {
+        pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&copy_src.pStages[i]);
+        }
+    }
+    if (groupCount && copy_src.pGroups) {
+        pGroups = new safe_VkRayTracingShaderGroupCreateInfoKHR[groupCount];
+        for (uint32_t i = 0; i < groupCount; ++i) {
+            pGroups[i].initialize(&copy_src.pGroups[i]);
+        }
+    }
+    if (copy_src.pLibraryInfo) pLibraryInfo = new safe_VkPipelineLibraryCreateInfoKHR(*copy_src.pLibraryInfo);
+    if (copy_src.pLibraryInterface)
+        pLibraryInterface = new safe_VkRayTracingPipelineInterfaceCreateInfoKHR(*copy_src.pLibraryInterface);
+    if (copy_src.pDynamicState) pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(*copy_src.pDynamicState);
+
+    return *this;
+}
+
+safe_VkRayTracingPipelineCreateInfoKHR::~safe_VkRayTracingPipelineCreateInfoKHR() {
+    if (pStages) delete[] pStages;
+    if (pGroups) delete[] pGroups;
+    if (pLibraryInfo) delete pLibraryInfo;
+    if (pLibraryInterface) delete pLibraryInterface;
+    if (pDynamicState) delete pDynamicState;
+    FreePnextChain(pNext);
+}
+
+void safe_VkRayTracingPipelineCreateInfoKHR::initialize(const VkRayTracingPipelineCreateInfoKHR* in_struct,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pStages) delete[] pStages;
+    if (pGroups) delete[] pGroups;
+    if (pLibraryInfo) delete pLibraryInfo;
+    if (pLibraryInterface) delete pLibraryInterface;
+    if (pDynamicState) delete pDynamicState;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    stageCount = in_struct->stageCount;
+    pStages = nullptr;
+    groupCount = in_struct->groupCount;
+    pGroups = nullptr;
+    maxPipelineRayRecursionDepth = in_struct->maxPipelineRayRecursionDepth;
+    pLibraryInfo = nullptr;
+    pLibraryInterface = nullptr;
+    pDynamicState = nullptr;
+    layout = in_struct->layout;
+    basePipelineHandle = in_struct->basePipelineHandle;
+    basePipelineIndex = in_struct->basePipelineIndex;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (stageCount && in_struct->pStages) {
+        pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&in_struct->pStages[i]);
+        }
+    }
+    if (groupCount && in_struct->pGroups) {
+        pGroups = new safe_VkRayTracingShaderGroupCreateInfoKHR[groupCount];
+        for (uint32_t i = 0; i < groupCount; ++i) {
+            pGroups[i].initialize(&in_struct->pGroups[i]);
+        }
+    }
+    if (in_struct->pLibraryInfo) pLibraryInfo = new safe_VkPipelineLibraryCreateInfoKHR(in_struct->pLibraryInfo);
+    if (in_struct->pLibraryInterface)
+        pLibraryInterface = new safe_VkRayTracingPipelineInterfaceCreateInfoKHR(in_struct->pLibraryInterface);
+    if (in_struct->pDynamicState) pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(in_struct->pDynamicState);
+}
+
+void safe_VkRayTracingPipelineCreateInfoKHR::initialize(const safe_VkRayTracingPipelineCreateInfoKHR* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    stageCount = copy_src->stageCount;
+    pStages = nullptr;
+    groupCount = copy_src->groupCount;
+    pGroups = nullptr;
+    maxPipelineRayRecursionDepth = copy_src->maxPipelineRayRecursionDepth;
+    pLibraryInfo = nullptr;
+    pLibraryInterface = nullptr;
+    pDynamicState = nullptr;
+    layout = copy_src->layout;
+    basePipelineHandle = copy_src->basePipelineHandle;
+    basePipelineIndex = copy_src->basePipelineIndex;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (stageCount && copy_src->pStages) {
+        pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&copy_src->pStages[i]);
+        }
+    }
+    if (groupCount && copy_src->pGroups) {
+        pGroups = new safe_VkRayTracingShaderGroupCreateInfoKHR[groupCount];
+        for (uint32_t i = 0; i < groupCount; ++i) {
+            pGroups[i].initialize(&copy_src->pGroups[i]);
+        }
+    }
+    if (copy_src->pLibraryInfo) pLibraryInfo = new safe_VkPipelineLibraryCreateInfoKHR(*copy_src->pLibraryInfo);
+    if (copy_src->pLibraryInterface)
+        pLibraryInterface = new safe_VkRayTracingPipelineInterfaceCreateInfoKHR(*copy_src->pLibraryInterface);
+    if (copy_src->pDynamicState) pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(*copy_src->pDynamicState);
+}
+
+safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR::safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
+    const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      rayTracingPipeline(in_struct->rayTracingPipeline),
+      rayTracingPipelineShaderGroupHandleCaptureReplay(in_struct->rayTracingPipelineShaderGroupHandleCaptureReplay),
+      rayTracingPipelineShaderGroupHandleCaptureReplayMixed(in_struct->rayTracingPipelineShaderGroupHandleCaptureReplayMixed),
+      rayTracingPipelineTraceRaysIndirect(in_struct->rayTracingPipelineTraceRaysIndirect),
+      rayTraversalPrimitiveCulling(in_struct->rayTraversalPrimitiveCulling) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR::safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR),
+      pNext(nullptr),
+      rayTracingPipeline(),
+      rayTracingPipelineShaderGroupHandleCaptureReplay(),
+      rayTracingPipelineShaderGroupHandleCaptureReplayMixed(),
+      rayTracingPipelineTraceRaysIndirect(),
+      rayTraversalPrimitiveCulling() {}
+
+safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR::safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
+    const safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    rayTracingPipeline = copy_src.rayTracingPipeline;
+    rayTracingPipelineShaderGroupHandleCaptureReplay = copy_src.rayTracingPipelineShaderGroupHandleCaptureReplay;
+    rayTracingPipelineShaderGroupHandleCaptureReplayMixed = copy_src.rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
+    rayTracingPipelineTraceRaysIndirect = copy_src.rayTracingPipelineTraceRaysIndirect;
+    rayTraversalPrimitiveCulling = copy_src.rayTraversalPrimitiveCulling;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR& safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    rayTracingPipeline = copy_src.rayTracingPipeline;
+    rayTracingPipelineShaderGroupHandleCaptureReplay = copy_src.rayTracingPipelineShaderGroupHandleCaptureReplay;
+    rayTracingPipelineShaderGroupHandleCaptureReplayMixed = copy_src.rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
+    rayTracingPipelineTraceRaysIndirect = copy_src.rayTracingPipelineTraceRaysIndirect;
+    rayTraversalPrimitiveCulling = copy_src.rayTraversalPrimitiveCulling;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR::~safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR::initialize(const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    rayTracingPipeline = in_struct->rayTracingPipeline;
+    rayTracingPipelineShaderGroupHandleCaptureReplay = in_struct->rayTracingPipelineShaderGroupHandleCaptureReplay;
+    rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_struct->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
+    rayTracingPipelineTraceRaysIndirect = in_struct->rayTracingPipelineTraceRaysIndirect;
+    rayTraversalPrimitiveCulling = in_struct->rayTraversalPrimitiveCulling;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR::initialize(
+    const safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    rayTracingPipeline = copy_src->rayTracingPipeline;
+    rayTracingPipelineShaderGroupHandleCaptureReplay = copy_src->rayTracingPipelineShaderGroupHandleCaptureReplay;
+    rayTracingPipelineShaderGroupHandleCaptureReplayMixed = copy_src->rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
+    rayTracingPipelineTraceRaysIndirect = copy_src->rayTracingPipelineTraceRaysIndirect;
+    rayTraversalPrimitiveCulling = copy_src->rayTraversalPrimitiveCulling;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR::safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
+    const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      shaderGroupHandleSize(in_struct->shaderGroupHandleSize),
+      maxRayRecursionDepth(in_struct->maxRayRecursionDepth),
+      maxShaderGroupStride(in_struct->maxShaderGroupStride),
+      shaderGroupBaseAlignment(in_struct->shaderGroupBaseAlignment),
+      shaderGroupHandleCaptureReplaySize(in_struct->shaderGroupHandleCaptureReplaySize),
+      maxRayDispatchInvocationCount(in_struct->maxRayDispatchInvocationCount),
+      shaderGroupHandleAlignment(in_struct->shaderGroupHandleAlignment),
+      maxRayHitAttributeSize(in_struct->maxRayHitAttributeSize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR::safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR),
+      pNext(nullptr),
+      shaderGroupHandleSize(),
+      maxRayRecursionDepth(),
+      maxShaderGroupStride(),
+      shaderGroupBaseAlignment(),
+      shaderGroupHandleCaptureReplaySize(),
+      maxRayDispatchInvocationCount(),
+      shaderGroupHandleAlignment(),
+      maxRayHitAttributeSize() {}
+
+safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR::safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
+    const safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    shaderGroupHandleSize = copy_src.shaderGroupHandleSize;
+    maxRayRecursionDepth = copy_src.maxRayRecursionDepth;
+    maxShaderGroupStride = copy_src.maxShaderGroupStride;
+    shaderGroupBaseAlignment = copy_src.shaderGroupBaseAlignment;
+    shaderGroupHandleCaptureReplaySize = copy_src.shaderGroupHandleCaptureReplaySize;
+    maxRayDispatchInvocationCount = copy_src.maxRayDispatchInvocationCount;
+    shaderGroupHandleAlignment = copy_src.shaderGroupHandleAlignment;
+    maxRayHitAttributeSize = copy_src.maxRayHitAttributeSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR& safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR::operator=(
+    const safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderGroupHandleSize = copy_src.shaderGroupHandleSize;
+    maxRayRecursionDepth = copy_src.maxRayRecursionDepth;
+    maxShaderGroupStride = copy_src.maxShaderGroupStride;
+    shaderGroupBaseAlignment = copy_src.shaderGroupBaseAlignment;
+    shaderGroupHandleCaptureReplaySize = copy_src.shaderGroupHandleCaptureReplaySize;
+    maxRayDispatchInvocationCount = copy_src.maxRayDispatchInvocationCount;
+    shaderGroupHandleAlignment = copy_src.shaderGroupHandleAlignment;
+    maxRayHitAttributeSize = copy_src.maxRayHitAttributeSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR::~safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR::initialize(
+    const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderGroupHandleSize = in_struct->shaderGroupHandleSize;
+    maxRayRecursionDepth = in_struct->maxRayRecursionDepth;
+    maxShaderGroupStride = in_struct->maxShaderGroupStride;
+    shaderGroupBaseAlignment = in_struct->shaderGroupBaseAlignment;
+    shaderGroupHandleCaptureReplaySize = in_struct->shaderGroupHandleCaptureReplaySize;
+    maxRayDispatchInvocationCount = in_struct->maxRayDispatchInvocationCount;
+    shaderGroupHandleAlignment = in_struct->shaderGroupHandleAlignment;
+    maxRayHitAttributeSize = in_struct->maxRayHitAttributeSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR::initialize(
+    const safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderGroupHandleSize = copy_src->shaderGroupHandleSize;
+    maxRayRecursionDepth = copy_src->maxRayRecursionDepth;
+    maxShaderGroupStride = copy_src->maxShaderGroupStride;
+    shaderGroupBaseAlignment = copy_src->shaderGroupBaseAlignment;
+    shaderGroupHandleCaptureReplaySize = copy_src->shaderGroupHandleCaptureReplaySize;
+    maxRayDispatchInvocationCount = copy_src->maxRayDispatchInvocationCount;
+    shaderGroupHandleAlignment = copy_src->shaderGroupHandleAlignment;
+    maxRayHitAttributeSize = copy_src->maxRayHitAttributeSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceRayQueryFeaturesKHR::safe_VkPhysicalDeviceRayQueryFeaturesKHR(
+    const VkPhysicalDeviceRayQueryFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), rayQuery(in_struct->rayQuery) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceRayQueryFeaturesKHR::safe_VkPhysicalDeviceRayQueryFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR), pNext(nullptr), rayQuery() {}
+
+safe_VkPhysicalDeviceRayQueryFeaturesKHR::safe_VkPhysicalDeviceRayQueryFeaturesKHR(
+    const safe_VkPhysicalDeviceRayQueryFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    rayQuery = copy_src.rayQuery;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceRayQueryFeaturesKHR& safe_VkPhysicalDeviceRayQueryFeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceRayQueryFeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    rayQuery = copy_src.rayQuery;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceRayQueryFeaturesKHR::~safe_VkPhysicalDeviceRayQueryFeaturesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceRayQueryFeaturesKHR::initialize(const VkPhysicalDeviceRayQueryFeaturesKHR* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    rayQuery = in_struct->rayQuery;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceRayQueryFeaturesKHR::initialize(const safe_VkPhysicalDeviceRayQueryFeaturesKHR* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    rayQuery = copy_src->rayQuery;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+}  // namespace vku
+
+// NOLINTEND
diff --git a/src/vulkan/vk_safe_struct_manual.cpp b/src/vulkan/vk_safe_struct_manual.cpp
new file mode 100644
index 0000000..4e50f8a
--- /dev/null
+++ b/src/vulkan/vk_safe_struct_manual.cpp
@@ -0,0 +1,2209 @@
+/***************************************************************************
+ *
+ * Copyright (c) 2015-2024 The Khronos Group Inc.
+ * Copyright (c) 2015-2024 Valve Corporation
+ * Copyright (c) 2015-2024 LunarG, Inc.
+ * Copyright (c) 2015-2024 Google Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ ****************************************************************************/
+
+#include <vulkan/utility/vk_safe_struct.hpp>
+#include <vulkan/utility/vk_struct_helper.hpp>
+#include <vulkan/utility/vk_concurrent_unordered_map.hpp>
+
+#include <cassert>
+#include <cstring>
+
+namespace vku {
+
+std::vector<std::pair<uint32_t, uint32_t>> custom_stype_info{};
+
+struct ASGeomKHRExtraData {
+    ASGeomKHRExtraData(uint8_t* alloc, uint32_t primOffset, uint32_t primCount)
+        : ptr(alloc), primitiveOffset(primOffset), primitiveCount(primCount) {}
+    ~ASGeomKHRExtraData() {
+        if (ptr) delete[] ptr;
+    }
+    uint8_t* ptr;
+    uint32_t primitiveOffset;
+    uint32_t primitiveCount;
+};
+
+vku::concurrent::unordered_map<const safe_VkAccelerationStructureGeometryKHR*, ASGeomKHRExtraData*, 4> as_geom_khr_host_alloc;
+
+safe_VkAccelerationStructureGeometryKHR::safe_VkAccelerationStructureGeometryKHR(
+    const VkAccelerationStructureGeometryKHR* in_struct, const bool is_host,
+    const VkAccelerationStructureBuildRangeInfoKHR* build_range_info, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), geometryType(in_struct->geometryType), geometry(in_struct->geometry), flags(in_struct->flags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (is_host && geometryType == VK_GEOMETRY_TYPE_INSTANCES_KHR) {
+        if (geometry.instances.arrayOfPointers) {
+            size_t pp_array_size = build_range_info->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR*);
+            size_t p_array_size = build_range_info->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR);
+            size_t array_size = build_range_info->primitiveOffset + pp_array_size + p_array_size;
+            uint8_t* allocation = new uint8_t[array_size];
+            VkAccelerationStructureInstanceKHR** ppInstances =
+                reinterpret_cast<VkAccelerationStructureInstanceKHR**>(allocation + build_range_info->primitiveOffset);
+            VkAccelerationStructureInstanceKHR* pInstances = reinterpret_cast<VkAccelerationStructureInstanceKHR*>(
+                allocation + build_range_info->primitiveOffset + pp_array_size);
+            for (uint32_t i = 0; i < build_range_info->primitiveCount; ++i) {
+                const uint8_t* byte_ptr = reinterpret_cast<const uint8_t*>(in_struct->geometry.instances.data.hostAddress);
+                pInstances[i] = *(
+                    reinterpret_cast<VkAccelerationStructureInstanceKHR* const*>(byte_ptr + build_range_info->primitiveOffset)[i]);
+                ppInstances[i] = &pInstances[i];
+            }
+            geometry.instances.data.hostAddress = allocation;
+            as_geom_khr_host_alloc.insert(
+                this, new ASGeomKHRExtraData(allocation, build_range_info->primitiveOffset, build_range_info->primitiveCount));
+        } else {
+            const auto primitive_offset = build_range_info->primitiveOffset;
+            const auto primitive_count = build_range_info->primitiveCount;
+            size_t array_size = primitive_offset + primitive_count * sizeof(VkAccelerationStructureInstanceKHR);
+            uint8_t* allocation = new uint8_t[array_size];
+            auto host_address = static_cast<const uint8_t*>(in_struct->geometry.instances.data.hostAddress);
+            memcpy(allocation + primitive_offset, host_address + primitive_offset,
+                   primitive_count * sizeof(VkAccelerationStructureInstanceKHR));
+            geometry.instances.data.hostAddress = allocation;
+            as_geom_khr_host_alloc.insert(
+                this, new ASGeomKHRExtraData(allocation, build_range_info->primitiveOffset, build_range_info->primitiveCount));
+        }
+    }
+}
+
+safe_VkAccelerationStructureGeometryKHR::safe_VkAccelerationStructureGeometryKHR()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR), pNext(nullptr), geometryType(), geometry(), flags() {}
+
+safe_VkAccelerationStructureGeometryKHR::safe_VkAccelerationStructureGeometryKHR(
+    const safe_VkAccelerationStructureGeometryKHR& copy_src) {
+    sType = copy_src.sType;
+    geometryType = copy_src.geometryType;
+    geometry = copy_src.geometry;
+    flags = copy_src.flags;
+
+    pNext = SafePnextCopy(copy_src.pNext);
+    auto src_iter = as_geom_khr_host_alloc.find(&copy_src);
+    if (src_iter != as_geom_khr_host_alloc.end()) {
+        auto& src_alloc = src_iter->second;
+        if (geometry.instances.arrayOfPointers) {
+            size_t pp_array_size = src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR*);
+            size_t p_array_size = src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR);
+            size_t array_size = src_alloc->primitiveOffset + pp_array_size + p_array_size;
+            uint8_t* allocation = new uint8_t[array_size];
+            VkAccelerationStructureInstanceKHR** ppInstances =
+                reinterpret_cast<VkAccelerationStructureInstanceKHR**>(allocation + src_alloc->primitiveOffset);
+            VkAccelerationStructureInstanceKHR* pInstances =
+                reinterpret_cast<VkAccelerationStructureInstanceKHR*>(allocation + src_alloc->primitiveOffset + pp_array_size);
+            for (uint32_t i = 0; i < src_alloc->primitiveCount; ++i) {
+                pInstances[i] =
+                    *(reinterpret_cast<VkAccelerationStructureInstanceKHR* const*>(src_alloc->ptr + src_alloc->primitiveOffset)[i]);
+                ppInstances[i] = &pInstances[i];
+            }
+            geometry.instances.data.hostAddress = allocation;
+            as_geom_khr_host_alloc.insert(
+                this, new ASGeomKHRExtraData(allocation, src_alloc->primitiveOffset, src_alloc->primitiveCount));
+        } else {
+            size_t array_size = src_alloc->primitiveOffset + src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR);
+            uint8_t* allocation = new uint8_t[array_size];
+            memcpy(allocation, src_alloc->ptr, array_size);
+            geometry.instances.data.hostAddress = allocation;
+            as_geom_khr_host_alloc.insert(
+                this, new ASGeomKHRExtraData(allocation, src_alloc->primitiveOffset, src_alloc->primitiveCount));
+        }
+    }
+}
+
+safe_VkAccelerationStructureGeometryKHR& safe_VkAccelerationStructureGeometryKHR::operator=(
+    const safe_VkAccelerationStructureGeometryKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    auto iter = as_geom_khr_host_alloc.pop(this);
+    if (iter != as_geom_khr_host_alloc.end()) {
+        delete iter->second;
+    }
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    geometryType = copy_src.geometryType;
+    geometry = copy_src.geometry;
+    flags = copy_src.flags;
+
+    pNext = SafePnextCopy(copy_src.pNext);
+    auto src_iter = as_geom_khr_host_alloc.find(&copy_src);
+    if (src_iter != as_geom_khr_host_alloc.end()) {
+        auto& src_alloc = src_iter->second;
+        if (geometry.instances.arrayOfPointers) {
+            size_t pp_array_size = src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR*);
+            size_t p_array_size = src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR);
+            size_t array_size = src_alloc->primitiveOffset + pp_array_size + p_array_size;
+            uint8_t* allocation = new uint8_t[array_size];
+            VkAccelerationStructureInstanceKHR** ppInstances =
+                reinterpret_cast<VkAccelerationStructureInstanceKHR**>(allocation + src_alloc->primitiveOffset);
+            VkAccelerationStructureInstanceKHR* pInstances =
+                reinterpret_cast<VkAccelerationStructureInstanceKHR*>(allocation + src_alloc->primitiveOffset + pp_array_size);
+            for (uint32_t i = 0; i < src_alloc->primitiveCount; ++i) {
+                pInstances[i] =
+                    *(reinterpret_cast<VkAccelerationStructureInstanceKHR* const*>(src_alloc->ptr + src_alloc->primitiveOffset)[i]);
+                ppInstances[i] = &pInstances[i];
+            }
+            geometry.instances.data.hostAddress = allocation;
+            as_geom_khr_host_alloc.insert(
+                this, new ASGeomKHRExtraData(allocation, src_alloc->primitiveOffset, src_alloc->primitiveCount));
+        } else {
+            size_t array_size = src_alloc->primitiveOffset + src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR);
+            uint8_t* allocation = new uint8_t[array_size];
+            memcpy(allocation, src_alloc->ptr, array_size);
+            geometry.instances.data.hostAddress = allocation;
+            as_geom_khr_host_alloc.insert(
+                this, new ASGeomKHRExtraData(allocation, src_alloc->primitiveOffset, src_alloc->primitiveCount));
+        }
+    }
+
+    return *this;
+}
+
+safe_VkAccelerationStructureGeometryKHR::~safe_VkAccelerationStructureGeometryKHR() {
+    auto iter = as_geom_khr_host_alloc.pop(this);
+    if (iter != as_geom_khr_host_alloc.end()) {
+        delete iter->second;
+    }
+    FreePnextChain(pNext);
+}
+
+void safe_VkAccelerationStructureGeometryKHR::initialize(const VkAccelerationStructureGeometryKHR* in_struct, const bool is_host,
+                                                         const VkAccelerationStructureBuildRangeInfoKHR* build_range_info,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    auto iter = as_geom_khr_host_alloc.pop(this);
+    if (iter != as_geom_khr_host_alloc.end()) {
+        delete iter->second;
+    }
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    geometryType = in_struct->geometryType;
+    geometry = in_struct->geometry;
+    flags = in_struct->flags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (is_host && geometryType == VK_GEOMETRY_TYPE_INSTANCES_KHR) {
+        if (geometry.instances.arrayOfPointers) {
+            size_t pp_array_size = build_range_info->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR*);
+            size_t p_array_size = build_range_info->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR);
+            size_t array_size = build_range_info->primitiveOffset + pp_array_size + p_array_size;
+            uint8_t* allocation = new uint8_t[array_size];
+            VkAccelerationStructureInstanceKHR** ppInstances =
+                reinterpret_cast<VkAccelerationStructureInstanceKHR**>(allocation + build_range_info->primitiveOffset);
+            VkAccelerationStructureInstanceKHR* pInstances = reinterpret_cast<VkAccelerationStructureInstanceKHR*>(
+                allocation + build_range_info->primitiveOffset + pp_array_size);
+            for (uint32_t i = 0; i < build_range_info->primitiveCount; ++i) {
+                const uint8_t* byte_ptr = reinterpret_cast<const uint8_t*>(in_struct->geometry.instances.data.hostAddress);
+                pInstances[i] = *(
+                    reinterpret_cast<VkAccelerationStructureInstanceKHR* const*>(byte_ptr + build_range_info->primitiveOffset)[i]);
+                ppInstances[i] = &pInstances[i];
+            }
+            geometry.instances.data.hostAddress = allocation;
+            as_geom_khr_host_alloc.insert(
+                this, new ASGeomKHRExtraData(allocation, build_range_info->primitiveOffset, build_range_info->primitiveCount));
+        } else {
+            const auto primitive_offset = build_range_info->primitiveOffset;
+            const auto primitive_count = build_range_info->primitiveCount;
+            size_t array_size = primitive_offset + primitive_count * sizeof(VkAccelerationStructureInstanceKHR);
+            uint8_t* allocation = new uint8_t[array_size];
+            auto host_address = static_cast<const uint8_t*>(in_struct->geometry.instances.data.hostAddress);
+            memcpy(allocation + primitive_offset, host_address + primitive_offset,
+                   primitive_count * sizeof(VkAccelerationStructureInstanceKHR));
+            geometry.instances.data.hostAddress = allocation;
+            as_geom_khr_host_alloc.insert(
+                this, new ASGeomKHRExtraData(allocation, build_range_info->primitiveOffset, build_range_info->primitiveCount));
+        }
+    }
+}
+
+void safe_VkAccelerationStructureGeometryKHR::initialize(const safe_VkAccelerationStructureGeometryKHR* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    geometryType = copy_src->geometryType;
+    geometry = copy_src->geometry;
+    flags = copy_src->flags;
+
+    pNext = SafePnextCopy(copy_src->pNext);
+    auto src_iter = as_geom_khr_host_alloc.find(copy_src);
+    if (src_iter != as_geom_khr_host_alloc.end()) {
+        auto& src_alloc = src_iter->second;
+        if (geometry.instances.arrayOfPointers) {
+            size_t pp_array_size = src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR*);
+            size_t p_array_size = src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR);
+            size_t array_size = src_alloc->primitiveOffset + pp_array_size + p_array_size;
+            uint8_t* allocation = new uint8_t[array_size];
+            VkAccelerationStructureInstanceKHR** ppInstances =
+                reinterpret_cast<VkAccelerationStructureInstanceKHR**>(allocation + src_alloc->primitiveOffset);
+            VkAccelerationStructureInstanceKHR* pInstances =
+                reinterpret_cast<VkAccelerationStructureInstanceKHR*>(allocation + src_alloc->primitiveOffset + pp_array_size);
+            for (uint32_t i = 0; i < src_alloc->primitiveCount; ++i) {
+                pInstances[i] =
+                    *(reinterpret_cast<VkAccelerationStructureInstanceKHR* const*>(src_alloc->ptr + src_alloc->primitiveOffset)[i]);
+                ppInstances[i] = &pInstances[i];
+            }
+            geometry.instances.data.hostAddress = allocation;
+            as_geom_khr_host_alloc.insert(
+                this, new ASGeomKHRExtraData(allocation, src_alloc->primitiveOffset, src_alloc->primitiveCount));
+        } else {
+            size_t array_size = src_alloc->primitiveOffset + src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR);
+            uint8_t* allocation = new uint8_t[array_size];
+            memcpy(allocation, src_alloc->ptr, array_size);
+            geometry.instances.data.hostAddress = allocation;
+            as_geom_khr_host_alloc.insert(
+                this, new ASGeomKHRExtraData(allocation, src_alloc->primitiveOffset, src_alloc->primitiveCount));
+        }
+    }
+}
+
+void safe_VkRayTracingPipelineCreateInfoCommon::initialize(const VkRayTracingPipelineCreateInfoNV* pCreateInfo) {
+    safe_VkRayTracingPipelineCreateInfoNV nvStruct;
+    nvStruct.initialize(pCreateInfo);
+
+    sType = nvStruct.sType;
+
+    // Take ownership of the pointer and null it out in nvStruct
+    pNext = nvStruct.pNext;
+    nvStruct.pNext = nullptr;
+
+    flags = nvStruct.flags;
+    stageCount = nvStruct.stageCount;
+
+    pStages = nvStruct.pStages;
+    nvStruct.pStages = nullptr;
+
+    groupCount = nvStruct.groupCount;
+    maxRecursionDepth = nvStruct.maxRecursionDepth;
+    layout = nvStruct.layout;
+    basePipelineHandle = nvStruct.basePipelineHandle;
+    basePipelineIndex = nvStruct.basePipelineIndex;
+
+    assert(pGroups == nullptr);
+    if (nvStruct.groupCount && nvStruct.pGroups) {
+        pGroups = new safe_VkRayTracingShaderGroupCreateInfoKHR[groupCount];
+        for (uint32_t i = 0; i < groupCount; ++i) {
+            pGroups[i].sType = nvStruct.pGroups[i].sType;
+            pGroups[i].pNext = nvStruct.pGroups[i].pNext;
+            pGroups[i].type = nvStruct.pGroups[i].type;
+            pGroups[i].generalShader = nvStruct.pGroups[i].generalShader;
+            pGroups[i].closestHitShader = nvStruct.pGroups[i].closestHitShader;
+            pGroups[i].anyHitShader = nvStruct.pGroups[i].anyHitShader;
+            pGroups[i].intersectionShader = nvStruct.pGroups[i].intersectionShader;
+            pGroups[i].intersectionShader = nvStruct.pGroups[i].intersectionShader;
+            pGroups[i].pShaderGroupCaptureReplayHandle = nullptr;
+        }
+    }
+}
+
+void safe_VkRayTracingPipelineCreateInfoCommon::initialize(const VkRayTracingPipelineCreateInfoKHR* pCreateInfo) {
+    safe_VkRayTracingPipelineCreateInfoKHR::initialize(pCreateInfo);
+}
+
+safe_VkDescriptorDataEXT::safe_VkDescriptorDataEXT(const VkDescriptorDataEXT* in_struct, const VkDescriptorType type,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    VkDescriptorType* pType = (VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
+
+    switch (type) {
+        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLER:
+            pSampler = new VkSampler(*in_struct->pSampler);
+            break;
+        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+            pCombinedImageSampler = new VkDescriptorImageInfo(*in_struct->pCombinedImageSampler);
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+            pSampledImage = in_struct->pSampledImage ? new VkDescriptorImageInfo(*in_struct->pSampledImage) : nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+            pStorageImage = in_struct->pStorageImage ? new VkDescriptorImageInfo(*in_struct->pStorageImage) : nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+            pInputAttachmentImage = new VkDescriptorImageInfo(*in_struct->pInputAttachmentImage);
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+            pUniformTexelBuffer =
+                in_struct->pUniformTexelBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pUniformTexelBuffer) : nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+            pStorageTexelBuffer =
+                in_struct->pStorageTexelBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pStorageTexelBuffer) : nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+            pUniformBuffer = in_struct->pUniformBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pUniformBuffer) : nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+            pStorageBuffer = in_struct->pStorageBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pStorageBuffer) : nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
+            accelerationStructure = in_struct->accelerationStructure;
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
+            accelerationStructure = in_struct->accelerationStructure;
+            break;
+        default:
+            break;
+    }
+
+    *pType = type;
+}
+
+safe_VkDescriptorDataEXT::safe_VkDescriptorDataEXT() : type_at_end{0} {
+    VkDescriptorType* pType = (VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
+    *pType = VK_DESCRIPTOR_TYPE_MAX_ENUM;
+}
+
+safe_VkDescriptorDataEXT::safe_VkDescriptorDataEXT(const safe_VkDescriptorDataEXT& copy_src) {
+    pSampler = nullptr;
+    pCombinedImageSampler = nullptr;
+    pInputAttachmentImage = nullptr;
+    pSampledImage = nullptr;
+    pStorageImage = nullptr;
+    pUniformTexelBuffer = nullptr;
+    pStorageTexelBuffer = nullptr;
+    pUniformBuffer = nullptr;
+    pStorageBuffer = nullptr;
+    accelerationStructure = copy_src.accelerationStructure;
+
+    VkDescriptorType* pType = (VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
+    VkDescriptorType type = *(VkDescriptorType*)&copy_src.type_at_end[sizeof(VkDescriptorDataEXT)];
+
+    switch (type) {
+        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLER:
+            pSampler = new VkSampler(*copy_src.pSampler);
+            break;
+        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+            pCombinedImageSampler = new VkDescriptorImageInfo(*copy_src.pCombinedImageSampler);
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+            pSampledImage = new VkDescriptorImageInfo(*copy_src.pSampledImage);
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+            pStorageImage = new VkDescriptorImageInfo(*copy_src.pStorageImage);
+            break;
+        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+            pInputAttachmentImage = new VkDescriptorImageInfo(*copy_src.pInputAttachmentImage);
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+            pUniformTexelBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pUniformTexelBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+            pStorageTexelBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pStorageTexelBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+            pUniformBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pUniformBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+            pStorageBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pStorageBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
+            accelerationStructure = copy_src.accelerationStructure;
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
+            accelerationStructure = copy_src.accelerationStructure;
+            break;
+        default:
+            break;
+    }
+
+    *pType = type;
+}
+
+safe_VkDescriptorDataEXT& safe_VkDescriptorDataEXT::operator=(const safe_VkDescriptorDataEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    VkDescriptorType& thisType = *(VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
+
+    switch (thisType) {
+        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLER:
+            delete pSampler;
+            pSampler = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+            delete pCombinedImageSampler;
+            pCombinedImageSampler = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+            delete pSampledImage;
+            pSampledImage = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+            delete pStorageImage;
+            pStorageImage = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+            delete pInputAttachmentImage;
+            pInputAttachmentImage = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+            delete pUniformTexelBuffer;
+            pUniformTexelBuffer = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+            delete pStorageTexelBuffer;
+            pStorageTexelBuffer = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+            delete pUniformBuffer;
+            pUniformBuffer = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+            delete pStorageBuffer;
+            pStorageBuffer = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
+            accelerationStructure = 0ull;
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
+            accelerationStructure = 0ull;
+            break;
+        default:
+            break;
+    }
+
+    thisType = VK_DESCRIPTOR_TYPE_MAX_ENUM;
+
+    pSampler = nullptr;
+    pCombinedImageSampler = nullptr;
+    pInputAttachmentImage = nullptr;
+    pSampledImage = nullptr;
+    pStorageImage = nullptr;
+    pUniformTexelBuffer = nullptr;
+    pStorageTexelBuffer = nullptr;
+    pUniformBuffer = nullptr;
+    pStorageBuffer = nullptr;
+    accelerationStructure = copy_src.accelerationStructure;
+
+    VkDescriptorType* pType = (VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
+    VkDescriptorType type = *(VkDescriptorType*)&copy_src.type_at_end[sizeof(VkDescriptorDataEXT)];
+
+    switch (type) {
+        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLER:
+            pSampler = new VkSampler(*copy_src.pSampler);
+            break;
+        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+            pCombinedImageSampler = new VkDescriptorImageInfo(*copy_src.pCombinedImageSampler);
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+            pSampledImage = new VkDescriptorImageInfo(*copy_src.pSampledImage);
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+            pStorageImage = new VkDescriptorImageInfo(*copy_src.pStorageImage);
+            break;
+        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+            pInputAttachmentImage = new VkDescriptorImageInfo(*copy_src.pInputAttachmentImage);
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+            pUniformTexelBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pUniformTexelBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+            pStorageTexelBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pStorageTexelBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+            pUniformBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pUniformBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+            pStorageBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pStorageBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
+            accelerationStructure = copy_src.accelerationStructure;
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
+            accelerationStructure = copy_src.accelerationStructure;
+            break;
+        default:
+            break;
+    }
+
+    *pType = type;
+
+    return *this;
+}
+
+safe_VkDescriptorDataEXT::~safe_VkDescriptorDataEXT() {
+    VkDescriptorType& thisType = *(VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
+
+    switch (thisType) {
+        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLER:
+            delete pSampler;
+            pSampler = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+            delete pCombinedImageSampler;
+            pCombinedImageSampler = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+            delete pSampledImage;
+            pSampledImage = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+            delete pStorageImage;
+            pStorageImage = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+            delete pInputAttachmentImage;
+            pInputAttachmentImage = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+            delete pUniformTexelBuffer;
+            pUniformTexelBuffer = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+            delete pStorageTexelBuffer;
+            pStorageTexelBuffer = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+            delete pUniformBuffer;
+            pUniformBuffer = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+            delete pStorageBuffer;
+            pStorageBuffer = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
+            accelerationStructure = 0ull;
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
+            accelerationStructure = 0ull;
+            break;
+        default:
+            break;
+    }
+
+    thisType = VK_DESCRIPTOR_TYPE_MAX_ENUM;
+}
+
+void safe_VkDescriptorDataEXT::initialize(const VkDescriptorDataEXT* in_struct, const VkDescriptorType type,
+                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    VkDescriptorType& thisType = *(VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
+
+    switch (thisType) {
+        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLER:
+            delete pSampler;
+            pSampler = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+            delete pCombinedImageSampler;
+            pCombinedImageSampler = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+            delete pSampledImage;
+            pSampledImage = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+            delete pStorageImage;
+            pStorageImage = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+            delete pInputAttachmentImage;
+            pInputAttachmentImage = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+            delete pUniformTexelBuffer;
+            pUniformTexelBuffer = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+            delete pStorageTexelBuffer;
+            pStorageTexelBuffer = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+            delete pUniformBuffer;
+            pUniformBuffer = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+            delete pStorageBuffer;
+            pStorageBuffer = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
+            accelerationStructure = 0ull;
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
+            accelerationStructure = 0ull;
+            break;
+        default:
+            break;
+    }
+
+    thisType = VK_DESCRIPTOR_TYPE_MAX_ENUM;
+    pSampler = nullptr;
+    pCombinedImageSampler = nullptr;
+    pInputAttachmentImage = nullptr;
+    pSampledImage = nullptr;
+    pStorageImage = nullptr;
+    pUniformTexelBuffer = nullptr;
+    pStorageTexelBuffer = nullptr;
+    pUniformBuffer = nullptr;
+    pStorageBuffer = nullptr;
+    accelerationStructure = in_struct->accelerationStructure;
+
+    VkDescriptorType* pType = (VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
+
+    switch (type) {
+        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLER:
+            pSampler = new VkSampler(*in_struct->pSampler);
+            break;
+        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+            pCombinedImageSampler = new VkDescriptorImageInfo(*in_struct->pCombinedImageSampler);
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+            pSampledImage = in_struct->pSampledImage ? new VkDescriptorImageInfo(*in_struct->pSampledImage) : nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+            pStorageImage = in_struct->pStorageImage ? new VkDescriptorImageInfo(*in_struct->pStorageImage) : nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+            pInputAttachmentImage = new VkDescriptorImageInfo(*in_struct->pInputAttachmentImage);
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+            pUniformTexelBuffer =
+                in_struct->pUniformTexelBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pUniformTexelBuffer) : nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+            pStorageTexelBuffer =
+                in_struct->pStorageTexelBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pStorageTexelBuffer) : nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+            pUniformBuffer = in_struct->pUniformBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pUniformBuffer) : nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+            pStorageBuffer = in_struct->pStorageBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pStorageBuffer) : nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
+            accelerationStructure = in_struct->accelerationStructure;
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
+            accelerationStructure = in_struct->accelerationStructure;
+            break;
+        default:
+            break;
+    }
+
+    *pType = type;
+}
+
+void safe_VkDescriptorDataEXT::initialize(const safe_VkDescriptorDataEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    pSampler = nullptr;
+    pCombinedImageSampler = nullptr;
+    pInputAttachmentImage = nullptr;
+    pSampledImage = nullptr;
+    pStorageImage = nullptr;
+    pUniformTexelBuffer = nullptr;
+    pStorageTexelBuffer = nullptr;
+    pUniformBuffer = nullptr;
+    pStorageBuffer = nullptr;
+    accelerationStructure = copy_src->accelerationStructure;
+
+    VkDescriptorType* pType = (VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
+    VkDescriptorType type = *(VkDescriptorType*)&copy_src->type_at_end[sizeof(VkDescriptorDataEXT)];
+
+    switch (type) {
+        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLER:
+            pSampler = new VkSampler(*copy_src->pSampler);
+            break;
+        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+            pCombinedImageSampler = new VkDescriptorImageInfo(*copy_src->pCombinedImageSampler);
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+            pSampledImage = new VkDescriptorImageInfo(*copy_src->pSampledImage);
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+            pStorageImage = new VkDescriptorImageInfo(*copy_src->pStorageImage);
+            break;
+        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+            pInputAttachmentImage = new VkDescriptorImageInfo(*copy_src->pInputAttachmentImage);
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+            pUniformTexelBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src->pUniformTexelBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+            pStorageTexelBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src->pStorageTexelBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+            pUniformBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src->pUniformBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+            pStorageBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src->pStorageBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
+            accelerationStructure = copy_src->accelerationStructure;
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
+            accelerationStructure = copy_src->accelerationStructure;
+            break;
+        default:
+            break;
+    }
+
+    *pType = type;
+}
+
+safe_VkGraphicsPipelineCreateInfo::safe_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo* in_struct,
+                                                                     const bool uses_color_attachment,
+                                                                     const bool uses_depthstencil_attachment,
+                                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      stageCount(in_struct->stageCount),
+      pStages(nullptr),
+      pVertexInputState(nullptr),
+      pInputAssemblyState(nullptr),
+      pTessellationState(nullptr),
+      pViewportState(nullptr),
+      pRasterizationState(nullptr),
+      pMultisampleState(nullptr),
+      pDepthStencilState(nullptr),
+      pColorBlendState(nullptr),
+      pDynamicState(nullptr),
+      layout(in_struct->layout),
+      renderPass(in_struct->renderPass),
+      subpass(in_struct->subpass),
+      basePipelineHandle(in_struct->basePipelineHandle),
+      basePipelineIndex(in_struct->basePipelineIndex) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    const bool is_graphics_library =
+        vku::FindStructInPNextChain<VkGraphicsPipelineLibraryCreateInfoEXT>(in_struct->pNext) != nullptr;
+    if (stageCount && in_struct->pStages) {
+        pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&in_struct->pStages[i]);
+        }
+    }
+    if (in_struct->pVertexInputState)
+        pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(in_struct->pVertexInputState);
+    else
+        pVertexInputState = nullptr;
+    if (in_struct->pInputAssemblyState)
+        pInputAssemblyState = new safe_VkPipelineInputAssemblyStateCreateInfo(in_struct->pInputAssemblyState);
+    else
+        pInputAssemblyState = nullptr;
+    bool has_tessellation_stage = false;
+    if (stageCount && pStages)
+        for (uint32_t i = 0; i < stageCount && !has_tessellation_stage; ++i)
+            if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT ||
+                pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)
+                has_tessellation_stage = true;
+    if (in_struct->pTessellationState && has_tessellation_stage)
+        pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(in_struct->pTessellationState);
+    else
+        pTessellationState = nullptr;  // original pTessellationState pointer ignored
+    bool is_dynamic_has_rasterization = false;
+    if (in_struct->pDynamicState && in_struct->pDynamicState->pDynamicStates) {
+        for (uint32_t i = 0; i < in_struct->pDynamicState->dynamicStateCount && !is_dynamic_has_rasterization; ++i)
+            if (in_struct->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT)
+                is_dynamic_has_rasterization = true;
+    }
+    const bool has_rasterization = in_struct->pRasterizationState
+                                       ? (is_dynamic_has_rasterization || !in_struct->pRasterizationState->rasterizerDiscardEnable)
+                                       : false;
+    if (in_struct->pViewportState && (has_rasterization || is_graphics_library)) {
+        bool is_dynamic_viewports = false;
+        bool is_dynamic_scissors = false;
+        if (in_struct->pDynamicState && in_struct->pDynamicState->pDynamicStates) {
+            for (uint32_t i = 0; i < in_struct->pDynamicState->dynamicStateCount && !is_dynamic_viewports; ++i)
+                if (in_struct->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_VIEWPORT) is_dynamic_viewports = true;
+            for (uint32_t i = 0; i < in_struct->pDynamicState->dynamicStateCount && !is_dynamic_scissors; ++i)
+                if (in_struct->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_SCISSOR) is_dynamic_scissors = true;
+        }
+        pViewportState =
+            new safe_VkPipelineViewportStateCreateInfo(in_struct->pViewportState, is_dynamic_viewports, is_dynamic_scissors);
+    } else
+        pViewportState = nullptr;  // original pViewportState pointer ignored
+    if (in_struct->pRasterizationState)
+        pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(in_struct->pRasterizationState);
+    else
+        pRasterizationState = nullptr;
+    if (in_struct->pMultisampleState && (renderPass != VK_NULL_HANDLE || has_rasterization || is_graphics_library))
+        pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(in_struct->pMultisampleState);
+    else
+        pMultisampleState = nullptr;  // original pMultisampleState pointer ignored
+    // needs a tracked subpass state uses_depthstencil_attachment
+    if (in_struct->pDepthStencilState && ((has_rasterization && uses_depthstencil_attachment) || is_graphics_library))
+        pDepthStencilState = new safe_VkPipelineDepthStencilStateCreateInfo(in_struct->pDepthStencilState);
+    else
+        pDepthStencilState = nullptr;  // original pDepthStencilState pointer ignored
+    // needs a tracked subpass state usesColorAttachment
+    if (in_struct->pColorBlendState && ((has_rasterization && uses_color_attachment) || is_graphics_library))
+        pColorBlendState = new safe_VkPipelineColorBlendStateCreateInfo(in_struct->pColorBlendState);
+    else
+        pColorBlendState = nullptr;  // original pColorBlendState pointer ignored
+    if (in_struct->pDynamicState)
+        pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(in_struct->pDynamicState);
+    else
+        pDynamicState = nullptr;
+}
+
+safe_VkGraphicsPipelineCreateInfo::safe_VkGraphicsPipelineCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      stageCount(),
+      pStages(nullptr),
+      pVertexInputState(nullptr),
+      pInputAssemblyState(nullptr),
+      pTessellationState(nullptr),
+      pViewportState(nullptr),
+      pRasterizationState(nullptr),
+      pMultisampleState(nullptr),
+      pDepthStencilState(nullptr),
+      pColorBlendState(nullptr),
+      pDynamicState(nullptr),
+      layout(),
+      renderPass(),
+      subpass(),
+      basePipelineHandle(),
+      basePipelineIndex() {}
+
+safe_VkGraphicsPipelineCreateInfo::safe_VkGraphicsPipelineCreateInfo(const safe_VkGraphicsPipelineCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    stageCount = copy_src.stageCount;
+    pStages = nullptr;
+    pVertexInputState = nullptr;
+    pInputAssemblyState = nullptr;
+    pTessellationState = nullptr;
+    pViewportState = nullptr;
+    pRasterizationState = nullptr;
+    pMultisampleState = nullptr;
+    pDepthStencilState = nullptr;
+    pColorBlendState = nullptr;
+    pDynamicState = nullptr;
+    layout = copy_src.layout;
+    renderPass = copy_src.renderPass;
+    subpass = copy_src.subpass;
+    basePipelineHandle = copy_src.basePipelineHandle;
+    basePipelineIndex = copy_src.basePipelineIndex;
+
+    pNext = SafePnextCopy(copy_src.pNext);
+    const bool is_graphics_library = vku::FindStructInPNextChain<VkGraphicsPipelineLibraryCreateInfoEXT>(copy_src.pNext);
+    if (stageCount && copy_src.pStages) {
+        pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&copy_src.pStages[i]);
+        }
+    }
+    if (copy_src.pVertexInputState)
+        pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(*copy_src.pVertexInputState);
+    else
+        pVertexInputState = nullptr;
+    if (copy_src.pInputAssemblyState)
+        pInputAssemblyState = new safe_VkPipelineInputAssemblyStateCreateInfo(*copy_src.pInputAssemblyState);
+    else
+        pInputAssemblyState = nullptr;
+    bool has_tessellation_stage = false;
+    if (stageCount && pStages)
+        for (uint32_t i = 0; i < stageCount && !has_tessellation_stage; ++i)
+            if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT ||
+                pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)
+                has_tessellation_stage = true;
+    if (copy_src.pTessellationState && has_tessellation_stage)
+        pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(*copy_src.pTessellationState);
+    else
+        pTessellationState = nullptr;  // original pTessellationState pointer ignored
+    bool is_dynamic_has_rasterization = false;
+    if (copy_src.pDynamicState && copy_src.pDynamicState->pDynamicStates) {
+        for (uint32_t i = 0; i < copy_src.pDynamicState->dynamicStateCount && !is_dynamic_has_rasterization; ++i)
+            if (copy_src.pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT)
+                is_dynamic_has_rasterization = true;
+    }
+    const bool has_rasterization = copy_src.pRasterizationState
+                                       ? (is_dynamic_has_rasterization || !copy_src.pRasterizationState->rasterizerDiscardEnable)
+                                       : false;
+    if (copy_src.pViewportState && (has_rasterization || is_graphics_library)) {
+        pViewportState = new safe_VkPipelineViewportStateCreateInfo(*copy_src.pViewportState);
+    } else
+        pViewportState = nullptr;  // original pViewportState pointer ignored
+    if (copy_src.pRasterizationState)
+        pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(*copy_src.pRasterizationState);
+    else
+        pRasterizationState = nullptr;
+    if (copy_src.pMultisampleState && (has_rasterization || is_graphics_library))
+        pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(*copy_src.pMultisampleState);
+    else
+        pMultisampleState = nullptr;  // original pMultisampleState pointer ignored
+    if (copy_src.pDepthStencilState && (has_rasterization || is_graphics_library))
+        pDepthStencilState = new safe_VkPipelineDepthStencilStateCreateInfo(*copy_src.pDepthStencilState);
+    else
+        pDepthStencilState = nullptr;  // original pDepthStencilState pointer ignored
+    if (copy_src.pColorBlendState && (has_rasterization || is_graphics_library))
+        pColorBlendState = new safe_VkPipelineColorBlendStateCreateInfo(*copy_src.pColorBlendState);
+    else
+        pColorBlendState = nullptr;  // original pColorBlendState pointer ignored
+    if (copy_src.pDynamicState)
+        pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(*copy_src.pDynamicState);
+    else
+        pDynamicState = nullptr;
+}
+
+safe_VkGraphicsPipelineCreateInfo& safe_VkGraphicsPipelineCreateInfo::operator=(const safe_VkGraphicsPipelineCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pStages) delete[] pStages;
+    if (pVertexInputState) delete pVertexInputState;
+    if (pInputAssemblyState) delete pInputAssemblyState;
+    if (pTessellationState) delete pTessellationState;
+    if (pViewportState) delete pViewportState;
+    if (pRasterizationState) delete pRasterizationState;
+    if (pMultisampleState) delete pMultisampleState;
+    if (pDepthStencilState) delete pDepthStencilState;
+    if (pColorBlendState) delete pColorBlendState;
+    if (pDynamicState) delete pDynamicState;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    stageCount = copy_src.stageCount;
+    pStages = nullptr;
+    pVertexInputState = nullptr;
+    pInputAssemblyState = nullptr;
+    pTessellationState = nullptr;
+    pViewportState = nullptr;
+    pRasterizationState = nullptr;
+    pMultisampleState = nullptr;
+    pDepthStencilState = nullptr;
+    pColorBlendState = nullptr;
+    pDynamicState = nullptr;
+    layout = copy_src.layout;
+    renderPass = copy_src.renderPass;
+    subpass = copy_src.subpass;
+    basePipelineHandle = copy_src.basePipelineHandle;
+    basePipelineIndex = copy_src.basePipelineIndex;
+
+    pNext = SafePnextCopy(copy_src.pNext);
+    const bool is_graphics_library = vku::FindStructInPNextChain<VkGraphicsPipelineLibraryCreateInfoEXT>(copy_src.pNext);
+    if (stageCount && copy_src.pStages) {
+        pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&copy_src.pStages[i]);
+        }
+    }
+    if (copy_src.pVertexInputState)
+        pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(*copy_src.pVertexInputState);
+    else
+        pVertexInputState = nullptr;
+    if (copy_src.pInputAssemblyState)
+        pInputAssemblyState = new safe_VkPipelineInputAssemblyStateCreateInfo(*copy_src.pInputAssemblyState);
+    else
+        pInputAssemblyState = nullptr;
+    bool has_tessellation_stage = false;
+    if (stageCount && pStages)
+        for (uint32_t i = 0; i < stageCount && !has_tessellation_stage; ++i)
+            if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT ||
+                pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)
+                has_tessellation_stage = true;
+    if (copy_src.pTessellationState && has_tessellation_stage)
+        pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(*copy_src.pTessellationState);
+    else
+        pTessellationState = nullptr;  // original pTessellationState pointer ignored
+    bool is_dynamic_has_rasterization = false;
+    if (copy_src.pDynamicState && copy_src.pDynamicState->pDynamicStates) {
+        for (uint32_t i = 0; i < copy_src.pDynamicState->dynamicStateCount && !is_dynamic_has_rasterization; ++i)
+            if (copy_src.pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT)
+                is_dynamic_has_rasterization = true;
+    }
+    const bool has_rasterization = copy_src.pRasterizationState
+                                       ? (is_dynamic_has_rasterization || !copy_src.pRasterizationState->rasterizerDiscardEnable)
+                                       : false;
+    if (copy_src.pViewportState && (has_rasterization || is_graphics_library)) {
+        pViewportState = new safe_VkPipelineViewportStateCreateInfo(*copy_src.pViewportState);
+    } else
+        pViewportState = nullptr;  // original pViewportState pointer ignored
+    if (copy_src.pRasterizationState)
+        pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(*copy_src.pRasterizationState);
+    else
+        pRasterizationState = nullptr;
+    if (copy_src.pMultisampleState && (has_rasterization || is_graphics_library))
+        pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(*copy_src.pMultisampleState);
+    else
+        pMultisampleState = nullptr;  // original pMultisampleState pointer ignored
+    if (copy_src.pDepthStencilState && (has_rasterization || is_graphics_library))
+        pDepthStencilState = new safe_VkPipelineDepthStencilStateCreateInfo(*copy_src.pDepthStencilState);
+    else
+        pDepthStencilState = nullptr;  // original pDepthStencilState pointer ignored
+    if (copy_src.pColorBlendState && (has_rasterization || is_graphics_library))
+        pColorBlendState = new safe_VkPipelineColorBlendStateCreateInfo(*copy_src.pColorBlendState);
+    else
+        pColorBlendState = nullptr;  // original pColorBlendState pointer ignored
+    if (copy_src.pDynamicState)
+        pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(*copy_src.pDynamicState);
+    else
+        pDynamicState = nullptr;
+
+    return *this;
+}
+
+safe_VkGraphicsPipelineCreateInfo::~safe_VkGraphicsPipelineCreateInfo() {
+    if (pStages) delete[] pStages;
+    if (pVertexInputState) delete pVertexInputState;
+    if (pInputAssemblyState) delete pInputAssemblyState;
+    if (pTessellationState) delete pTessellationState;
+    if (pViewportState) delete pViewportState;
+    if (pRasterizationState) delete pRasterizationState;
+    if (pMultisampleState) delete pMultisampleState;
+    if (pDepthStencilState) delete pDepthStencilState;
+    if (pColorBlendState) delete pColorBlendState;
+    if (pDynamicState) delete pDynamicState;
+    FreePnextChain(pNext);
+}
+
+void safe_VkGraphicsPipelineCreateInfo::initialize(const VkGraphicsPipelineCreateInfo* in_struct, const bool uses_color_attachment,
+                                                   const bool uses_depthstencil_attachment,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pStages) delete[] pStages;
+    if (pVertexInputState) delete pVertexInputState;
+    if (pInputAssemblyState) delete pInputAssemblyState;
+    if (pTessellationState) delete pTessellationState;
+    if (pViewportState) delete pViewportState;
+    if (pRasterizationState) delete pRasterizationState;
+    if (pMultisampleState) delete pMultisampleState;
+    if (pDepthStencilState) delete pDepthStencilState;
+    if (pColorBlendState) delete pColorBlendState;
+    if (pDynamicState) delete pDynamicState;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    stageCount = in_struct->stageCount;
+    pStages = nullptr;
+    pVertexInputState = nullptr;
+    pInputAssemblyState = nullptr;
+    pTessellationState = nullptr;
+    pViewportState = nullptr;
+    pRasterizationState = nullptr;
+    pMultisampleState = nullptr;
+    pDepthStencilState = nullptr;
+    pColorBlendState = nullptr;
+    pDynamicState = nullptr;
+    layout = in_struct->layout;
+    renderPass = in_struct->renderPass;
+    subpass = in_struct->subpass;
+    basePipelineHandle = in_struct->basePipelineHandle;
+    basePipelineIndex = in_struct->basePipelineIndex;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    const bool is_graphics_library =
+        vku::FindStructInPNextChain<VkGraphicsPipelineLibraryCreateInfoEXT>(in_struct->pNext) != nullptr;
+    if (stageCount && in_struct->pStages) {
+        pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&in_struct->pStages[i]);
+        }
+    }
+    if (in_struct->pVertexInputState)
+        pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(in_struct->pVertexInputState);
+    else
+        pVertexInputState = nullptr;
+    if (in_struct->pInputAssemblyState)
+        pInputAssemblyState = new safe_VkPipelineInputAssemblyStateCreateInfo(in_struct->pInputAssemblyState);
+    else
+        pInputAssemblyState = nullptr;
+    bool has_tessellation_stage = false;
+    if (stageCount && pStages)
+        for (uint32_t i = 0; i < stageCount && !has_tessellation_stage; ++i)
+            if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT ||
+                pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)
+                has_tessellation_stage = true;
+    if (in_struct->pTessellationState && has_tessellation_stage)
+        pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(in_struct->pTessellationState);
+    else
+        pTessellationState = nullptr;  // original pTessellationState pointer ignored
+    bool is_dynamic_has_rasterization = false;
+    if (in_struct->pDynamicState && in_struct->pDynamicState->pDynamicStates) {
+        for (uint32_t i = 0; i < in_struct->pDynamicState->dynamicStateCount && !is_dynamic_has_rasterization; ++i)
+            if (in_struct->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT)
+                is_dynamic_has_rasterization = true;
+    }
+    const bool has_rasterization = in_struct->pRasterizationState
+                                       ? (is_dynamic_has_rasterization || !in_struct->pRasterizationState->rasterizerDiscardEnable)
+                                       : false;
+    if (in_struct->pViewportState && (has_rasterization || is_graphics_library)) {
+        bool is_dynamic_viewports = false;
+        bool is_dynamic_scissors = false;
+        if (in_struct->pDynamicState && in_struct->pDynamicState->pDynamicStates) {
+            for (uint32_t i = 0; i < in_struct->pDynamicState->dynamicStateCount && !is_dynamic_viewports; ++i)
+                if (in_struct->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_VIEWPORT) is_dynamic_viewports = true;
+            for (uint32_t i = 0; i < in_struct->pDynamicState->dynamicStateCount && !is_dynamic_scissors; ++i)
+                if (in_struct->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_SCISSOR) is_dynamic_scissors = true;
+        }
+        pViewportState =
+            new safe_VkPipelineViewportStateCreateInfo(in_struct->pViewportState, is_dynamic_viewports, is_dynamic_scissors);
+    } else
+        pViewportState = nullptr;  // original pViewportState pointer ignored
+    if (in_struct->pRasterizationState)
+        pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(in_struct->pRasterizationState);
+    else
+        pRasterizationState = nullptr;
+    if (in_struct->pMultisampleState && (renderPass != VK_NULL_HANDLE || has_rasterization || is_graphics_library))
+        pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(in_struct->pMultisampleState);
+    else
+        pMultisampleState = nullptr;  // original pMultisampleState pointer ignored
+    // needs a tracked subpass state uses_depthstencil_attachment
+    if (in_struct->pDepthStencilState && ((has_rasterization && uses_depthstencil_attachment) || is_graphics_library))
+        pDepthStencilState = new safe_VkPipelineDepthStencilStateCreateInfo(in_struct->pDepthStencilState);
+    else
+        pDepthStencilState = nullptr;  // original pDepthStencilState pointer ignored
+    // needs a tracked subpass state usesColorAttachment
+    if (in_struct->pColorBlendState && ((has_rasterization && uses_color_attachment) || is_graphics_library))
+        pColorBlendState = new safe_VkPipelineColorBlendStateCreateInfo(in_struct->pColorBlendState);
+    else
+        pColorBlendState = nullptr;  // original pColorBlendState pointer ignored
+    if (in_struct->pDynamicState)
+        pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(in_struct->pDynamicState);
+    else
+        pDynamicState = nullptr;
+}
+
+void safe_VkGraphicsPipelineCreateInfo::initialize(const safe_VkGraphicsPipelineCreateInfo* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    stageCount = copy_src->stageCount;
+    pStages = nullptr;
+    pVertexInputState = nullptr;
+    pInputAssemblyState = nullptr;
+    pTessellationState = nullptr;
+    pViewportState = nullptr;
+    pRasterizationState = nullptr;
+    pMultisampleState = nullptr;
+    pDepthStencilState = nullptr;
+    pColorBlendState = nullptr;
+    pDynamicState = nullptr;
+    layout = copy_src->layout;
+    renderPass = copy_src->renderPass;
+    subpass = copy_src->subpass;
+    basePipelineHandle = copy_src->basePipelineHandle;
+    basePipelineIndex = copy_src->basePipelineIndex;
+
+    pNext = SafePnextCopy(copy_src->pNext);
+    const bool is_graphics_library = vku::FindStructInPNextChain<VkGraphicsPipelineLibraryCreateInfoEXT>(copy_src->pNext);
+    if (stageCount && copy_src->pStages) {
+        pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&copy_src->pStages[i]);
+        }
+    }
+    if (copy_src->pVertexInputState)
+        pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(*copy_src->pVertexInputState);
+    else
+        pVertexInputState = nullptr;
+    if (copy_src->pInputAssemblyState)
+        pInputAssemblyState = new safe_VkPipelineInputAssemblyStateCreateInfo(*copy_src->pInputAssemblyState);
+    else
+        pInputAssemblyState = nullptr;
+    bool has_tessellation_stage = false;
+    if (stageCount && pStages)
+        for (uint32_t i = 0; i < stageCount && !has_tessellation_stage; ++i)
+            if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT ||
+                pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)
+                has_tessellation_stage = true;
+    if (copy_src->pTessellationState && has_tessellation_stage)
+        pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(*copy_src->pTessellationState);
+    else
+        pTessellationState = nullptr;  // original pTessellationState pointer ignored
+    bool is_dynamic_has_rasterization = false;
+    if (copy_src->pDynamicState && copy_src->pDynamicState->pDynamicStates) {
+        for (uint32_t i = 0; i < copy_src->pDynamicState->dynamicStateCount && !is_dynamic_has_rasterization; ++i)
+            if (copy_src->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT)
+                is_dynamic_has_rasterization = true;
+    }
+    const bool has_rasterization = copy_src->pRasterizationState
+                                       ? (is_dynamic_has_rasterization || !copy_src->pRasterizationState->rasterizerDiscardEnable)
+                                       : false;
+    if (copy_src->pViewportState && (has_rasterization || is_graphics_library)) {
+        pViewportState = new safe_VkPipelineViewportStateCreateInfo(*copy_src->pViewportState);
+    } else
+        pViewportState = nullptr;  // original pViewportState pointer ignored
+    if (copy_src->pRasterizationState)
+        pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(*copy_src->pRasterizationState);
+    else
+        pRasterizationState = nullptr;
+    if (copy_src->pMultisampleState && (has_rasterization || is_graphics_library))
+        pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(*copy_src->pMultisampleState);
+    else
+        pMultisampleState = nullptr;  // original pMultisampleState pointer ignored
+    if (copy_src->pDepthStencilState && (has_rasterization || is_graphics_library))
+        pDepthStencilState = new safe_VkPipelineDepthStencilStateCreateInfo(*copy_src->pDepthStencilState);
+    else
+        pDepthStencilState = nullptr;  // original pDepthStencilState pointer ignored
+    if (copy_src->pColorBlendState && (has_rasterization || is_graphics_library))
+        pColorBlendState = new safe_VkPipelineColorBlendStateCreateInfo(*copy_src->pColorBlendState);
+    else
+        pColorBlendState = nullptr;  // original pColorBlendState pointer ignored
+    if (copy_src->pDynamicState)
+        pDynamicState = new safe_VkPipelineDynamicStateCreateInfo(*copy_src->pDynamicState);
+    else
+        pDynamicState = nullptr;
+}
+
+safe_VkPipelineViewportStateCreateInfo::safe_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo* in_struct,
+                                                                               const bool is_dynamic_viewports,
+                                                                               const bool is_dynamic_scissors,
+                                                                               [[maybe_unused]] PNextCopyState* copy_state,
+                                                                               bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      viewportCount(in_struct->viewportCount),
+      pViewports(nullptr),
+      scissorCount(in_struct->scissorCount),
+      pScissors(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pViewports && !is_dynamic_viewports) {
+        pViewports = new VkViewport[in_struct->viewportCount];
+        memcpy((void*)pViewports, (void*)in_struct->pViewports, sizeof(VkViewport) * in_struct->viewportCount);
+    } else
+        pViewports = nullptr;
+    if (in_struct->pScissors && !is_dynamic_scissors) {
+        pScissors = new VkRect2D[in_struct->scissorCount];
+        memcpy((void*)pScissors, (void*)in_struct->pScissors, sizeof(VkRect2D) * in_struct->scissorCount);
+    } else
+        pScissors = nullptr;
+}
+
+safe_VkPipelineViewportStateCreateInfo::safe_VkPipelineViewportStateCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO),
+      pNext(nullptr),
+      flags(),
+      viewportCount(),
+      pViewports(nullptr),
+      scissorCount(),
+      pScissors(nullptr) {}
+
+safe_VkPipelineViewportStateCreateInfo::safe_VkPipelineViewportStateCreateInfo(
+    const safe_VkPipelineViewportStateCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    viewportCount = copy_src.viewportCount;
+    pViewports = nullptr;
+    scissorCount = copy_src.scissorCount;
+    pScissors = nullptr;
+
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pViewports) {
+        pViewports = new VkViewport[copy_src.viewportCount];
+        memcpy((void*)pViewports, (void*)copy_src.pViewports, sizeof(VkViewport) * copy_src.viewportCount);
+    } else
+        pViewports = nullptr;
+    if (copy_src.pScissors) {
+        pScissors = new VkRect2D[copy_src.scissorCount];
+        memcpy((void*)pScissors, (void*)copy_src.pScissors, sizeof(VkRect2D) * copy_src.scissorCount);
+    } else
+        pScissors = nullptr;
+}
+
+safe_VkPipelineViewportStateCreateInfo& safe_VkPipelineViewportStateCreateInfo::operator=(
+    const safe_VkPipelineViewportStateCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pViewports) delete[] pViewports;
+    if (pScissors) delete[] pScissors;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    viewportCount = copy_src.viewportCount;
+    pViewports = nullptr;
+    scissorCount = copy_src.scissorCount;
+    pScissors = nullptr;
+
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pViewports) {
+        pViewports = new VkViewport[copy_src.viewportCount];
+        memcpy((void*)pViewports, (void*)copy_src.pViewports, sizeof(VkViewport) * copy_src.viewportCount);
+    } else
+        pViewports = nullptr;
+    if (copy_src.pScissors) {
+        pScissors = new VkRect2D[copy_src.scissorCount];
+        memcpy((void*)pScissors, (void*)copy_src.pScissors, sizeof(VkRect2D) * copy_src.scissorCount);
+    } else
+        pScissors = nullptr;
+
+    return *this;
+}
+
+safe_VkPipelineViewportStateCreateInfo::~safe_VkPipelineViewportStateCreateInfo() {
+    if (pViewports) delete[] pViewports;
+    if (pScissors) delete[] pScissors;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineViewportStateCreateInfo::initialize(const VkPipelineViewportStateCreateInfo* in_struct,
+                                                        const bool is_dynamic_viewports, const bool is_dynamic_scissors,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pViewports) delete[] pViewports;
+    if (pScissors) delete[] pScissors;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    viewportCount = in_struct->viewportCount;
+    pViewports = nullptr;
+    scissorCount = in_struct->scissorCount;
+    pScissors = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pViewports && !is_dynamic_viewports) {
+        pViewports = new VkViewport[in_struct->viewportCount];
+        memcpy((void*)pViewports, (void*)in_struct->pViewports, sizeof(VkViewport) * in_struct->viewportCount);
+    } else
+        pViewports = nullptr;
+    if (in_struct->pScissors && !is_dynamic_scissors) {
+        pScissors = new VkRect2D[in_struct->scissorCount];
+        memcpy((void*)pScissors, (void*)in_struct->pScissors, sizeof(VkRect2D) * in_struct->scissorCount);
+    } else
+        pScissors = nullptr;
+}
+
+void safe_VkPipelineViewportStateCreateInfo::initialize(const safe_VkPipelineViewportStateCreateInfo* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    viewportCount = copy_src->viewportCount;
+    pViewports = nullptr;
+    scissorCount = copy_src->scissorCount;
+    pScissors = nullptr;
+
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (copy_src->pViewports) {
+        pViewports = new VkViewport[copy_src->viewportCount];
+        memcpy((void*)pViewports, (void*)copy_src->pViewports, sizeof(VkViewport) * copy_src->viewportCount);
+    } else
+        pViewports = nullptr;
+    if (copy_src->pScissors) {
+        pScissors = new VkRect2D[copy_src->scissorCount];
+        memcpy((void*)pScissors, (void*)copy_src->pScissors, sizeof(VkRect2D) * copy_src->scissorCount);
+    } else
+        pScissors = nullptr;
+}
+
+safe_VkAccelerationStructureBuildGeometryInfoKHR::safe_VkAccelerationStructureBuildGeometryInfoKHR(
+    const VkAccelerationStructureBuildGeometryInfoKHR* in_struct, const bool is_host,
+    const VkAccelerationStructureBuildRangeInfoKHR* build_range_infos, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      type(in_struct->type),
+      flags(in_struct->flags),
+      mode(in_struct->mode),
+      srcAccelerationStructure(in_struct->srcAccelerationStructure),
+      dstAccelerationStructure(in_struct->dstAccelerationStructure),
+      geometryCount(in_struct->geometryCount),
+      pGeometries(nullptr),
+      ppGeometries(nullptr),
+      scratchData(&in_struct->scratchData) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (geometryCount) {
+        if (in_struct->ppGeometries) {
+            ppGeometries = new safe_VkAccelerationStructureGeometryKHR*[geometryCount];
+            for (uint32_t i = 0; i < geometryCount; ++i) {
+                ppGeometries[i] =
+                    new safe_VkAccelerationStructureGeometryKHR(in_struct->ppGeometries[i], is_host, &build_range_infos[i]);
+            }
+        } else {
+            pGeometries = new safe_VkAccelerationStructureGeometryKHR[geometryCount];
+            for (uint32_t i = 0; i < geometryCount; ++i) {
+                (pGeometries)[i] =
+                    safe_VkAccelerationStructureGeometryKHR(&(in_struct->pGeometries)[i], is_host, &build_range_infos[i]);
+            }
+        }
+    }
+}
+
+safe_VkAccelerationStructureBuildGeometryInfoKHR::safe_VkAccelerationStructureBuildGeometryInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR),
+      pNext(nullptr),
+      type(),
+      flags(),
+      mode(),
+      srcAccelerationStructure(),
+      dstAccelerationStructure(),
+      geometryCount(),
+      pGeometries(nullptr),
+      ppGeometries(nullptr) {}
+
+safe_VkAccelerationStructureBuildGeometryInfoKHR::safe_VkAccelerationStructureBuildGeometryInfoKHR(
+    const safe_VkAccelerationStructureBuildGeometryInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    type = copy_src.type;
+    flags = copy_src.flags;
+    mode = copy_src.mode;
+    srcAccelerationStructure = copy_src.srcAccelerationStructure;
+    dstAccelerationStructure = copy_src.dstAccelerationStructure;
+    geometryCount = copy_src.geometryCount;
+    pGeometries = nullptr;
+    ppGeometries = nullptr;
+    scratchData.initialize(&copy_src.scratchData);
+
+    if (geometryCount) {
+        if (copy_src.ppGeometries) {
+            ppGeometries = new safe_VkAccelerationStructureGeometryKHR*[geometryCount];
+            for (uint32_t i = 0; i < geometryCount; ++i) {
+                ppGeometries[i] = new safe_VkAccelerationStructureGeometryKHR(*copy_src.ppGeometries[i]);
+            }
+        } else {
+            pGeometries = new safe_VkAccelerationStructureGeometryKHR[geometryCount];
+            for (uint32_t i = 0; i < geometryCount; ++i) {
+                pGeometries[i] = safe_VkAccelerationStructureGeometryKHR(copy_src.pGeometries[i]);
+            }
+        }
+    }
+}
+
+safe_VkAccelerationStructureBuildGeometryInfoKHR& safe_VkAccelerationStructureBuildGeometryInfoKHR::operator=(
+    const safe_VkAccelerationStructureBuildGeometryInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (ppGeometries) {
+        for (uint32_t i = 0; i < geometryCount; ++i) {
+            delete ppGeometries[i];
+        }
+        delete[] ppGeometries;
+    } else if (pGeometries) {
+        delete[] pGeometries;
+    }
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    type = copy_src.type;
+    flags = copy_src.flags;
+    mode = copy_src.mode;
+    srcAccelerationStructure = copy_src.srcAccelerationStructure;
+    dstAccelerationStructure = copy_src.dstAccelerationStructure;
+    geometryCount = copy_src.geometryCount;
+    pGeometries = nullptr;
+    ppGeometries = nullptr;
+    scratchData.initialize(&copy_src.scratchData);
+
+    if (geometryCount) {
+        if (copy_src.ppGeometries) {
+            ppGeometries = new safe_VkAccelerationStructureGeometryKHR*[geometryCount];
+            for (uint32_t i = 0; i < geometryCount; ++i) {
+                ppGeometries[i] = new safe_VkAccelerationStructureGeometryKHR(*copy_src.ppGeometries[i]);
+            }
+        } else {
+            pGeometries = new safe_VkAccelerationStructureGeometryKHR[geometryCount];
+            for (uint32_t i = 0; i < geometryCount; ++i) {
+                pGeometries[i] = safe_VkAccelerationStructureGeometryKHR(copy_src.pGeometries[i]);
+            }
+        }
+    }
+
+    return *this;
+}
+
+safe_VkAccelerationStructureBuildGeometryInfoKHR::~safe_VkAccelerationStructureBuildGeometryInfoKHR() {
+    if (ppGeometries) {
+        for (uint32_t i = 0; i < geometryCount; ++i) {
+            delete ppGeometries[i];
+        }
+        delete[] ppGeometries;
+    } else if (pGeometries) {
+        delete[] pGeometries;
+    }
+    FreePnextChain(pNext);
+}
+
+void safe_VkAccelerationStructureBuildGeometryInfoKHR::initialize(const VkAccelerationStructureBuildGeometryInfoKHR* in_struct,
+                                                                  const bool is_host,
+                                                                  const VkAccelerationStructureBuildRangeInfoKHR* build_range_infos,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    if (ppGeometries) {
+        for (uint32_t i = 0; i < geometryCount; ++i) {
+            delete ppGeometries[i];
+        }
+        delete[] ppGeometries;
+    } else if (pGeometries) {
+        delete[] pGeometries;
+    }
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    type = in_struct->type;
+    flags = in_struct->flags;
+    mode = in_struct->mode;
+    srcAccelerationStructure = in_struct->srcAccelerationStructure;
+    dstAccelerationStructure = in_struct->dstAccelerationStructure;
+    geometryCount = in_struct->geometryCount;
+    pGeometries = nullptr;
+    ppGeometries = nullptr;
+    scratchData.initialize(&in_struct->scratchData);
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (geometryCount) {
+        if (in_struct->ppGeometries) {
+            ppGeometries = new safe_VkAccelerationStructureGeometryKHR*[geometryCount];
+            for (uint32_t i = 0; i < geometryCount; ++i) {
+                ppGeometries[i] =
+                    new safe_VkAccelerationStructureGeometryKHR(in_struct->ppGeometries[i], is_host, &build_range_infos[i]);
+            }
+        } else {
+            pGeometries = new safe_VkAccelerationStructureGeometryKHR[geometryCount];
+            for (uint32_t i = 0; i < geometryCount; ++i) {
+                (pGeometries)[i] =
+                    safe_VkAccelerationStructureGeometryKHR(&(in_struct->pGeometries)[i], is_host, &build_range_infos[i]);
+            }
+        }
+    }
+}
+
+void safe_VkAccelerationStructureBuildGeometryInfoKHR::initialize(const safe_VkAccelerationStructureBuildGeometryInfoKHR* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    type = copy_src->type;
+    flags = copy_src->flags;
+    mode = copy_src->mode;
+    srcAccelerationStructure = copy_src->srcAccelerationStructure;
+    dstAccelerationStructure = copy_src->dstAccelerationStructure;
+    geometryCount = copy_src->geometryCount;
+    pGeometries = nullptr;
+    ppGeometries = nullptr;
+    scratchData.initialize(&copy_src->scratchData);
+
+    if (geometryCount) {
+        if (copy_src->ppGeometries) {
+            ppGeometries = new safe_VkAccelerationStructureGeometryKHR*[geometryCount];
+            for (uint32_t i = 0; i < geometryCount; ++i) {
+                ppGeometries[i] = new safe_VkAccelerationStructureGeometryKHR(*copy_src->ppGeometries[i]);
+            }
+        } else {
+            pGeometries = new safe_VkAccelerationStructureGeometryKHR[geometryCount];
+            for (uint32_t i = 0; i < geometryCount; ++i) {
+                pGeometries[i] = safe_VkAccelerationStructureGeometryKHR(copy_src->pGeometries[i]);
+            }
+        }
+    }
+}
+
+safe_VkMicromapBuildInfoEXT::safe_VkMicromapBuildInfoEXT(const VkMicromapBuildInfoEXT* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      type(in_struct->type),
+      flags(in_struct->flags),
+      mode(in_struct->mode),
+      dstMicromap(in_struct->dstMicromap),
+      usageCountsCount(in_struct->usageCountsCount),
+      pUsageCounts(nullptr),
+      ppUsageCounts(nullptr),
+      data(&in_struct->data),
+      scratchData(&in_struct->scratchData),
+      triangleArray(&in_struct->triangleArray),
+      triangleArrayStride(in_struct->triangleArrayStride) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pUsageCounts) {
+        pUsageCounts = new VkMicromapUsageEXT[in_struct->usageCountsCount];
+        memcpy((void*)pUsageCounts, (void*)in_struct->pUsageCounts, sizeof(VkMicromapUsageEXT) * in_struct->usageCountsCount);
+    }
+    if (in_struct->ppUsageCounts) {
+        VkMicromapUsageEXT** pointer_array = new VkMicromapUsageEXT*[in_struct->usageCountsCount];
+        for (uint32_t i = 0; i < in_struct->usageCountsCount; ++i) {
+            pointer_array[i] = new VkMicromapUsageEXT(*in_struct->ppUsageCounts[i]);
+        }
+        ppUsageCounts = pointer_array;
+    }
+}
+
+safe_VkMicromapBuildInfoEXT::safe_VkMicromapBuildInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT),
+      pNext(nullptr),
+      type(),
+      flags(),
+      mode(),
+      dstMicromap(),
+      usageCountsCount(),
+      pUsageCounts(nullptr),
+      ppUsageCounts(nullptr),
+      triangleArrayStride() {}
+
+safe_VkMicromapBuildInfoEXT::safe_VkMicromapBuildInfoEXT(const safe_VkMicromapBuildInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    type = copy_src.type;
+    flags = copy_src.flags;
+    mode = copy_src.mode;
+    dstMicromap = copy_src.dstMicromap;
+    usageCountsCount = copy_src.usageCountsCount;
+    pUsageCounts = nullptr;
+    ppUsageCounts = nullptr;
+    data.initialize(&copy_src.data);
+    scratchData.initialize(&copy_src.scratchData);
+    triangleArray.initialize(&copy_src.triangleArray);
+    triangleArrayStride = copy_src.triangleArrayStride;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pUsageCounts) {
+        pUsageCounts = new VkMicromapUsageEXT[copy_src.usageCountsCount];
+        memcpy((void*)pUsageCounts, (void*)copy_src.pUsageCounts, sizeof(VkMicromapUsageEXT) * copy_src.usageCountsCount);
+    }
+    if (copy_src.ppUsageCounts) {
+        VkMicromapUsageEXT** pointer_array = new VkMicromapUsageEXT*[copy_src.usageCountsCount];
+        for (uint32_t i = 0; i < copy_src.usageCountsCount; ++i) {
+            pointer_array[i] = new VkMicromapUsageEXT(*copy_src.ppUsageCounts[i]);
+        }
+        ppUsageCounts = pointer_array;
+    }
+}
+
+safe_VkMicromapBuildInfoEXT& safe_VkMicromapBuildInfoEXT::operator=(const safe_VkMicromapBuildInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pUsageCounts) delete[] pUsageCounts;
+    if (ppUsageCounts) {
+        for (uint32_t i = 0; i < usageCountsCount; ++i) {
+            delete ppUsageCounts[i];
+        }
+        delete[] ppUsageCounts;
+    }
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    type = copy_src.type;
+    flags = copy_src.flags;
+    mode = copy_src.mode;
+    dstMicromap = copy_src.dstMicromap;
+    usageCountsCount = copy_src.usageCountsCount;
+    pUsageCounts = nullptr;
+    ppUsageCounts = nullptr;
+    data.initialize(&copy_src.data);
+    scratchData.initialize(&copy_src.scratchData);
+    triangleArray.initialize(&copy_src.triangleArray);
+    triangleArrayStride = copy_src.triangleArrayStride;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pUsageCounts) {
+        pUsageCounts = new VkMicromapUsageEXT[copy_src.usageCountsCount];
+        memcpy((void*)pUsageCounts, (void*)copy_src.pUsageCounts, sizeof(VkMicromapUsageEXT) * copy_src.usageCountsCount);
+    }
+    if (copy_src.ppUsageCounts) {
+        VkMicromapUsageEXT** pointer_array = new VkMicromapUsageEXT*[copy_src.usageCountsCount];
+        for (uint32_t i = 0; i < copy_src.usageCountsCount; ++i) {
+            pointer_array[i] = new VkMicromapUsageEXT(*copy_src.ppUsageCounts[i]);
+        }
+        ppUsageCounts = pointer_array;
+    }
+
+    return *this;
+}
+
+safe_VkMicromapBuildInfoEXT::~safe_VkMicromapBuildInfoEXT() {
+    if (pUsageCounts) delete[] pUsageCounts;
+    if (ppUsageCounts) {
+        for (uint32_t i = 0; i < usageCountsCount; ++i) {
+            delete ppUsageCounts[i];
+        }
+        delete[] ppUsageCounts;
+    }
+    FreePnextChain(pNext);
+}
+
+void safe_VkMicromapBuildInfoEXT::initialize(const VkMicromapBuildInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pUsageCounts) delete[] pUsageCounts;
+    if (ppUsageCounts) {
+        for (uint32_t i = 0; i < usageCountsCount; ++i) {
+            delete ppUsageCounts[i];
+        }
+        delete[] ppUsageCounts;
+    }
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    type = in_struct->type;
+    flags = in_struct->flags;
+    mode = in_struct->mode;
+    dstMicromap = in_struct->dstMicromap;
+    usageCountsCount = in_struct->usageCountsCount;
+    pUsageCounts = nullptr;
+    ppUsageCounts = nullptr;
+    data.initialize(&in_struct->data);
+    scratchData.initialize(&in_struct->scratchData);
+    triangleArray.initialize(&in_struct->triangleArray);
+    triangleArrayStride = in_struct->triangleArrayStride;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pUsageCounts) {
+        pUsageCounts = new VkMicromapUsageEXT[in_struct->usageCountsCount];
+        memcpy((void*)pUsageCounts, (void*)in_struct->pUsageCounts, sizeof(VkMicromapUsageEXT) * in_struct->usageCountsCount);
+    }
+    if (in_struct->ppUsageCounts) {
+        VkMicromapUsageEXT** pointer_array = new VkMicromapUsageEXT*[in_struct->usageCountsCount];
+        for (uint32_t i = 0; i < in_struct->usageCountsCount; ++i) {
+            pointer_array[i] = new VkMicromapUsageEXT(*in_struct->ppUsageCounts[i]);
+        }
+        ppUsageCounts = pointer_array;
+    }
+}
+
+void safe_VkMicromapBuildInfoEXT::initialize(const safe_VkMicromapBuildInfoEXT* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    type = copy_src->type;
+    flags = copy_src->flags;
+    mode = copy_src->mode;
+    dstMicromap = copy_src->dstMicromap;
+    usageCountsCount = copy_src->usageCountsCount;
+    pUsageCounts = nullptr;
+    ppUsageCounts = nullptr;
+    data.initialize(&copy_src->data);
+    scratchData.initialize(&copy_src->scratchData);
+    triangleArray.initialize(&copy_src->triangleArray);
+    triangleArrayStride = copy_src->triangleArrayStride;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pUsageCounts) {
+        pUsageCounts = new VkMicromapUsageEXT[copy_src->usageCountsCount];
+        memcpy((void*)pUsageCounts, (void*)copy_src->pUsageCounts, sizeof(VkMicromapUsageEXT) * copy_src->usageCountsCount);
+    }
+    if (copy_src->ppUsageCounts) {
+        VkMicromapUsageEXT** pointer_array = new VkMicromapUsageEXT*[copy_src->usageCountsCount];
+        for (uint32_t i = 0; i < copy_src->usageCountsCount; ++i) {
+            pointer_array[i] = new VkMicromapUsageEXT(*copy_src->ppUsageCounts[i]);
+        }
+        ppUsageCounts = pointer_array;
+    }
+}
+
+safe_VkAccelerationStructureTrianglesOpacityMicromapEXT::safe_VkAccelerationStructureTrianglesOpacityMicromapEXT(
+    const VkAccelerationStructureTrianglesOpacityMicromapEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      indexType(in_struct->indexType),
+      indexBuffer(&in_struct->indexBuffer),
+      indexStride(in_struct->indexStride),
+      baseTriangle(in_struct->baseTriangle),
+      usageCountsCount(in_struct->usageCountsCount),
+      pUsageCounts(nullptr),
+      ppUsageCounts(nullptr),
+      micromap(in_struct->micromap) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pUsageCounts) {
+        pUsageCounts = new VkMicromapUsageEXT[in_struct->usageCountsCount];
+        memcpy((void*)pUsageCounts, (void*)in_struct->pUsageCounts, sizeof(VkMicromapUsageEXT) * in_struct->usageCountsCount);
+    }
+    if (in_struct->ppUsageCounts) {
+        VkMicromapUsageEXT** pointer_array = new VkMicromapUsageEXT*[in_struct->usageCountsCount];
+        for (uint32_t i = 0; i < in_struct->usageCountsCount; ++i) {
+            pointer_array[i] = new VkMicromapUsageEXT(*in_struct->ppUsageCounts[i]);
+        }
+        ppUsageCounts = pointer_array;
+    }
+}
+
+safe_VkAccelerationStructureTrianglesOpacityMicromapEXT::safe_VkAccelerationStructureTrianglesOpacityMicromapEXT()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT),
+      pNext(nullptr),
+      indexType(),
+      indexStride(),
+      baseTriangle(),
+      usageCountsCount(),
+      pUsageCounts(nullptr),
+      ppUsageCounts(nullptr),
+      micromap() {}
+
+safe_VkAccelerationStructureTrianglesOpacityMicromapEXT::safe_VkAccelerationStructureTrianglesOpacityMicromapEXT(
+    const safe_VkAccelerationStructureTrianglesOpacityMicromapEXT& copy_src) {
+    sType = copy_src.sType;
+    indexType = copy_src.indexType;
+    indexBuffer.initialize(&copy_src.indexBuffer);
+    indexStride = copy_src.indexStride;
+    baseTriangle = copy_src.baseTriangle;
+    usageCountsCount = copy_src.usageCountsCount;
+    pUsageCounts = nullptr;
+    ppUsageCounts = nullptr;
+    micromap = copy_src.micromap;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pUsageCounts) {
+        pUsageCounts = new VkMicromapUsageEXT[copy_src.usageCountsCount];
+        memcpy((void*)pUsageCounts, (void*)copy_src.pUsageCounts, sizeof(VkMicromapUsageEXT) * copy_src.usageCountsCount);
+    }
+    if (copy_src.ppUsageCounts) {
+        VkMicromapUsageEXT** pointer_array = new VkMicromapUsageEXT*[copy_src.usageCountsCount];
+        for (uint32_t i = 0; i < copy_src.usageCountsCount; ++i) {
+            pointer_array[i] = new VkMicromapUsageEXT(*copy_src.ppUsageCounts[i]);
+        }
+        ppUsageCounts = pointer_array;
+    }
+}
+
+safe_VkAccelerationStructureTrianglesOpacityMicromapEXT& safe_VkAccelerationStructureTrianglesOpacityMicromapEXT::operator=(
+    const safe_VkAccelerationStructureTrianglesOpacityMicromapEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pUsageCounts) delete[] pUsageCounts;
+    if (ppUsageCounts) {
+        for (uint32_t i = 0; i < usageCountsCount; ++i) {
+            delete ppUsageCounts[i];
+        }
+        delete[] ppUsageCounts;
+    }
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    indexType = copy_src.indexType;
+    indexBuffer.initialize(&copy_src.indexBuffer);
+    indexStride = copy_src.indexStride;
+    baseTriangle = copy_src.baseTriangle;
+    usageCountsCount = copy_src.usageCountsCount;
+    pUsageCounts = nullptr;
+    ppUsageCounts = nullptr;
+    micromap = copy_src.micromap;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pUsageCounts) {
+        pUsageCounts = new VkMicromapUsageEXT[copy_src.usageCountsCount];
+        memcpy((void*)pUsageCounts, (void*)copy_src.pUsageCounts, sizeof(VkMicromapUsageEXT) * copy_src.usageCountsCount);
+    }
+    if (copy_src.ppUsageCounts) {
+        VkMicromapUsageEXT** pointer_array = new VkMicromapUsageEXT*[copy_src.usageCountsCount];
+        for (uint32_t i = 0; i < copy_src.usageCountsCount; ++i) {
+            pointer_array[i] = new VkMicromapUsageEXT(*copy_src.ppUsageCounts[i]);
+        }
+        ppUsageCounts = pointer_array;
+    }
+
+    return *this;
+}
+
+safe_VkAccelerationStructureTrianglesOpacityMicromapEXT::~safe_VkAccelerationStructureTrianglesOpacityMicromapEXT() {
+    if (pUsageCounts) delete[] pUsageCounts;
+    if (ppUsageCounts) {
+        for (uint32_t i = 0; i < usageCountsCount; ++i) {
+            delete ppUsageCounts[i];
+        }
+        delete[] ppUsageCounts;
+    }
+    FreePnextChain(pNext);
+}
+
+void safe_VkAccelerationStructureTrianglesOpacityMicromapEXT::initialize(
+    const VkAccelerationStructureTrianglesOpacityMicromapEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pUsageCounts) delete[] pUsageCounts;
+    if (ppUsageCounts) {
+        for (uint32_t i = 0; i < usageCountsCount; ++i) {
+            delete ppUsageCounts[i];
+        }
+        delete[] ppUsageCounts;
+    }
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    indexType = in_struct->indexType;
+    indexBuffer.initialize(&in_struct->indexBuffer);
+    indexStride = in_struct->indexStride;
+    baseTriangle = in_struct->baseTriangle;
+    usageCountsCount = in_struct->usageCountsCount;
+    pUsageCounts = nullptr;
+    ppUsageCounts = nullptr;
+    micromap = in_struct->micromap;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pUsageCounts) {
+        pUsageCounts = new VkMicromapUsageEXT[in_struct->usageCountsCount];
+        memcpy((void*)pUsageCounts, (void*)in_struct->pUsageCounts, sizeof(VkMicromapUsageEXT) * in_struct->usageCountsCount);
+    }
+    if (in_struct->ppUsageCounts) {
+        VkMicromapUsageEXT** pointer_array = new VkMicromapUsageEXT*[in_struct->usageCountsCount];
+        for (uint32_t i = 0; i < in_struct->usageCountsCount; ++i) {
+            pointer_array[i] = new VkMicromapUsageEXT(*in_struct->ppUsageCounts[i]);
+        }
+        ppUsageCounts = pointer_array;
+    }
+}
+
+void safe_VkAccelerationStructureTrianglesOpacityMicromapEXT::initialize(
+    const safe_VkAccelerationStructureTrianglesOpacityMicromapEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    indexType = copy_src->indexType;
+    indexBuffer.initialize(&copy_src->indexBuffer);
+    indexStride = copy_src->indexStride;
+    baseTriangle = copy_src->baseTriangle;
+    usageCountsCount = copy_src->usageCountsCount;
+    pUsageCounts = nullptr;
+    ppUsageCounts = nullptr;
+    micromap = copy_src->micromap;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pUsageCounts) {
+        pUsageCounts = new VkMicromapUsageEXT[copy_src->usageCountsCount];
+        memcpy((void*)pUsageCounts, (void*)copy_src->pUsageCounts, sizeof(VkMicromapUsageEXT) * copy_src->usageCountsCount);
+    }
+    if (copy_src->ppUsageCounts) {
+        VkMicromapUsageEXT** pointer_array = new VkMicromapUsageEXT*[copy_src->usageCountsCount];
+        for (uint32_t i = 0; i < copy_src->usageCountsCount; ++i) {
+            pointer_array[i] = new VkMicromapUsageEXT(*copy_src->ppUsageCounts[i]);
+        }
+        ppUsageCounts = pointer_array;
+    }
+}
+
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+safe_VkAccelerationStructureTrianglesDisplacementMicromapNV::safe_VkAccelerationStructureTrianglesDisplacementMicromapNV(
+    const VkAccelerationStructureTrianglesDisplacementMicromapNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      displacementBiasAndScaleFormat(in_struct->displacementBiasAndScaleFormat),
+      displacementVectorFormat(in_struct->displacementVectorFormat),
+      displacementBiasAndScaleBuffer(&in_struct->displacementBiasAndScaleBuffer),
+      displacementBiasAndScaleStride(in_struct->displacementBiasAndScaleStride),
+      displacementVectorBuffer(&in_struct->displacementVectorBuffer),
+      displacementVectorStride(in_struct->displacementVectorStride),
+      displacedMicromapPrimitiveFlags(&in_struct->displacedMicromapPrimitiveFlags),
+      displacedMicromapPrimitiveFlagsStride(in_struct->displacedMicromapPrimitiveFlagsStride),
+      indexType(in_struct->indexType),
+      indexBuffer(&in_struct->indexBuffer),
+      indexStride(in_struct->indexStride),
+      baseTriangle(in_struct->baseTriangle),
+      usageCountsCount(in_struct->usageCountsCount),
+      pUsageCounts(nullptr),
+      ppUsageCounts(nullptr),
+      micromap(in_struct->micromap) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pUsageCounts) {
+        pUsageCounts = new VkMicromapUsageEXT[in_struct->usageCountsCount];
+        memcpy((void*)pUsageCounts, (void*)in_struct->pUsageCounts, sizeof(VkMicromapUsageEXT) * in_struct->usageCountsCount);
+    }
+    if (in_struct->ppUsageCounts) {
+        VkMicromapUsageEXT** pointer_array = new VkMicromapUsageEXT*[in_struct->usageCountsCount];
+        for (uint32_t i = 0; i < in_struct->usageCountsCount; ++i) {
+            pointer_array[i] = new VkMicromapUsageEXT(*in_struct->ppUsageCounts[i]);
+        }
+        ppUsageCounts = pointer_array;
+    }
+}
+
+safe_VkAccelerationStructureTrianglesDisplacementMicromapNV::safe_VkAccelerationStructureTrianglesDisplacementMicromapNV()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV),
+      pNext(nullptr),
+      displacementBiasAndScaleFormat(),
+      displacementVectorFormat(),
+      displacementBiasAndScaleStride(),
+      displacementVectorStride(),
+      displacedMicromapPrimitiveFlagsStride(),
+      indexType(),
+      indexStride(),
+      baseTriangle(),
+      usageCountsCount(),
+      pUsageCounts(nullptr),
+      ppUsageCounts(nullptr),
+      micromap() {}
+
+safe_VkAccelerationStructureTrianglesDisplacementMicromapNV::safe_VkAccelerationStructureTrianglesDisplacementMicromapNV(
+    const safe_VkAccelerationStructureTrianglesDisplacementMicromapNV& copy_src) {
+    sType = copy_src.sType;
+    displacementBiasAndScaleFormat = copy_src.displacementBiasAndScaleFormat;
+    displacementVectorFormat = copy_src.displacementVectorFormat;
+    displacementBiasAndScaleBuffer.initialize(&copy_src.displacementBiasAndScaleBuffer);
+    displacementBiasAndScaleStride = copy_src.displacementBiasAndScaleStride;
+    displacementVectorBuffer.initialize(&copy_src.displacementVectorBuffer);
+    displacementVectorStride = copy_src.displacementVectorStride;
+    displacedMicromapPrimitiveFlags.initialize(&copy_src.displacedMicromapPrimitiveFlags);
+    displacedMicromapPrimitiveFlagsStride = copy_src.displacedMicromapPrimitiveFlagsStride;
+    indexType = copy_src.indexType;
+    indexBuffer.initialize(&copy_src.indexBuffer);
+    indexStride = copy_src.indexStride;
+    baseTriangle = copy_src.baseTriangle;
+    usageCountsCount = copy_src.usageCountsCount;
+    pUsageCounts = nullptr;
+    ppUsageCounts = nullptr;
+    micromap = copy_src.micromap;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pUsageCounts) {
+        pUsageCounts = new VkMicromapUsageEXT[copy_src.usageCountsCount];
+        memcpy((void*)pUsageCounts, (void*)copy_src.pUsageCounts, sizeof(VkMicromapUsageEXT) * copy_src.usageCountsCount);
+    }
+    if (copy_src.ppUsageCounts) {
+        VkMicromapUsageEXT** pointer_array = new VkMicromapUsageEXT*[copy_src.usageCountsCount];
+        for (uint32_t i = 0; i < copy_src.usageCountsCount; ++i) {
+            pointer_array[i] = new VkMicromapUsageEXT(*copy_src.ppUsageCounts[i]);
+        }
+        ppUsageCounts = pointer_array;
+    }
+}
+
+safe_VkAccelerationStructureTrianglesDisplacementMicromapNV& safe_VkAccelerationStructureTrianglesDisplacementMicromapNV::operator=(
+    const safe_VkAccelerationStructureTrianglesDisplacementMicromapNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pUsageCounts) delete[] pUsageCounts;
+    if (ppUsageCounts) {
+        for (uint32_t i = 0; i < usageCountsCount; ++i) {
+            delete ppUsageCounts[i];
+        }
+        delete[] ppUsageCounts;
+    }
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    displacementBiasAndScaleFormat = copy_src.displacementBiasAndScaleFormat;
+    displacementVectorFormat = copy_src.displacementVectorFormat;
+    displacementBiasAndScaleBuffer.initialize(&copy_src.displacementBiasAndScaleBuffer);
+    displacementBiasAndScaleStride = copy_src.displacementBiasAndScaleStride;
+    displacementVectorBuffer.initialize(&copy_src.displacementVectorBuffer);
+    displacementVectorStride = copy_src.displacementVectorStride;
+    displacedMicromapPrimitiveFlags.initialize(&copy_src.displacedMicromapPrimitiveFlags);
+    displacedMicromapPrimitiveFlagsStride = copy_src.displacedMicromapPrimitiveFlagsStride;
+    indexType = copy_src.indexType;
+    indexBuffer.initialize(&copy_src.indexBuffer);
+    indexStride = copy_src.indexStride;
+    baseTriangle = copy_src.baseTriangle;
+    usageCountsCount = copy_src.usageCountsCount;
+    pUsageCounts = nullptr;
+    ppUsageCounts = nullptr;
+    micromap = copy_src.micromap;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pUsageCounts) {
+        pUsageCounts = new VkMicromapUsageEXT[copy_src.usageCountsCount];
+        memcpy((void*)pUsageCounts, (void*)copy_src.pUsageCounts, sizeof(VkMicromapUsageEXT) * copy_src.usageCountsCount);
+    }
+    if (copy_src.ppUsageCounts) {
+        VkMicromapUsageEXT** pointer_array = new VkMicromapUsageEXT*[copy_src.usageCountsCount];
+        for (uint32_t i = 0; i < copy_src.usageCountsCount; ++i) {
+            pointer_array[i] = new VkMicromapUsageEXT(*copy_src.ppUsageCounts[i]);
+        }
+        ppUsageCounts = pointer_array;
+    }
+
+    return *this;
+}
+
+safe_VkAccelerationStructureTrianglesDisplacementMicromapNV::~safe_VkAccelerationStructureTrianglesDisplacementMicromapNV() {
+    if (pUsageCounts) delete[] pUsageCounts;
+    if (ppUsageCounts) {
+        for (uint32_t i = 0; i < usageCountsCount; ++i) {
+            delete ppUsageCounts[i];
+        }
+        delete[] ppUsageCounts;
+    }
+    FreePnextChain(pNext);
+}
+
+void safe_VkAccelerationStructureTrianglesDisplacementMicromapNV::initialize(
+    const VkAccelerationStructureTrianglesDisplacementMicromapNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pUsageCounts) delete[] pUsageCounts;
+    if (ppUsageCounts) {
+        for (uint32_t i = 0; i < usageCountsCount; ++i) {
+            delete ppUsageCounts[i];
+        }
+        delete[] ppUsageCounts;
+    }
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    displacementBiasAndScaleFormat = in_struct->displacementBiasAndScaleFormat;
+    displacementVectorFormat = in_struct->displacementVectorFormat;
+    displacementBiasAndScaleBuffer.initialize(&in_struct->displacementBiasAndScaleBuffer);
+    displacementBiasAndScaleStride = in_struct->displacementBiasAndScaleStride;
+    displacementVectorBuffer.initialize(&in_struct->displacementVectorBuffer);
+    displacementVectorStride = in_struct->displacementVectorStride;
+    displacedMicromapPrimitiveFlags.initialize(&in_struct->displacedMicromapPrimitiveFlags);
+    displacedMicromapPrimitiveFlagsStride = in_struct->displacedMicromapPrimitiveFlagsStride;
+    indexType = in_struct->indexType;
+    indexBuffer.initialize(&in_struct->indexBuffer);
+    indexStride = in_struct->indexStride;
+    baseTriangle = in_struct->baseTriangle;
+    usageCountsCount = in_struct->usageCountsCount;
+    pUsageCounts = nullptr;
+    ppUsageCounts = nullptr;
+    micromap = in_struct->micromap;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pUsageCounts) {
+        pUsageCounts = new VkMicromapUsageEXT[in_struct->usageCountsCount];
+        memcpy((void*)pUsageCounts, (void*)in_struct->pUsageCounts, sizeof(VkMicromapUsageEXT) * in_struct->usageCountsCount);
+    }
+    if (in_struct->ppUsageCounts) {
+        VkMicromapUsageEXT** pointer_array = new VkMicromapUsageEXT*[in_struct->usageCountsCount];
+        for (uint32_t i = 0; i < in_struct->usageCountsCount; ++i) {
+            pointer_array[i] = new VkMicromapUsageEXT(*in_struct->ppUsageCounts[i]);
+        }
+        ppUsageCounts = pointer_array;
+    }
+}
+
+void safe_VkAccelerationStructureTrianglesDisplacementMicromapNV::initialize(
+    const safe_VkAccelerationStructureTrianglesDisplacementMicromapNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    displacementBiasAndScaleFormat = copy_src->displacementBiasAndScaleFormat;
+    displacementVectorFormat = copy_src->displacementVectorFormat;
+    displacementBiasAndScaleBuffer.initialize(&copy_src->displacementBiasAndScaleBuffer);
+    displacementBiasAndScaleStride = copy_src->displacementBiasAndScaleStride;
+    displacementVectorBuffer.initialize(&copy_src->displacementVectorBuffer);
+    displacementVectorStride = copy_src->displacementVectorStride;
+    displacedMicromapPrimitiveFlags.initialize(&copy_src->displacedMicromapPrimitiveFlags);
+    displacedMicromapPrimitiveFlagsStride = copy_src->displacedMicromapPrimitiveFlagsStride;
+    indexType = copy_src->indexType;
+    indexBuffer.initialize(&copy_src->indexBuffer);
+    indexStride = copy_src->indexStride;
+    baseTriangle = copy_src->baseTriangle;
+    usageCountsCount = copy_src->usageCountsCount;
+    pUsageCounts = nullptr;
+    ppUsageCounts = nullptr;
+    micromap = copy_src->micromap;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pUsageCounts) {
+        pUsageCounts = new VkMicromapUsageEXT[copy_src->usageCountsCount];
+        memcpy((void*)pUsageCounts, (void*)copy_src->pUsageCounts, sizeof(VkMicromapUsageEXT) * copy_src->usageCountsCount);
+    }
+    if (copy_src->ppUsageCounts) {
+        VkMicromapUsageEXT** pointer_array = new VkMicromapUsageEXT*[copy_src->usageCountsCount];
+        for (uint32_t i = 0; i < copy_src->usageCountsCount; ++i) {
+            pointer_array[i] = new VkMicromapUsageEXT(*copy_src->ppUsageCounts[i]);
+        }
+        ppUsageCounts = pointer_array;
+    }
+}
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+}  // namespace vku
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
new file mode 100644
index 0000000..063c311
--- /dev/null
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -0,0 +1,3633 @@
+// *** THIS FILE IS GENERATED - DO NOT EDIT ***
+// See safe_struct_generator.py for modifications
+
+/***************************************************************************
+ *
+ * Copyright (c) 2015-2024 The Khronos Group Inc.
+ * Copyright (c) 2015-2024 Valve Corporation
+ * Copyright (c) 2015-2024 LunarG, Inc.
+ * Copyright (c) 2015-2024 Google Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ ****************************************************************************/
+
+// NOLINTBEGIN
+
+#include <vulkan/vk_layer.h>
+#include <vulkan/utility/vk_safe_struct.hpp>
+
+#include <vector>
+#include <cstring>
+
+extern std::vector<std::pair<uint32_t, uint32_t>> custom_stype_info;
+
+namespace vku {
+char *SafeStringCopy(const char *in_string) {
+    if (nullptr == in_string) return nullptr;
+    size_t len = std::strlen(in_string);
+    char *dest = new char[len + 1];
+    dest[len] = '\0';
+    std::memcpy(dest, in_string, len);
+    return dest;
+}
+
+// clang-format off
+void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
+    void *first_pNext{};
+    VkBaseOutStructure *prev_pNext{};
+    void *safe_pNext{};
+
+    while (pNext) {
+        const VkBaseOutStructure *header = reinterpret_cast<const VkBaseOutStructure *>(pNext);
+
+        switch (header->sType) {
+            // Add special-case code to copy beloved secret loader structs
+            // Special-case Loader Instance Struct passed to/from layer in pNext chain
+            case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO: {
+                VkLayerInstanceCreateInfo *struct_copy = new VkLayerInstanceCreateInfo;
+                // TODO: Uses original VkLayerInstanceLink* chain, which should be okay for our uses
+                memcpy(struct_copy, pNext, sizeof(VkLayerInstanceCreateInfo));
+                safe_pNext = struct_copy;
+                break;
+            }
+            // Special-case Loader Device Struct passed to/from layer in pNext chain
+            case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO: {
+                VkLayerDeviceCreateInfo *struct_copy = new VkLayerDeviceCreateInfo;
+                // TODO: Uses original VkLayerDeviceLink*, which should be okay for our uses
+                memcpy(struct_copy, pNext, sizeof(VkLayerDeviceCreateInfo));
+                safe_pNext = struct_copy;
+                break;
+            }
+            case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
+                safe_pNext = new safe_VkShaderModuleCreateInfo(reinterpret_cast<const VkShaderModuleCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:
+                safe_pNext = new safe_VkPipelineLayoutCreateInfo(reinterpret_cast<const VkPipelineLayoutCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
+                safe_pNext = new safe_VkPhysicalDeviceSubgroupProperties(reinterpret_cast<const VkPhysicalDeviceSubgroupProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
+                safe_pNext = new safe_VkPhysicalDevice16BitStorageFeatures(reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
+                safe_pNext = new safe_VkMemoryDedicatedRequirements(reinterpret_cast<const VkMemoryDedicatedRequirements *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
+                safe_pNext = new safe_VkMemoryDedicatedAllocateInfo(reinterpret_cast<const VkMemoryDedicatedAllocateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
+                safe_pNext = new safe_VkMemoryAllocateFlagsInfo(reinterpret_cast<const VkMemoryAllocateFlagsInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
+                safe_pNext = new safe_VkDeviceGroupRenderPassBeginInfo(reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
+                safe_pNext = new safe_VkDeviceGroupCommandBufferBeginInfo(reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
+                safe_pNext = new safe_VkDeviceGroupSubmitInfo(reinterpret_cast<const VkDeviceGroupSubmitInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
+                safe_pNext = new safe_VkDeviceGroupBindSparseInfo(reinterpret_cast<const VkDeviceGroupBindSparseInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
+                safe_pNext = new safe_VkBindBufferMemoryDeviceGroupInfo(reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
+                safe_pNext = new safe_VkBindImageMemoryDeviceGroupInfo(reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
+                safe_pNext = new safe_VkDeviceGroupDeviceCreateInfo(reinterpret_cast<const VkDeviceGroupDeviceCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
+                safe_pNext = new safe_VkPhysicalDeviceFeatures2(reinterpret_cast<const VkPhysicalDeviceFeatures2 *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
+                safe_pNext = new safe_VkPhysicalDevicePointClippingProperties(reinterpret_cast<const VkPhysicalDevicePointClippingProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
+                safe_pNext = new safe_VkRenderPassInputAttachmentAspectCreateInfo(reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
+                safe_pNext = new safe_VkImageViewUsageCreateInfo(reinterpret_cast<const VkImageViewUsageCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
+                safe_pNext = new safe_VkPipelineTessellationDomainOriginStateCreateInfo(reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
+                safe_pNext = new safe_VkRenderPassMultiviewCreateInfo(reinterpret_cast<const VkRenderPassMultiviewCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceMultiviewFeatures(reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
+                safe_pNext = new safe_VkPhysicalDeviceMultiviewProperties(reinterpret_cast<const VkPhysicalDeviceMultiviewProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceVariablePointersFeatures(reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceProtectedMemoryFeatures(reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
+                safe_pNext = new safe_VkPhysicalDeviceProtectedMemoryProperties(reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
+                safe_pNext = new safe_VkProtectedSubmitInfo(reinterpret_cast<const VkProtectedSubmitInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
+                safe_pNext = new safe_VkSamplerYcbcrConversionInfo(reinterpret_cast<const VkSamplerYcbcrConversionInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
+                safe_pNext = new safe_VkBindImagePlaneMemoryInfo(reinterpret_cast<const VkBindImagePlaneMemoryInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
+                safe_pNext = new safe_VkImagePlaneMemoryRequirementsInfo(reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures(reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
+                safe_pNext = new safe_VkSamplerYcbcrConversionImageFormatProperties(reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
+                safe_pNext = new safe_VkPhysicalDeviceExternalImageFormatInfo(reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
+                safe_pNext = new safe_VkExternalImageFormatProperties(reinterpret_cast<const VkExternalImageFormatProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
+                safe_pNext = new safe_VkPhysicalDeviceIDProperties(reinterpret_cast<const VkPhysicalDeviceIDProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
+                safe_pNext = new safe_VkExternalMemoryImageCreateInfo(reinterpret_cast<const VkExternalMemoryImageCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
+                safe_pNext = new safe_VkExternalMemoryBufferCreateInfo(reinterpret_cast<const VkExternalMemoryBufferCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
+                safe_pNext = new safe_VkExportMemoryAllocateInfo(reinterpret_cast<const VkExportMemoryAllocateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
+                safe_pNext = new safe_VkExportFenceCreateInfo(reinterpret_cast<const VkExportFenceCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
+                safe_pNext = new safe_VkExportSemaphoreCreateInfo(reinterpret_cast<const VkExportSemaphoreCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
+                safe_pNext = new safe_VkPhysicalDeviceMaintenance3Properties(reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceShaderDrawParametersFeatures(reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceVulkan11Features(reinterpret_cast<const VkPhysicalDeviceVulkan11Features *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
+                safe_pNext = new safe_VkPhysicalDeviceVulkan11Properties(reinterpret_cast<const VkPhysicalDeviceVulkan11Properties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceVulkan12Features(reinterpret_cast<const VkPhysicalDeviceVulkan12Features *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
+                safe_pNext = new safe_VkPhysicalDeviceVulkan12Properties(reinterpret_cast<const VkPhysicalDeviceVulkan12Properties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
+                safe_pNext = new safe_VkImageFormatListCreateInfo(reinterpret_cast<const VkImageFormatListCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
+                safe_pNext = new safe_VkPhysicalDevice8BitStorageFeatures(reinterpret_cast<const VkPhysicalDevice8BitStorageFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
+                safe_pNext = new safe_VkPhysicalDeviceDriverProperties(reinterpret_cast<const VkPhysicalDeviceDriverProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceShaderAtomicInt64Features(reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64Features *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceShaderFloat16Int8Features(reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8Features *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
+                safe_pNext = new safe_VkPhysicalDeviceFloatControlsProperties(reinterpret_cast<const VkPhysicalDeviceFloatControlsProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
+                safe_pNext = new safe_VkDescriptorSetLayoutBindingFlagsCreateInfo(reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceDescriptorIndexingFeatures(reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
+                safe_pNext = new safe_VkPhysicalDeviceDescriptorIndexingProperties(reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
+                safe_pNext = new safe_VkDescriptorSetVariableDescriptorCountAllocateInfo(reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
+                safe_pNext = new safe_VkDescriptorSetVariableDescriptorCountLayoutSupport(reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupport *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
+                safe_pNext = new safe_VkSubpassDescriptionDepthStencilResolve(reinterpret_cast<const VkSubpassDescriptionDepthStencilResolve *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
+                safe_pNext = new safe_VkPhysicalDeviceDepthStencilResolveProperties(reinterpret_cast<const VkPhysicalDeviceDepthStencilResolveProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceScalarBlockLayoutFeatures(reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
+                safe_pNext = new safe_VkImageStencilUsageCreateInfo(reinterpret_cast<const VkImageStencilUsageCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
+                safe_pNext = new safe_VkSamplerReductionModeCreateInfo(reinterpret_cast<const VkSamplerReductionModeCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
+                safe_pNext = new safe_VkPhysicalDeviceSamplerFilterMinmaxProperties(reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceVulkanMemoryModelFeatures(reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceImagelessFramebufferFeatures(reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
+                safe_pNext = new safe_VkFramebufferAttachmentsCreateInfo(reinterpret_cast<const VkFramebufferAttachmentsCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
+                safe_pNext = new safe_VkRenderPassAttachmentBeginInfo(reinterpret_cast<const VkRenderPassAttachmentBeginInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(reinterpret_cast<const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(reinterpret_cast<const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
+                safe_pNext = new safe_VkAttachmentReferenceStencilLayout(reinterpret_cast<const VkAttachmentReferenceStencilLayout *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
+                safe_pNext = new safe_VkAttachmentDescriptionStencilLayout(reinterpret_cast<const VkAttachmentDescriptionStencilLayout *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceHostQueryResetFeatures(reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceTimelineSemaphoreFeatures(reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
+                safe_pNext = new safe_VkPhysicalDeviceTimelineSemaphoreProperties(reinterpret_cast<const VkPhysicalDeviceTimelineSemaphoreProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
+                safe_pNext = new safe_VkSemaphoreTypeCreateInfo(reinterpret_cast<const VkSemaphoreTypeCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
+                safe_pNext = new safe_VkTimelineSemaphoreSubmitInfo(reinterpret_cast<const VkTimelineSemaphoreSubmitInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceBufferDeviceAddressFeatures(reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
+                safe_pNext = new safe_VkBufferOpaqueCaptureAddressCreateInfo(reinterpret_cast<const VkBufferOpaqueCaptureAddressCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
+                safe_pNext = new safe_VkMemoryOpaqueCaptureAddressAllocateInfo(reinterpret_cast<const VkMemoryOpaqueCaptureAddressAllocateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceVulkan13Features(reinterpret_cast<const VkPhysicalDeviceVulkan13Features *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
+                safe_pNext = new safe_VkPhysicalDeviceVulkan13Properties(reinterpret_cast<const VkPhysicalDeviceVulkan13Properties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
+                safe_pNext = new safe_VkPipelineCreationFeedbackCreateInfo(reinterpret_cast<const VkPipelineCreationFeedbackCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceShaderTerminateInvocationFeatures(reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
+                safe_pNext = new safe_VkPhysicalDevicePrivateDataFeatures(reinterpret_cast<const VkPhysicalDevicePrivateDataFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
+                safe_pNext = new safe_VkDevicePrivateDataCreateInfo(reinterpret_cast<const VkDevicePrivateDataCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
+                safe_pNext = new safe_VkPhysicalDevicePipelineCreationCacheControlFeatures(reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2:
+                safe_pNext = new safe_VkMemoryBarrier2(reinterpret_cast<const VkMemoryBarrier2 *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceSynchronization2Features(reinterpret_cast<const VkPhysicalDeviceSynchronization2Features *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceImageRobustnessFeatures(reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceSubgroupSizeControlFeatures(reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
+                safe_pNext = new safe_VkPhysicalDeviceSubgroupSizeControlProperties(reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
+                safe_pNext = new safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceInlineUniformBlockFeatures(reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
+                safe_pNext = new safe_VkPhysicalDeviceInlineUniformBlockProperties(reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK:
+                safe_pNext = new safe_VkWriteDescriptorSetInlineUniformBlock(reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlock *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO:
+                safe_pNext = new safe_VkDescriptorPoolInlineUniformBlockCreateInfo(reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
+                safe_pNext = new safe_VkPipelineRenderingCreateInfo(reinterpret_cast<const VkPipelineRenderingCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceDynamicRenderingFeatures(reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO:
+                safe_pNext = new safe_VkCommandBufferInheritanceRenderingInfo(reinterpret_cast<const VkCommandBufferInheritanceRenderingInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceShaderIntegerDotProductFeatures(reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
+                safe_pNext = new safe_VkPhysicalDeviceShaderIntegerDotProductProperties(reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
+                safe_pNext = new safe_VkPhysicalDeviceTexelBufferAlignmentProperties(reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
+                safe_pNext = new safe_VkFormatProperties3(reinterpret_cast<const VkFormatProperties3 *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceMaintenance4Features(reinterpret_cast<const VkPhysicalDeviceMaintenance4Features *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
+                safe_pNext = new safe_VkPhysicalDeviceMaintenance4Properties(reinterpret_cast<const VkPhysicalDeviceMaintenance4Properties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
+                safe_pNext = new safe_VkImageSwapchainCreateInfoKHR(reinterpret_cast<const VkImageSwapchainCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
+                safe_pNext = new safe_VkBindImageMemorySwapchainInfoKHR(reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
+                safe_pNext = new safe_VkDeviceGroupPresentInfoKHR(reinterpret_cast<const VkDeviceGroupPresentInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
+                safe_pNext = new safe_VkDeviceGroupSwapchainCreateInfoKHR(reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
+                safe_pNext = new safe_VkDisplayPresentInfoKHR(reinterpret_cast<const VkDisplayPresentInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR:
+                safe_pNext = new safe_VkQueueFamilyQueryResultStatusPropertiesKHR(reinterpret_cast<const VkQueueFamilyQueryResultStatusPropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR:
+                safe_pNext = new safe_VkQueueFamilyVideoPropertiesKHR(reinterpret_cast<const VkQueueFamilyVideoPropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR:
+                safe_pNext = new safe_VkVideoProfileInfoKHR(reinterpret_cast<const VkVideoProfileInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR:
+                safe_pNext = new safe_VkVideoProfileListInfoKHR(reinterpret_cast<const VkVideoProfileListInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR:
+                safe_pNext = new safe_VkVideoDecodeCapabilitiesKHR(reinterpret_cast<const VkVideoDecodeCapabilitiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR:
+                safe_pNext = new safe_VkVideoDecodeUsageInfoKHR(reinterpret_cast<const VkVideoDecodeUsageInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR:
+                safe_pNext = new safe_VkVideoEncodeH264CapabilitiesKHR(reinterpret_cast<const VkVideoEncodeH264CapabilitiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR:
+                safe_pNext = new safe_VkVideoEncodeH264QualityLevelPropertiesKHR(reinterpret_cast<const VkVideoEncodeH264QualityLevelPropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeH264SessionCreateInfoKHR(reinterpret_cast<const VkVideoEncodeH264SessionCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeH264SessionParametersAddInfoKHR(reinterpret_cast<const VkVideoEncodeH264SessionParametersAddInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeH264SessionParametersCreateInfoKHR(reinterpret_cast<const VkVideoEncodeH264SessionParametersCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeH264SessionParametersGetInfoKHR(reinterpret_cast<const VkVideoEncodeH264SessionParametersGetInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR(reinterpret_cast<const VkVideoEncodeH264SessionParametersFeedbackInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeH264PictureInfoKHR(reinterpret_cast<const VkVideoEncodeH264PictureInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeH264DpbSlotInfoKHR(reinterpret_cast<const VkVideoEncodeH264DpbSlotInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeH264ProfileInfoKHR(reinterpret_cast<const VkVideoEncodeH264ProfileInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeH264RateControlInfoKHR(reinterpret_cast<const VkVideoEncodeH264RateControlInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeH264RateControlLayerInfoKHR(reinterpret_cast<const VkVideoEncodeH264RateControlLayerInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeH264GopRemainingFrameInfoKHR(reinterpret_cast<const VkVideoEncodeH264GopRemainingFrameInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR:
+                safe_pNext = new safe_VkVideoEncodeH265CapabilitiesKHR(reinterpret_cast<const VkVideoEncodeH265CapabilitiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeH265SessionCreateInfoKHR(reinterpret_cast<const VkVideoEncodeH265SessionCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR:
+                safe_pNext = new safe_VkVideoEncodeH265QualityLevelPropertiesKHR(reinterpret_cast<const VkVideoEncodeH265QualityLevelPropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeH265SessionParametersAddInfoKHR(reinterpret_cast<const VkVideoEncodeH265SessionParametersAddInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeH265SessionParametersCreateInfoKHR(reinterpret_cast<const VkVideoEncodeH265SessionParametersCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeH265SessionParametersGetInfoKHR(reinterpret_cast<const VkVideoEncodeH265SessionParametersGetInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR(reinterpret_cast<const VkVideoEncodeH265SessionParametersFeedbackInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeH265PictureInfoKHR(reinterpret_cast<const VkVideoEncodeH265PictureInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeH265DpbSlotInfoKHR(reinterpret_cast<const VkVideoEncodeH265DpbSlotInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeH265ProfileInfoKHR(reinterpret_cast<const VkVideoEncodeH265ProfileInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeH265RateControlInfoKHR(reinterpret_cast<const VkVideoEncodeH265RateControlInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeH265RateControlLayerInfoKHR(reinterpret_cast<const VkVideoEncodeH265RateControlLayerInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeH265GopRemainingFrameInfoKHR(reinterpret_cast<const VkVideoEncodeH265GopRemainingFrameInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR:
+                safe_pNext = new safe_VkVideoDecodeH264ProfileInfoKHR(reinterpret_cast<const VkVideoDecodeH264ProfileInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR:
+                safe_pNext = new safe_VkVideoDecodeH264CapabilitiesKHR(reinterpret_cast<const VkVideoDecodeH264CapabilitiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR:
+                safe_pNext = new safe_VkVideoDecodeH264SessionParametersAddInfoKHR(reinterpret_cast<const VkVideoDecodeH264SessionParametersAddInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR:
+                safe_pNext = new safe_VkVideoDecodeH264SessionParametersCreateInfoKHR(reinterpret_cast<const VkVideoDecodeH264SessionParametersCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR:
+                safe_pNext = new safe_VkVideoDecodeH264PictureInfoKHR(reinterpret_cast<const VkVideoDecodeH264PictureInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR:
+                safe_pNext = new safe_VkVideoDecodeH264DpbSlotInfoKHR(reinterpret_cast<const VkVideoDecodeH264DpbSlotInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
+                safe_pNext = new safe_VkRenderingFragmentShadingRateAttachmentInfoKHR(reinterpret_cast<const VkRenderingFragmentShadingRateAttachmentInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
+                safe_pNext = new safe_VkRenderingFragmentDensityMapAttachmentInfoEXT(reinterpret_cast<const VkRenderingFragmentDensityMapAttachmentInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
+                safe_pNext = new safe_VkAttachmentSampleCountInfoAMD(reinterpret_cast<const VkAttachmentSampleCountInfoAMD *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
+                safe_pNext = new safe_VkMultiviewPerViewAttributesInfoNVX(reinterpret_cast<const VkMultiviewPerViewAttributesInfoNVX *>(pNext), copy_state, false);
+                break;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+            case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+                safe_pNext = new safe_VkImportMemoryWin32HandleInfoKHR(reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+                safe_pNext = new safe_VkExportMemoryWin32HandleInfoKHR(reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR *>(pNext), copy_state, false);
+                break;
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+            case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
+                safe_pNext = new safe_VkImportMemoryFdInfoKHR(reinterpret_cast<const VkImportMemoryFdInfoKHR *>(pNext), copy_state, false);
+                break;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+            case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
+                safe_pNext = new safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
+                safe_pNext = new safe_VkExportSemaphoreWin32HandleInfoKHR(reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
+                safe_pNext = new safe_VkD3D12FenceSubmitInfoKHR(reinterpret_cast<const VkD3D12FenceSubmitInfoKHR *>(pNext), copy_state, false);
+                break;
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
+                safe_pNext = new safe_VkPhysicalDevicePushDescriptorPropertiesKHR(reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
+                safe_pNext = new safe_VkPresentRegionsKHR(reinterpret_cast<const VkPresentRegionsKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
+                safe_pNext = new safe_VkSharedPresentSurfaceCapabilitiesKHR(reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR *>(pNext), copy_state, false);
+                break;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+            case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
+                safe_pNext = new safe_VkExportFenceWin32HandleInfoKHR(reinterpret_cast<const VkExportFenceWin32HandleInfoKHR *>(pNext), copy_state, false);
+                break;
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDevicePerformanceQueryFeaturesKHR(reinterpret_cast<const VkPhysicalDevicePerformanceQueryFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
+                safe_pNext = new safe_VkPhysicalDevicePerformanceQueryPropertiesKHR(reinterpret_cast<const VkPhysicalDevicePerformanceQueryPropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
+                safe_pNext = new safe_VkQueryPoolPerformanceCreateInfoKHR(reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
+                safe_pNext = new safe_VkPerformanceQuerySubmitInfoKHR(reinterpret_cast<const VkPerformanceQuerySubmitInfoKHR *>(pNext), copy_state, false);
+                break;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR(reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
+                safe_pNext = new safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR(reinterpret_cast<const VkPhysicalDevicePortabilitySubsetPropertiesKHR *>(pNext), copy_state, false);
+                break;
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceShaderClockFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceShaderClockFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR:
+                safe_pNext = new safe_VkVideoDecodeH265ProfileInfoKHR(reinterpret_cast<const VkVideoDecodeH265ProfileInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR:
+                safe_pNext = new safe_VkVideoDecodeH265CapabilitiesKHR(reinterpret_cast<const VkVideoDecodeH265CapabilitiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR:
+                safe_pNext = new safe_VkVideoDecodeH265SessionParametersAddInfoKHR(reinterpret_cast<const VkVideoDecodeH265SessionParametersAddInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR:
+                safe_pNext = new safe_VkVideoDecodeH265SessionParametersCreateInfoKHR(reinterpret_cast<const VkVideoDecodeH265SessionParametersCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR:
+                safe_pNext = new safe_VkVideoDecodeH265PictureInfoKHR(reinterpret_cast<const VkVideoDecodeH265PictureInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR:
+                safe_pNext = new safe_VkVideoDecodeH265DpbSlotInfoKHR(reinterpret_cast<const VkVideoDecodeH265DpbSlotInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR:
+                safe_pNext = new safe_VkDeviceQueueGlobalPriorityCreateInfoKHR(reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR:
+                safe_pNext = new safe_VkQueueFamilyGlobalPriorityPropertiesKHR(reinterpret_cast<const VkQueueFamilyGlobalPriorityPropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
+                safe_pNext = new safe_VkFragmentShadingRateAttachmentInfoKHR(reinterpret_cast<const VkFragmentShadingRateAttachmentInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
+                safe_pNext = new safe_VkPipelineFragmentShadingRateStateCreateInfoKHR(reinterpret_cast<const VkPipelineFragmentShadingRateStateCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(reinterpret_cast<const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR:
+                safe_pNext = new safe_VkRenderingAttachmentLocationInfoKHR(reinterpret_cast<const VkRenderingAttachmentLocationInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR:
+                safe_pNext = new safe_VkRenderingInputAttachmentIndexInfoKHR(reinterpret_cast<const VkRenderingInputAttachmentIndexInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceShaderQuadControlFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:
+                safe_pNext = new safe_VkSurfaceProtectedCapabilitiesKHR(reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDevicePresentWaitFeaturesKHR(reinterpret_cast<const VkPhysicalDevicePresentWaitFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
+                safe_pNext = new safe_VkPipelineLibraryCreateInfoKHR(reinterpret_cast<const VkPipelineLibraryCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PRESENT_ID_KHR:
+                safe_pNext = new safe_VkPresentIdKHR(reinterpret_cast<const VkPresentIdKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDevicePresentIdFeaturesKHR(reinterpret_cast<const VkPhysicalDevicePresentIdFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR:
+                safe_pNext = new safe_VkVideoEncodeCapabilitiesKHR(reinterpret_cast<const VkVideoEncodeCapabilitiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR:
+                safe_pNext = new safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(reinterpret_cast<const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeUsageInfoKHR(reinterpret_cast<const VkVideoEncodeUsageInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeRateControlInfoKHR(reinterpret_cast<const VkVideoEncodeRateControlInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeQualityLevelInfoKHR(reinterpret_cast<const VkVideoEncodeQualityLevelInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
+                safe_pNext = new safe_VkQueueFamilyCheckpointProperties2NV(reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceMaintenance5FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceMaintenance5FeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceMaintenance5PropertiesKHR(reinterpret_cast<const VkPhysicalDeviceMaintenance5PropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR:
+                safe_pNext = new safe_VkPipelineCreateFlags2CreateInfoKHR(reinterpret_cast<const VkPipelineCreateFlags2CreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR:
+                safe_pNext = new safe_VkBufferUsageFlags2CreateInfoKHR(reinterpret_cast<const VkBufferUsageFlags2CreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR:
+                safe_pNext = new safe_VkVideoDecodeAV1ProfileInfoKHR(reinterpret_cast<const VkVideoDecodeAV1ProfileInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR:
+                safe_pNext = new safe_VkVideoDecodeAV1CapabilitiesKHR(reinterpret_cast<const VkVideoDecodeAV1CapabilitiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR:
+                safe_pNext = new safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR(reinterpret_cast<const VkVideoDecodeAV1SessionParametersCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR:
+                safe_pNext = new safe_VkVideoDecodeAV1PictureInfoKHR(reinterpret_cast<const VkVideoDecodeAV1PictureInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR:
+                safe_pNext = new safe_VkVideoDecodeAV1DpbSlotInfoKHR(reinterpret_cast<const VkVideoDecodeAV1DpbSlotInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR:
+                safe_pNext = new safe_VkVideoInlineQueryInfoKHR(reinterpret_cast<const VkVideoInlineQueryInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR(reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR:
+                safe_pNext = new safe_VkPipelineVertexInputDivisorStateCreateInfoKHR(reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceShaderFloatControls2FeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8FeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceLineRasterizationFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceLineRasterizationPropertiesKHR(reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR:
+                safe_pNext = new safe_VkPipelineRasterizationLineStateCreateInfoKHR(reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceMaintenance6FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceMaintenance6FeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceMaintenance6PropertiesKHR(reinterpret_cast<const VkPhysicalDeviceMaintenance6PropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR:
+                safe_pNext = new safe_VkBindMemoryStatusKHR(reinterpret_cast<const VkBindMemoryStatusKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkDebugReportCallbackCreateInfoEXT(reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
+                safe_pNext = new safe_VkPipelineRasterizationStateRasterizationOrderAMD(reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
+                safe_pNext = new safe_VkDedicatedAllocationImageCreateInfoNV(reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
+                safe_pNext = new safe_VkDedicatedAllocationBufferCreateInfoNV(reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
+                safe_pNext = new safe_VkDedicatedAllocationMemoryAllocateInfoNV(reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkPipelineRasterizationStateStreamCreateInfoEXT(reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
+                safe_pNext = new safe_VkTextureLODGatherFormatPropertiesAMD(reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceCornerSampledImageFeaturesNV(reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
+                safe_pNext = new safe_VkExternalMemoryImageCreateInfoNV(reinterpret_cast<const VkExternalMemoryImageCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
+                safe_pNext = new safe_VkExportMemoryAllocateInfoNV(reinterpret_cast<const VkExportMemoryAllocateInfoNV *>(pNext), copy_state, false);
+                break;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+            case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+                safe_pNext = new safe_VkImportMemoryWin32HandleInfoNV(reinterpret_cast<const VkImportMemoryWin32HandleInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+                safe_pNext = new safe_VkExportMemoryWin32HandleInfoNV(reinterpret_cast<const VkExportMemoryWin32HandleInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
+                safe_pNext = new safe_VkWin32KeyedMutexAcquireReleaseInfoNV(reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV *>(pNext), copy_state, false);
+                break;
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+            case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
+                safe_pNext = new safe_VkValidationFlagsEXT(reinterpret_cast<const VkValidationFlagsEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
+                safe_pNext = new safe_VkImageViewASTCDecodeModeEXT(reinterpret_cast<const VkImageViewASTCDecodeModeEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceASTCDecodeFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT(reinterpret_cast<const VkPhysicalDevicePipelineRobustnessFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT(reinterpret_cast<const VkPhysicalDevicePipelineRobustnessPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkPipelineRobustnessCreateInfoEXT(reinterpret_cast<const VkPipelineRobustnessCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
+                safe_pNext = new safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT(reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
+                safe_pNext = new safe_VkPipelineViewportWScalingStateCreateInfoNV(reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkSwapchainCounterCreateInfoEXT(reinterpret_cast<const VkSwapchainCounterCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
+                safe_pNext = new safe_VkPresentTimesInfoGOOGLE(reinterpret_cast<const VkPresentTimesInfoGOOGLE *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
+                safe_pNext = new safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
+                safe_pNext = new safe_VkPipelineViewportSwizzleStateCreateInfoNV(reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT(reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkPipelineDiscardRectangleStateCreateInfoEXT(reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkPipelineRasterizationConservativeStateCreateInfoEXT(reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT(reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG:
+                safe_pNext = new safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG(reinterpret_cast<const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
+                safe_pNext = new safe_VkDebugUtilsObjectNameInfoEXT(reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkDebugUtilsMessengerCreateInfoEXT(reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+            case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
+                safe_pNext = new safe_VkAndroidHardwareBufferUsageANDROID(reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
+                safe_pNext = new safe_VkAndroidHardwareBufferFormatPropertiesANDROID(reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
+                safe_pNext = new safe_VkImportAndroidHardwareBufferInfoANDROID(reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
+                safe_pNext = new safe_VkExternalFormatANDROID(reinterpret_cast<const VkExternalFormatANDROID *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID:
+                safe_pNext = new safe_VkAndroidHardwareBufferFormatProperties2ANDROID(reinterpret_cast<const VkAndroidHardwareBufferFormatProperties2ANDROID *>(pNext), copy_state, false);
+                break;
+#endif  // VK_USE_PLATFORM_ANDROID_KHR
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX:
+                safe_pNext = new safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX(reinterpret_cast<const VkPhysicalDeviceShaderEnqueueFeaturesAMDX *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX:
+                safe_pNext = new safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX(reinterpret_cast<const VkPhysicalDeviceShaderEnqueuePropertiesAMDX *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX:
+                safe_pNext = new safe_VkPipelineShaderStageNodeCreateInfoAMDX(reinterpret_cast<const VkPipelineShaderStageNodeCreateInfoAMDX *>(pNext), copy_state, false);
+                break;
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+            case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
+                safe_pNext = new safe_VkSampleLocationsInfoEXT(reinterpret_cast<const VkSampleLocationsInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
+                safe_pNext = new safe_VkRenderPassSampleLocationsBeginInfoEXT(reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkPipelineSampleLocationsStateCreateInfoEXT(reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceSampleLocationsPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT(reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
+                safe_pNext = new safe_VkPipelineCoverageToColorStateCreateInfoNV(reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
+                safe_pNext = new safe_VkPipelineCoverageModulationStateCreateInfoNV(reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
+                safe_pNext = new safe_VkDrmFormatModifierPropertiesListEXT(reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkImageDrmFormatModifierListCreateInfoEXT(reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkImageDrmFormatModifierExplicitCreateInfoEXT(reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
+                safe_pNext = new safe_VkDrmFormatModifierPropertiesList2EXT(reinterpret_cast<const VkDrmFormatModifierPropertiesList2EXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkShaderModuleValidationCacheCreateInfoEXT(reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
+                safe_pNext = new safe_VkPipelineViewportShadingRateImageStateCreateInfoNV(reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceShadingRateImageFeaturesNV(reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceShadingRateImagePropertiesNV(reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
+                safe_pNext = new safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
+                safe_pNext = new safe_VkWriteDescriptorSetAccelerationStructureNV(reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceRayTracingPropertiesNV(reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
+                safe_pNext = new safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceImageViewImageFormatInfoEXT(reinterpret_cast<const VkPhysicalDeviceImageViewImageFormatInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
+                safe_pNext = new safe_VkFilterCubicImageViewImageFormatPropertiesEXT(reinterpret_cast<const VkFilterCubicImageViewImageFormatPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
+                safe_pNext = new safe_VkImportMemoryHostPointerInfoEXT(reinterpret_cast<const VkImportMemoryHostPointerInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
+                safe_pNext = new safe_VkPipelineCompilerControlCreateInfoAMD(reinterpret_cast<const VkPipelineCompilerControlCreateInfoAMD *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
+                safe_pNext = new safe_VkPhysicalDeviceShaderCorePropertiesAMD(reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
+                safe_pNext = new safe_VkDeviceMemoryOverallocationCreateInfoAMD(reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *>(pNext), copy_state, false);
+                break;
+#ifdef VK_USE_PLATFORM_GGP
+            case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
+                safe_pNext = new safe_VkPresentFrameTokenGGP(reinterpret_cast<const VkPresentFrameTokenGGP *>(pNext), copy_state, false);
+                break;
+#endif  // VK_USE_PLATFORM_GGP
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceMeshShaderFeaturesNV(reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceMeshShaderPropertiesNV(reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV(reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
+                safe_pNext = new safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV(reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceExclusiveScissorFeaturesNV(reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
+                safe_pNext = new safe_VkQueueFamilyCheckpointPropertiesNV(reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
+                safe_pNext = new safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
+                safe_pNext = new safe_VkQueryPoolPerformanceQueryCreateInfoINTEL(reinterpret_cast<const VkQueryPoolPerformanceQueryCreateInfoINTEL *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDevicePCIBusInfoPropertiesEXT(reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD:
+                safe_pNext = new safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD(reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
+                safe_pNext = new safe_VkSwapchainDisplayNativeHdrCreateInfoAMD(reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkRenderPassFragmentDensityMapCreateInfoEXT(reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
+                safe_pNext = new safe_VkPhysicalDeviceShaderCoreProperties2AMD(reinterpret_cast<const VkPhysicalDeviceShaderCoreProperties2AMD *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
+                safe_pNext = new safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD(reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(reinterpret_cast<const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceMemoryBudgetPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
+                safe_pNext = new safe_VkMemoryPriorityAllocateInfoEXT(reinterpret_cast<const VkMemoryPriorityAllocateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkBufferDeviceAddressCreateInfoEXT(reinterpret_cast<const VkBufferDeviceAddressCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
+                safe_pNext = new safe_VkValidationFeaturesEXT(reinterpret_cast<const VkValidationFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV(reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
+                safe_pNext = new safe_VkPipelineCoverageReductionStateCreateInfoNV(reinterpret_cast<const VkPipelineCoverageReductionStateCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceProvokingVertexFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceProvokingVertexFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceProvokingVertexPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceProvokingVertexPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(reinterpret_cast<const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+            case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
+                safe_pNext = new safe_VkSurfaceFullScreenExclusiveInfoEXT(reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
+                safe_pNext = new safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT(reinterpret_cast<const VkSurfaceCapabilitiesFullScreenExclusiveEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
+                safe_pNext = new safe_VkSurfaceFullScreenExclusiveWin32InfoEXT(reinterpret_cast<const VkSurfaceFullScreenExclusiveWin32InfoEXT *>(pNext), copy_state, false);
+                break;
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceHostImageCopyFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceHostImageCopyFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceHostImageCopyPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceHostImageCopyPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT:
+                safe_pNext = new safe_VkSubresourceHostMemcpySizeEXT(reinterpret_cast<const VkSubresourceHostMemcpySizeEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT:
+                safe_pNext = new safe_VkHostImageCopyDevicePerformanceQueryEXT(reinterpret_cast<const VkHostImageCopyDevicePerformanceQueryEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT:
+                safe_pNext = new safe_VkMemoryMapPlacedInfoEXT(reinterpret_cast<const VkMemoryMapPlacedInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT:
+                safe_pNext = new safe_VkSurfacePresentModeEXT(reinterpret_cast<const VkSurfacePresentModeEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT:
+                safe_pNext = new safe_VkSurfacePresentScalingCapabilitiesEXT(reinterpret_cast<const VkSurfacePresentScalingCapabilitiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT:
+                safe_pNext = new safe_VkSurfacePresentModeCompatibilityEXT(reinterpret_cast<const VkSurfacePresentModeCompatibilityEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(reinterpret_cast<const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT:
+                safe_pNext = new safe_VkSwapchainPresentFenceInfoEXT(reinterpret_cast<const VkSwapchainPresentFenceInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkSwapchainPresentModesCreateInfoEXT(reinterpret_cast<const VkSwapchainPresentModesCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT:
+                safe_pNext = new safe_VkSwapchainPresentModeInfoEXT(reinterpret_cast<const VkSwapchainPresentModeInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkSwapchainPresentScalingCreateInfoEXT(reinterpret_cast<const VkSwapchainPresentScalingCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
+                safe_pNext = new safe_VkGraphicsPipelineShaderGroupsCreateInfoNV(reinterpret_cast<const VkGraphicsPipelineShaderGroupsCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(reinterpret_cast<const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
+                safe_pNext = new safe_VkCommandBufferInheritanceViewportScissorInfoNV(reinterpret_cast<const VkCommandBufferInheritanceViewportScissorInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
+                safe_pNext = new safe_VkRenderPassTransformBeginInfoQCOM(reinterpret_cast<const VkRenderPassTransformBeginInfoQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
+                safe_pNext = new safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(reinterpret_cast<const VkCommandBufferInheritanceRenderPassTransformInfoQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceDepthBiasControlFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT:
+                safe_pNext = new safe_VkDepthBiasRepresentationInfoEXT(reinterpret_cast<const VkDepthBiasRepresentationInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkDeviceDeviceMemoryReportCreateInfoEXT(reinterpret_cast<const VkDeviceDeviceMemoryReportCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceRobustness2FeaturesEXT(reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceRobustness2PropertiesEXT(reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkSamplerCustomBorderColorCreateInfoEXT(reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceCustomBorderColorPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceCustomBorderColorFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDevicePresentBarrierFeaturesNV(reinterpret_cast<const VkPhysicalDevicePresentBarrierFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV:
+                safe_pNext = new safe_VkSurfaceCapabilitiesPresentBarrierNV(reinterpret_cast<const VkSurfaceCapabilitiesPresentBarrierNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV:
+                safe_pNext = new safe_VkSwapchainPresentBarrierCreateInfoNV(reinterpret_cast<const VkSwapchainPresentBarrierCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(reinterpret_cast<const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
+                safe_pNext = new safe_VkDeviceDiagnosticsConfigCreateInfoNV(reinterpret_cast<const VkDeviceDiagnosticsConfigCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV(reinterpret_cast<const VkPhysicalDeviceCudaKernelLaunchFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV(reinterpret_cast<const VkPhysicalDeviceCudaKernelLaunchPropertiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV:
+                safe_pNext = new safe_VkQueryLowLatencySupportNV(reinterpret_cast<const VkQueryLowLatencySupportNV *>(pNext), copy_state, false);
+                break;
+#ifdef VK_USE_PLATFORM_METAL_EXT
+            case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkExportMetalObjectCreateInfoEXT(reinterpret_cast<const VkExportMetalObjectCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT:
+                safe_pNext = new safe_VkExportMetalDeviceInfoEXT(reinterpret_cast<const VkExportMetalDeviceInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT:
+                safe_pNext = new safe_VkExportMetalCommandQueueInfoEXT(reinterpret_cast<const VkExportMetalCommandQueueInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT:
+                safe_pNext = new safe_VkExportMetalBufferInfoEXT(reinterpret_cast<const VkExportMetalBufferInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT:
+                safe_pNext = new safe_VkImportMetalBufferInfoEXT(reinterpret_cast<const VkImportMetalBufferInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT:
+                safe_pNext = new safe_VkExportMetalTextureInfoEXT(reinterpret_cast<const VkExportMetalTextureInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT:
+                safe_pNext = new safe_VkImportMetalTextureInfoEXT(reinterpret_cast<const VkImportMetalTextureInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT:
+                safe_pNext = new safe_VkExportMetalIOSurfaceInfoEXT(reinterpret_cast<const VkExportMetalIOSurfaceInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT:
+                safe_pNext = new safe_VkImportMetalIOSurfaceInfoEXT(reinterpret_cast<const VkImportMetalIOSurfaceInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT:
+                safe_pNext = new safe_VkExportMetalSharedEventInfoEXT(reinterpret_cast<const VkExportMetalSharedEventInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT:
+                safe_pNext = new safe_VkImportMetalSharedEventInfoEXT(reinterpret_cast<const VkImportMetalSharedEventInfoEXT *>(pNext), copy_state, false);
+                break;
+#endif  // VK_USE_PLATFORM_METAL_EXT
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceDescriptorBufferPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceDescriptorBufferFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT:
+                safe_pNext = new safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(reinterpret_cast<const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT(reinterpret_cast<const VkOpaqueCaptureDescriptorDataCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkGraphicsPipelineLibraryCreateInfoEXT(reinterpret_cast<const VkGraphicsPipelineLibraryCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
+                safe_pNext = new safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(reinterpret_cast<const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(reinterpret_cast<const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
+                safe_pNext = new safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(reinterpret_cast<const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV:
+                safe_pNext = new safe_VkAccelerationStructureGeometryMotionTrianglesDataNV(reinterpret_cast<const VkAccelerationStructureGeometryMotionTrianglesDataNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV:
+                safe_pNext = new safe_VkAccelerationStructureMotionInfoNV(reinterpret_cast<const VkAccelerationStructureMotionInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(reinterpret_cast<const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(reinterpret_cast<const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
+                safe_pNext = new safe_VkCopyCommandTransformInfoQCOM(reinterpret_cast<const VkCopyCommandTransformInfoQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceImageCompressionControlFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
+                safe_pNext = new safe_VkImageCompressionControlEXT(reinterpret_cast<const VkImageCompressionControlEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
+                safe_pNext = new safe_VkImageCompressionPropertiesEXT(reinterpret_cast<const VkImageCompressionPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDevice4444FormatsFeaturesEXT(reinterpret_cast<const VkPhysicalDevice4444FormatsFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceFaultFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceFaultFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkMutableDescriptorTypeCreateInfoEXT(reinterpret_cast<const VkMutableDescriptorTypeCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceDrmPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceDrmPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceAddressBindingReportFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT:
+                safe_pNext = new safe_VkDeviceAddressBindingCallbackDataEXT(reinterpret_cast<const VkDeviceAddressBindingCallbackDataEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceDepthClipControlFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceDepthClipControlFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkPipelineViewportDepthClipControlCreateInfoEXT(reinterpret_cast<const VkPipelineViewportDepthClipControlCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(reinterpret_cast<const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *>(pNext), copy_state, false);
+                break;
+#ifdef VK_USE_PLATFORM_FUCHSIA
+            case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
+                safe_pNext = new safe_VkImportMemoryZirconHandleInfoFUCHSIA(reinterpret_cast<const VkImportMemoryZirconHandleInfoFUCHSIA *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA:
+                safe_pNext = new safe_VkImportMemoryBufferCollectionFUCHSIA(reinterpret_cast<const VkImportMemoryBufferCollectionFUCHSIA *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA:
+                safe_pNext = new safe_VkBufferCollectionImageCreateInfoFUCHSIA(reinterpret_cast<const VkBufferCollectionImageCreateInfoFUCHSIA *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA:
+                safe_pNext = new safe_VkBufferCollectionBufferCreateInfoFUCHSIA(reinterpret_cast<const VkBufferCollectionBufferCreateInfoFUCHSIA *>(pNext), copy_state, false);
+                break;
+#endif  // VK_USE_PLATFORM_FUCHSIA
+            case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI:
+                safe_pNext = new safe_VkSubpassShadingPipelineCreateInfoHUAWEI(reinterpret_cast<const VkSubpassShadingPipelineCreateInfoHUAWEI *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
+                safe_pNext = new safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(reinterpret_cast<const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
+                safe_pNext = new safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(reinterpret_cast<const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
+                safe_pNext = new safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(reinterpret_cast<const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(reinterpret_cast<const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT(reinterpret_cast<const VkPhysicalDevicePipelinePropertiesFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceFrameBoundaryFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT:
+                safe_pNext = new safe_VkFrameBoundaryEXT(reinterpret_cast<const VkFrameBoundaryEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT:
+                safe_pNext = new safe_VkSubpassResolvePerformanceQueryEXT(reinterpret_cast<const VkSubpassResolvePerformanceQueryEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT:
+                safe_pNext = new safe_VkMultisampledRenderToSingleSampledInfoEXT(reinterpret_cast<const VkMultisampledRenderToSingleSampledInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceColorWriteEnableFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkPipelineColorWriteCreateInfoEXT(reinterpret_cast<const VkPipelineColorWriteCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(reinterpret_cast<const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceImageViewMinLodFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkImageViewMinLodCreateInfoEXT(reinterpret_cast<const VkImageViewMinLodCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceMultiDrawFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceMultiDrawFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceMultiDrawPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceMultiDrawPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceShaderTileImageFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceShaderTileImageFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceShaderTileImagePropertiesEXT(reinterpret_cast<const VkPhysicalDeviceShaderTileImagePropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceOpacityMicromapFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceOpacityMicromapPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT:
+                safe_pNext = new safe_VkAccelerationStructureTrianglesOpacityMicromapEXT(reinterpret_cast<const VkAccelerationStructureTrianglesOpacityMicromapEXT *>(pNext), copy_state, false);
+                break;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV(reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV(reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapPropertiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV:
+                safe_pNext = new safe_VkAccelerationStructureTrianglesDisplacementMicromapNV(reinterpret_cast<const VkAccelerationStructureTrianglesDisplacementMicromapNV *>(pNext), copy_state, false);
+                break;
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI:
+                safe_pNext = new safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI:
+                safe_pNext = new safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI:
+                safe_pNext = new safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI(reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkSamplerBorderColorComponentMappingCreateInfoEXT(reinterpret_cast<const VkSamplerBorderColorComponentMappingCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(reinterpret_cast<const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM:
+                safe_pNext = new safe_VkPhysicalDeviceShaderCorePropertiesARM(reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesARM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM:
+                safe_pNext = new safe_VkDeviceQueueShaderCoreControlCreateInfoARM(reinterpret_cast<const VkDeviceQueueShaderCoreControlCreateInfoARM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM:
+                safe_pNext = new safe_VkPhysicalDeviceSchedulingControlsFeaturesARM(reinterpret_cast<const VkPhysicalDeviceSchedulingControlsFeaturesARM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM:
+                safe_pNext = new safe_VkPhysicalDeviceSchedulingControlsPropertiesARM(reinterpret_cast<const VkPhysicalDeviceSchedulingControlsPropertiesARM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkImageViewSlicedCreateInfoEXT(reinterpret_cast<const VkImageViewSlicedCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
+                safe_pNext = new safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(reinterpret_cast<const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM:
+                safe_pNext = new safe_VkPhysicalDeviceRenderPassStripedFeaturesARM(reinterpret_cast<const VkPhysicalDeviceRenderPassStripedFeaturesARM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM:
+                safe_pNext = new safe_VkPhysicalDeviceRenderPassStripedPropertiesARM(reinterpret_cast<const VkPhysicalDeviceRenderPassStripedPropertiesARM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM:
+                safe_pNext = new safe_VkRenderPassStripeBeginInfoARM(reinterpret_cast<const VkRenderPassStripeBeginInfoARM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM:
+                safe_pNext = new safe_VkRenderPassStripeSubmitInfoARM(reinterpret_cast<const VkRenderPassStripeSubmitInfoARM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
+                safe_pNext = new safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM:
+                safe_pNext = new safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM:
+                safe_pNext = new safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(reinterpret_cast<const VkSubpassFragmentDensityMapOffsetEndInfoQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV(reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV(reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionPropertiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV(reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV:
+                safe_pNext = new safe_VkComputePipelineIndirectBufferInfoNV(reinterpret_cast<const VkComputePipelineIndirectBufferInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(reinterpret_cast<const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM:
+                safe_pNext = new safe_VkImageViewSampleWeightCreateInfoQCOM(reinterpret_cast<const VkImageViewSampleWeightCreateInfoQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
+                safe_pNext = new safe_VkPhysicalDeviceImageProcessingFeaturesQCOM(reinterpret_cast<const VkPhysicalDeviceImageProcessingFeaturesQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM:
+                safe_pNext = new safe_VkPhysicalDeviceImageProcessingPropertiesQCOM(reinterpret_cast<const VkPhysicalDeviceImageProcessingPropertiesQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceNestedCommandBufferFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceNestedCommandBufferPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT:
+                safe_pNext = new safe_VkExternalMemoryAcquireUnmodifiedEXT(reinterpret_cast<const VkExternalMemoryAcquireUnmodifiedEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT:
+                safe_pNext = new safe_VkRenderPassCreationControlEXT(reinterpret_cast<const VkRenderPassCreationControlEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkRenderPassCreationFeedbackCreateInfoEXT(reinterpret_cast<const VkRenderPassCreationFeedbackCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkRenderPassSubpassFeedbackCreateInfoEXT(reinterpret_cast<const VkRenderPassSubpassFeedbackCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG:
+                safe_pNext = new safe_VkDirectDriverLoadingListLUNARG(reinterpret_cast<const VkDirectDriverLoadingListLUNARG *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(reinterpret_cast<const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceOpticalFlowFeaturesNV(reinterpret_cast<const VkPhysicalDeviceOpticalFlowFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceOpticalFlowPropertiesNV(reinterpret_cast<const VkPhysicalDeviceOpticalFlowPropertiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV:
+                safe_pNext = new safe_VkOpticalFlowImageFormatInfoNV(reinterpret_cast<const VkOpticalFlowImageFormatInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV:
+                safe_pNext = new safe_VkOpticalFlowSessionCreatePrivateDataInfoNV(reinterpret_cast<const VkOpticalFlowSessionCreatePrivateDataInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceLegacyDitheringFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(reinterpret_cast<const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *>(pNext), copy_state, false);
+                break;
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID:
+                safe_pNext = new safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID(reinterpret_cast<const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID:
+                safe_pNext = new safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID(reinterpret_cast<const VkPhysicalDeviceExternalFormatResolvePropertiesANDROID *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID:
+                safe_pNext = new safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID(reinterpret_cast<const VkAndroidHardwareBufferFormatResolvePropertiesANDROID *>(pNext), copy_state, false);
+                break;
+#endif  // VK_USE_PLATFORM_ANDROID_KHR
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceShaderObjectFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceShaderObjectFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceShaderObjectPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceShaderObjectPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
+                safe_pNext = new safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM(reinterpret_cast<const VkPhysicalDeviceTilePropertiesFeaturesQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC:
+                safe_pNext = new safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC(reinterpret_cast<const VkPhysicalDeviceAmigoProfilingFeaturesSEC *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC:
+                safe_pNext = new safe_VkAmigoProfilingSubmitInfoSEC(reinterpret_cast<const VkAmigoProfilingSubmitInfoSEC *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
+                safe_pNext = new safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV(reinterpret_cast<const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV(reinterpret_cast<const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkLayerSettingsCreateInfoEXT(reinterpret_cast<const VkLayerSettingsCreateInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
+                safe_pNext = new safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM:
+                safe_pNext = new safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(reinterpret_cast<const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV:
+                safe_pNext = new safe_VkLatencySubmissionPresentIdNV(reinterpret_cast<const VkLatencySubmissionPresentIdNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV:
+                safe_pNext = new safe_VkSwapchainLatencyCreateInfoNV(reinterpret_cast<const VkSwapchainLatencyCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV:
+                safe_pNext = new safe_VkLatencySurfaceCapabilitiesNV(reinterpret_cast<const VkLatencySurfaceCapabilitiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM:
+                safe_pNext = new safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM:
+                safe_pNext = new safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(reinterpret_cast<const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV(reinterpret_cast<const VkPhysicalDevicePerStageDescriptorSetFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM:
+                safe_pNext = new safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM(reinterpret_cast<const VkPhysicalDeviceImageProcessing2FeaturesQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM:
+                safe_pNext = new safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM(reinterpret_cast<const VkPhysicalDeviceImageProcessing2PropertiesQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM:
+                safe_pNext = new safe_VkSamplerBlockMatchWindowCreateInfoQCOM(reinterpret_cast<const VkSamplerBlockMatchWindowCreateInfoQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM:
+                safe_pNext = new safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM(reinterpret_cast<const VkPhysicalDeviceCubicWeightsFeaturesQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM:
+                safe_pNext = new safe_VkSamplerCubicWeightsCreateInfoQCOM(reinterpret_cast<const VkSamplerCubicWeightsCreateInfoQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM:
+                safe_pNext = new safe_VkBlitImageCubicWeightsInfoQCOM(reinterpret_cast<const VkBlitImageCubicWeightsInfoQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM:
+                safe_pNext = new safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM(reinterpret_cast<const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM:
+                safe_pNext = new safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM(reinterpret_cast<const VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM:
+                safe_pNext = new safe_VkPhysicalDeviceCubicClampFeaturesQCOM(reinterpret_cast<const VkPhysicalDeviceCubicClampFeaturesQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *>(pNext), copy_state, false);
+                break;
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+            case VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX:
+                safe_pNext = new safe_VkScreenBufferFormatPropertiesQNX(reinterpret_cast<const VkScreenBufferFormatPropertiesQNX *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX:
+                safe_pNext = new safe_VkImportScreenBufferInfoQNX(reinterpret_cast<const VkImportScreenBufferInfoQNX *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX:
+                safe_pNext = new safe_VkExternalFormatQNX(reinterpret_cast<const VkExternalFormatQNX *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX:
+                safe_pNext = new safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX(reinterpret_cast<const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX *>(pNext), copy_state, false);
+                break;
+#endif  // VK_USE_PLATFORM_SCREEN_QNX
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT:
+                safe_pNext = new safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT(reinterpret_cast<const VkPhysicalDeviceLayeredDriverPropertiesMSFT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV(reinterpret_cast<const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceRawAccessChainsFeaturesNV(reinterpret_cast<const VkPhysicalDeviceRawAccessChainsFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV(reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceRayTracingValidationFeaturesNV(reinterpret_cast<const VkPhysicalDeviceRayTracingValidationFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
+                safe_pNext = new safe_VkWriteDescriptorSetAccelerationStructureKHR(reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceAccelerationStructureFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR(reinterpret_cast<const VkPhysicalDeviceAccelerationStructurePropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(reinterpret_cast<const VkPhysicalDeviceRayTracingPipelinePropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceRayQueryFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceRayQueryFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceMeshShaderFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceMeshShaderPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesEXT *>(pNext), copy_state, false);
+                break;
+
+            default: // Encountered an unknown sType -- skip (do not copy) this entry in the chain
+                // If sType is in custom list, construct blind copy
+                for (auto item : custom_stype_info) {
+                    if (item.first == static_cast<uint32_t>(header->sType)) {
+                        safe_pNext = malloc(item.second);
+                        memcpy(safe_pNext, header, item.second);
+                    }
+                }
+                break;
+        }
+        if (!first_pNext) {
+            first_pNext = safe_pNext;
+        }
+        pNext = header->pNext;
+        if (prev_pNext && safe_pNext) {
+            prev_pNext->pNext = (VkBaseOutStructure*)safe_pNext;
+        }
+        if (safe_pNext) {
+            prev_pNext = (VkBaseOutStructure*)safe_pNext;
+        }
+        safe_pNext = nullptr;
+    }
+
+    return first_pNext;
+}
+
+void FreePnextChain(const void *pNext) {
+    if (!pNext) return;
+
+    auto header = reinterpret_cast<const VkBaseOutStructure *>(pNext);
+
+    switch (header->sType) {
+        // Special-case Loader Instance Struct passed to/from layer in pNext chain
+        case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:
+            FreePnextChain(header->pNext);
+            delete reinterpret_cast<const VkLayerInstanceCreateInfo *>(pNext);
+            break;
+        // Special-case Loader Device Struct passed to/from layer in pNext chain
+        case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:
+            FreePnextChain(header->pNext);
+            delete reinterpret_cast<const VkLayerDeviceCreateInfo *>(pNext);
+            break;
+        case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkShaderModuleCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkPipelineLayoutCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceSubgroupProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDevice16BitStorageFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
+            delete reinterpret_cast<const safe_VkMemoryDedicatedRequirements *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
+            delete reinterpret_cast<const safe_VkMemoryDedicatedAllocateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
+            delete reinterpret_cast<const safe_VkMemoryAllocateFlagsInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
+            delete reinterpret_cast<const safe_VkDeviceGroupRenderPassBeginInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
+            delete reinterpret_cast<const safe_VkDeviceGroupCommandBufferBeginInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
+            delete reinterpret_cast<const safe_VkDeviceGroupSubmitInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
+            delete reinterpret_cast<const safe_VkDeviceGroupBindSparseInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
+            delete reinterpret_cast<const safe_VkBindBufferMemoryDeviceGroupInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
+            delete reinterpret_cast<const safe_VkBindImageMemoryDeviceGroupInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkDeviceGroupDeviceCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceFeatures2 *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
+            delete reinterpret_cast<const safe_VkPhysicalDevicePointClippingProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkRenderPassInputAttachmentAspectCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkImageViewUsageCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkPipelineTessellationDomainOriginStateCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkRenderPassMultiviewCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMultiviewFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMultiviewProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceVariablePointersFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceProtectedMemoryFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceProtectedMemoryProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
+            delete reinterpret_cast<const safe_VkProtectedSubmitInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
+            delete reinterpret_cast<const safe_VkSamplerYcbcrConversionInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
+            delete reinterpret_cast<const safe_VkBindImagePlaneMemoryInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
+            delete reinterpret_cast<const safe_VkImagePlaneMemoryRequirementsInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
+            delete reinterpret_cast<const safe_VkSamplerYcbcrConversionImageFormatProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceExternalImageFormatInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
+            delete reinterpret_cast<const safe_VkExternalImageFormatProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceIDProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkExternalMemoryImageCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkExternalMemoryBufferCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
+            delete reinterpret_cast<const safe_VkExportMemoryAllocateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkExportFenceCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkExportSemaphoreCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMaintenance3Properties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderDrawParametersFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceVulkan11Features *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceVulkan11Properties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceVulkan12Features *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceVulkan12Properties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkImageFormatListCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDevice8BitStorageFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDriverProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderAtomicInt64Features *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderFloat16Int8Features *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceFloatControlsProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkDescriptorSetLayoutBindingFlagsCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDescriptorIndexingFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDescriptorIndexingProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
+            delete reinterpret_cast<const safe_VkDescriptorSetVariableDescriptorCountAllocateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
+            delete reinterpret_cast<const safe_VkDescriptorSetVariableDescriptorCountLayoutSupport *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
+            delete reinterpret_cast<const safe_VkSubpassDescriptionDepthStencilResolve *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDepthStencilResolveProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceScalarBlockLayoutFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkImageStencilUsageCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkSamplerReductionModeCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceSamplerFilterMinmaxProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceVulkanMemoryModelFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceImagelessFramebufferFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkFramebufferAttachmentsCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
+            delete reinterpret_cast<const safe_VkRenderPassAttachmentBeginInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
+            delete reinterpret_cast<const safe_VkAttachmentReferenceStencilLayout *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
+            delete reinterpret_cast<const safe_VkAttachmentDescriptionStencilLayout *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceHostQueryResetFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceTimelineSemaphoreFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceTimelineSemaphoreProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkSemaphoreTypeCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
+            delete reinterpret_cast<const safe_VkTimelineSemaphoreSubmitInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceBufferDeviceAddressFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkBufferOpaqueCaptureAddressCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
+            delete reinterpret_cast<const safe_VkMemoryOpaqueCaptureAddressAllocateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceVulkan13Features *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceVulkan13Properties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkPipelineCreationFeedbackCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderTerminateInvocationFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDevicePrivateDataFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkDevicePrivateDataCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDevicePipelineCreationCacheControlFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2:
+            delete reinterpret_cast<const safe_VkMemoryBarrier2 *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceSynchronization2Features *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceImageRobustnessFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceSubgroupSizeControlFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceSubgroupSizeControlProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceInlineUniformBlockFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceInlineUniformBlockProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK:
+            delete reinterpret_cast<const safe_VkWriteDescriptorSetInlineUniformBlock *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkDescriptorPoolInlineUniformBlockCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkPipelineRenderingCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDynamicRenderingFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO:
+            delete reinterpret_cast<const safe_VkCommandBufferInheritanceRenderingInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderIntegerDotProductFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderIntegerDotProductProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceTexelBufferAlignmentProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
+            delete reinterpret_cast<const safe_VkFormatProperties3 *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMaintenance4Features *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMaintenance4Properties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkImageSwapchainCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
+            delete reinterpret_cast<const safe_VkBindImageMemorySwapchainInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
+            delete reinterpret_cast<const safe_VkDeviceGroupPresentInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkDeviceGroupSwapchainCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
+            delete reinterpret_cast<const safe_VkDisplayPresentInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR:
+            delete reinterpret_cast<const safe_VkQueueFamilyQueryResultStatusPropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR:
+            delete reinterpret_cast<const safe_VkQueueFamilyVideoPropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoProfileInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoProfileListInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR:
+            delete reinterpret_cast<const safe_VkVideoDecodeCapabilitiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoDecodeUsageInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR:
+            delete reinterpret_cast<const safe_VkVideoEncodeH264CapabilitiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR:
+            delete reinterpret_cast<const safe_VkVideoEncodeH264QualityLevelPropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoEncodeH264SessionCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoEncodeH264SessionParametersAddInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoEncodeH264SessionParametersCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoEncodeH264SessionParametersGetInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoEncodeH264PictureInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoEncodeH264DpbSlotInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoEncodeH264ProfileInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoEncodeH264RateControlInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoEncodeH264RateControlLayerInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoEncodeH264GopRemainingFrameInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR:
+            delete reinterpret_cast<const safe_VkVideoEncodeH265CapabilitiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoEncodeH265SessionCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR:
+            delete reinterpret_cast<const safe_VkVideoEncodeH265QualityLevelPropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoEncodeH265SessionParametersAddInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoEncodeH265SessionParametersCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoEncodeH265SessionParametersGetInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoEncodeH265PictureInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoEncodeH265DpbSlotInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoEncodeH265ProfileInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoEncodeH265RateControlInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoEncodeH265RateControlLayerInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoEncodeH265GopRemainingFrameInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoDecodeH264ProfileInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR:
+            delete reinterpret_cast<const safe_VkVideoDecodeH264CapabilitiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoDecodeH264SessionParametersAddInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoDecodeH264SessionParametersCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoDecodeH264PictureInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoDecodeH264DpbSlotInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
+            delete reinterpret_cast<const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
+            delete reinterpret_cast<const safe_VkRenderingFragmentDensityMapAttachmentInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
+            delete reinterpret_cast<const safe_VkAttachmentSampleCountInfoAMD *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
+            delete reinterpret_cast<const safe_VkMultiviewPerViewAttributesInfoNVX *>(header);
+            break;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkImportMemoryWin32HandleInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkExportMemoryWin32HandleInfoKHR *>(header);
+            break;
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
+            delete reinterpret_cast<const safe_VkImportMemoryFdInfoKHR *>(header);
+            break;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkExportSemaphoreWin32HandleInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
+            delete reinterpret_cast<const safe_VkD3D12FenceSubmitInfoKHR *>(header);
+            break;
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDevicePushDescriptorPropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
+            delete reinterpret_cast<const safe_VkPresentRegionsKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
+            delete reinterpret_cast<const safe_VkSharedPresentSurfaceCapabilitiesKHR *>(header);
+            break;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkExportFenceWin32HandleInfoKHR *>(header);
+            break;
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkQueryPoolPerformanceCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
+            delete reinterpret_cast<const safe_VkPerformanceQuerySubmitInfoKHR *>(header);
+            break;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR *>(header);
+            break;
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderClockFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoDecodeH265ProfileInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR:
+            delete reinterpret_cast<const safe_VkVideoDecodeH265CapabilitiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoDecodeH265SessionParametersAddInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoDecodeH265SessionParametersCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoDecodeH265PictureInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoDecodeH265DpbSlotInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkDeviceQueueGlobalPriorityCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR:
+            delete reinterpret_cast<const safe_VkQueueFamilyGlobalPriorityPropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
+            delete reinterpret_cast<const safe_VkFragmentShadingRateAttachmentInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR:
+            delete reinterpret_cast<const safe_VkRenderingAttachmentLocationInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR:
+            delete reinterpret_cast<const safe_VkRenderingInputAttachmentIndexInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:
+            delete reinterpret_cast<const safe_VkSurfaceProtectedCapabilitiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDevicePresentWaitFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkPipelineLibraryCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PRESENT_ID_KHR:
+            delete reinterpret_cast<const safe_VkPresentIdKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDevicePresentIdFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR:
+            delete reinterpret_cast<const safe_VkVideoEncodeCapabilitiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoEncodeUsageInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoEncodeRateControlInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoEncodeQualityLevelInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
+            delete reinterpret_cast<const safe_VkQueueFamilyCheckpointProperties2NV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMaintenance5FeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMaintenance5PropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkPipelineCreateFlags2CreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkBufferUsageFlags2CreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoDecodeAV1ProfileInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR:
+            delete reinterpret_cast<const safe_VkVideoDecodeAV1CapabilitiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoDecodeAV1PictureInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoDecodeAV1DpbSlotInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR:
+            delete reinterpret_cast<const safe_VkVideoInlineQueryInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceLineRasterizationFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceLineRasterizationPropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkPipelineRasterizationLineStateCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMaintenance6FeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMaintenance6PropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR:
+            delete reinterpret_cast<const safe_VkBindMemoryStatusKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkDebugReportCallbackCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
+            delete reinterpret_cast<const safe_VkPipelineRasterizationStateRasterizationOrderAMD *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkDedicatedAllocationImageCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkDedicatedAllocationBufferCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkDedicatedAllocationMemoryAllocateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkPipelineRasterizationStateStreamCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
+            delete reinterpret_cast<const safe_VkTextureLODGatherFormatPropertiesAMD *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceCornerSampledImageFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkExternalMemoryImageCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkExportMemoryAllocateInfoNV *>(header);
+            break;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+            delete reinterpret_cast<const safe_VkImportMemoryWin32HandleInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+            delete reinterpret_cast<const safe_VkExportMemoryWin32HandleInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
+            delete reinterpret_cast<const safe_VkWin32KeyedMutexAcquireReleaseInfoNV *>(header);
+            break;
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
+            delete reinterpret_cast<const safe_VkValidationFlagsEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
+            delete reinterpret_cast<const safe_VkImageViewASTCDecodeModeEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceASTCDecodeFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkPipelineRobustnessCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
+            delete reinterpret_cast<const safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkPipelineViewportWScalingStateCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkSwapchainCounterCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
+            delete reinterpret_cast<const safe_VkPresentTimesInfoGOOGLE *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkPipelineViewportSwizzleStateCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkPipelineDiscardRectangleStateCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkPipelineRasterizationConservativeStateCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
+            delete reinterpret_cast<const safe_VkDebugUtilsObjectNameInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkDebugUtilsMessengerCreateInfoEXT *>(header);
+            break;
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
+            delete reinterpret_cast<const safe_VkAndroidHardwareBufferUsageANDROID *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
+            delete reinterpret_cast<const safe_VkAndroidHardwareBufferFormatPropertiesANDROID *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
+            delete reinterpret_cast<const safe_VkImportAndroidHardwareBufferInfoANDROID *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
+            delete reinterpret_cast<const safe_VkExternalFormatANDROID *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID:
+            delete reinterpret_cast<const safe_VkAndroidHardwareBufferFormatProperties2ANDROID *>(header);
+            break;
+#endif  // VK_USE_PLATFORM_ANDROID_KHR
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX:
+            delete reinterpret_cast<const safe_VkPipelineShaderStageNodeCreateInfoAMDX *>(header);
+            break;
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
+            delete reinterpret_cast<const safe_VkSampleLocationsInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
+            delete reinterpret_cast<const safe_VkRenderPassSampleLocationsBeginInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkPipelineSampleLocationsStateCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceSampleLocationsPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkPipelineCoverageToColorStateCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkPipelineCoverageModulationStateCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
+            delete reinterpret_cast<const safe_VkDrmFormatModifierPropertiesListEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkImageDrmFormatModifierListCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkImageDrmFormatModifierExplicitCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
+            delete reinterpret_cast<const safe_VkDrmFormatModifierPropertiesList2EXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkShaderModuleValidationCacheCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkPipelineViewportShadingRateImageStateCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShadingRateImageFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShadingRateImagePropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
+            delete reinterpret_cast<const safe_VkWriteDescriptorSetAccelerationStructureNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceRayTracingPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceImageViewImageFormatInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkFilterCubicImageViewImageFormatPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
+            delete reinterpret_cast<const safe_VkImportMemoryHostPointerInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
+            delete reinterpret_cast<const safe_VkPipelineCompilerControlCreateInfoAMD *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderCorePropertiesAMD *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
+            delete reinterpret_cast<const safe_VkDeviceMemoryOverallocationCreateInfoAMD *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *>(header);
+            break;
+#ifdef VK_USE_PLATFORM_GGP
+        case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
+            delete reinterpret_cast<const safe_VkPresentFrameTokenGGP *>(header);
+            break;
+#endif  // VK_USE_PLATFORM_GGP
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMeshShaderFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMeshShaderPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceExclusiveScissorFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
+            delete reinterpret_cast<const safe_VkQueueFamilyCheckpointPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
+            delete reinterpret_cast<const safe_VkQueryPoolPerformanceQueryCreateInfoINTEL *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDevicePCIBusInfoPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD:
+            delete reinterpret_cast<const safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
+            delete reinterpret_cast<const safe_VkSwapchainDisplayNativeHdrCreateInfoAMD *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkRenderPassFragmentDensityMapCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderCoreProperties2AMD *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkMemoryPriorityAllocateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkBufferDeviceAddressCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkValidationFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkPipelineCoverageReductionStateCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceProvokingVertexFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceProvokingVertexPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *>(header);
+            break;
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkSurfaceFullScreenExclusiveInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
+            delete reinterpret_cast<const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
+            delete reinterpret_cast<const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT *>(header);
+            break;
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceHostImageCopyFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceHostImageCopyPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT:
+            delete reinterpret_cast<const safe_VkSubresourceHostMemcpySizeEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT:
+            delete reinterpret_cast<const safe_VkHostImageCopyDevicePerformanceQueryEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT:
+            delete reinterpret_cast<const safe_VkMemoryMapPlacedInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT:
+            delete reinterpret_cast<const safe_VkSurfacePresentModeEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT:
+            delete reinterpret_cast<const safe_VkSurfacePresentScalingCapabilitiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT:
+            delete reinterpret_cast<const safe_VkSurfacePresentModeCompatibilityEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkSwapchainPresentFenceInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkSwapchainPresentModesCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkSwapchainPresentModeInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkSwapchainPresentScalingCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkGraphicsPipelineShaderGroupsCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
+            delete reinterpret_cast<const safe_VkCommandBufferInheritanceViewportScissorInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
+            delete reinterpret_cast<const safe_VkRenderPassTransformBeginInfoQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
+            delete reinterpret_cast<const safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT:
+            delete reinterpret_cast<const safe_VkDepthBiasRepresentationInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkDeviceDeviceMemoryReportCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceRobustness2FeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceRobustness2PropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkSamplerCustomBorderColorCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDevicePresentBarrierFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV:
+            delete reinterpret_cast<const safe_VkSurfaceCapabilitiesPresentBarrierNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkSwapchainPresentBarrierCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkDeviceDiagnosticsConfigCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV:
+            delete reinterpret_cast<const safe_VkQueryLowLatencySupportNV *>(header);
+            break;
+#ifdef VK_USE_PLATFORM_METAL_EXT
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkExportMetalObjectCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkExportMetalDeviceInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkExportMetalCommandQueueInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT:
+            delete reinterpret_cast<const safe_VkExportMetalBufferInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT:
+            delete reinterpret_cast<const safe_VkImportMetalBufferInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkExportMetalTextureInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkImportMetalTextureInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkExportMetalIOSurfaceInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkImportMetalIOSurfaceInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT:
+            delete reinterpret_cast<const safe_VkExportMetalSharedEventInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT:
+            delete reinterpret_cast<const safe_VkImportMetalSharedEventInfoEXT *>(header);
+            break;
+#endif  // VK_USE_PLATFORM_METAL_EXT
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT:
+            delete reinterpret_cast<const safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkGraphicsPipelineLibraryCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV:
+            delete reinterpret_cast<const safe_VkAccelerationStructureGeometryMotionTrianglesDataNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV:
+            delete reinterpret_cast<const safe_VkAccelerationStructureMotionInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
+            delete reinterpret_cast<const safe_VkCopyCommandTransformInfoQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
+            delete reinterpret_cast<const safe_VkImageCompressionControlEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkImageCompressionPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDevice4444FormatsFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceFaultFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkMutableDescriptorTypeCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDrmPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT:
+            delete reinterpret_cast<const safe_VkDeviceAddressBindingCallbackDataEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDepthClipControlFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkPipelineViewportDepthClipControlCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *>(header);
+            break;
+#ifdef VK_USE_PLATFORM_FUCHSIA
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
+            delete reinterpret_cast<const safe_VkImportMemoryZirconHandleInfoFUCHSIA *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA:
+            delete reinterpret_cast<const safe_VkImportMemoryBufferCollectionFUCHSIA *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA:
+            delete reinterpret_cast<const safe_VkBufferCollectionImageCreateInfoFUCHSIA *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA:
+            delete reinterpret_cast<const safe_VkBufferCollectionBufferCreateInfoFUCHSIA *>(header);
+            break;
+#endif  // VK_USE_PLATFORM_FUCHSIA
+        case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI:
+            delete reinterpret_cast<const safe_VkSubpassShadingPipelineCreateInfoHUAWEI *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT:
+            delete reinterpret_cast<const safe_VkFrameBoundaryEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT:
+            delete reinterpret_cast<const safe_VkSubpassResolvePerformanceQueryEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT:
+            delete reinterpret_cast<const safe_VkMultisampledRenderToSingleSampledInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkPipelineColorWriteCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkImageViewMinLodCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMultiDrawFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMultiDrawPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderTileImageFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderTileImagePropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT:
+            delete reinterpret_cast<const safe_VkAccelerationStructureTrianglesOpacityMicromapEXT *>(header);
+            break;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV:
+            delete reinterpret_cast<const safe_VkAccelerationStructureTrianglesDisplacementMicromapNV *>(header);
+            break;
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkSamplerBorderColorComponentMappingCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderCorePropertiesARM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM:
+            delete reinterpret_cast<const safe_VkDeviceQueueShaderCoreControlCreateInfoARM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceSchedulingControlsFeaturesARM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceSchedulingControlsPropertiesARM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkImageViewSlicedCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceRenderPassStripedFeaturesARM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceRenderPassStripedPropertiesARM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM:
+            delete reinterpret_cast<const safe_VkRenderPassStripeBeginInfoARM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM:
+            delete reinterpret_cast<const safe_VkRenderPassStripeSubmitInfoARM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM:
+            delete reinterpret_cast<const safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV:
+            delete reinterpret_cast<const safe_VkComputePipelineIndirectBufferInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM:
+            delete reinterpret_cast<const safe_VkImageViewSampleWeightCreateInfoQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceImageProcessingFeaturesQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceImageProcessingPropertiesQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT:
+            delete reinterpret_cast<const safe_VkExternalMemoryAcquireUnmodifiedEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT:
+            delete reinterpret_cast<const safe_VkRenderPassCreationControlEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkRenderPassCreationFeedbackCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkRenderPassSubpassFeedbackCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG:
+            delete reinterpret_cast<const safe_VkDirectDriverLoadingListLUNARG *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceOpticalFlowFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceOpticalFlowPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV:
+            delete reinterpret_cast<const safe_VkOpticalFlowImageFormatInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV:
+            delete reinterpret_cast<const safe_VkOpticalFlowSessionCreatePrivateDataInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *>(header);
+            break;
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID:
+            delete reinterpret_cast<const safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID *>(header);
+            break;
+#endif  // VK_USE_PLATFORM_ANDROID_KHR
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderObjectFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderObjectPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC:
+            delete reinterpret_cast<const safe_VkAmigoProfilingSubmitInfoSEC *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkLayerSettingsCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV:
+            delete reinterpret_cast<const safe_VkLatencySubmissionPresentIdNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkSwapchainLatencyCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV:
+            delete reinterpret_cast<const safe_VkLatencySurfaceCapabilitiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM:
+            delete reinterpret_cast<const safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM:
+            delete reinterpret_cast<const safe_VkSamplerBlockMatchWindowCreateInfoQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM:
+            delete reinterpret_cast<const safe_VkSamplerCubicWeightsCreateInfoQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM:
+            delete reinterpret_cast<const safe_VkBlitImageCubicWeightsInfoQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM:
+            delete reinterpret_cast<const safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceCubicClampFeaturesQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *>(header);
+            break;
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+        case VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX:
+            delete reinterpret_cast<const safe_VkScreenBufferFormatPropertiesQNX *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX:
+            delete reinterpret_cast<const safe_VkImportScreenBufferInfoQNX *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX:
+            delete reinterpret_cast<const safe_VkExternalFormatQNX *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX *>(header);
+            break;
+#endif  // VK_USE_PLATFORM_SCREEN_QNX
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceRawAccessChainsFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceRayTracingValidationFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
+            delete reinterpret_cast<const safe_VkWriteDescriptorSetAccelerationStructureKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceRayQueryFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMeshShaderFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMeshShaderPropertiesEXT *>(header);
+            break;
+
+        default: // Encountered an unknown sType
+            // If sType is in custom list, free custom struct memory and clean up
+            for (auto item : custom_stype_info) {
+                if (item.first == static_cast<uint32_t>(header->sType)) {
+                    if (header->pNext) {
+                        FreePnextChain(header->pNext);
+                    }
+                    free(const_cast<void *>(pNext));
+                    pNext = nullptr;
+                    break;
+                }
+            }
+            if (pNext) {
+                FreePnextChain(header->pNext);
+            }
+            break;
+    }
+}  // clang-format on
+
+}  // namespace vku
+
+// NOLINTEND
diff --git a/src/vulkan/vk_safe_struct_vendor.cpp b/src/vulkan/vk_safe_struct_vendor.cpp
new file mode 100644
index 0000000..6054229
--- /dev/null
+++ b/src/vulkan/vk_safe_struct_vendor.cpp
@@ -0,0 +1,15191 @@
+// *** THIS FILE IS GENERATED - DO NOT EDIT ***
+// See safe_struct_generator.py for modifications
+
+/***************************************************************************
+ *
+ * Copyright (c) 2015-2024 The Khronos Group Inc.
+ * Copyright (c) 2015-2024 Valve Corporation
+ * Copyright (c) 2015-2024 LunarG, Inc.
+ * Copyright (c) 2015-2024 Google Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ ****************************************************************************/
+
+// NOLINTBEGIN
+
+#include <vulkan/utility/vk_safe_struct.hpp>
+#include <vulkan/utility/vk_struct_helper.hpp>
+
+#include <cstring>
+
+namespace vku {
+
+safe_VkAttachmentSampleCountInfoAMD::safe_VkAttachmentSampleCountInfoAMD(const VkAttachmentSampleCountInfoAMD* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType),
+      colorAttachmentCount(in_struct->colorAttachmentCount),
+      pColorAttachmentSamples(nullptr),
+      depthStencilAttachmentSamples(in_struct->depthStencilAttachmentSamples) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pColorAttachmentSamples) {
+        pColorAttachmentSamples = new VkSampleCountFlagBits[in_struct->colorAttachmentCount];
+        memcpy((void*)pColorAttachmentSamples, (void*)in_struct->pColorAttachmentSamples,
+               sizeof(VkSampleCountFlagBits) * in_struct->colorAttachmentCount);
+    }
+}
+
+safe_VkAttachmentSampleCountInfoAMD::safe_VkAttachmentSampleCountInfoAMD()
+    : sType(VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD),
+      pNext(nullptr),
+      colorAttachmentCount(),
+      pColorAttachmentSamples(nullptr),
+      depthStencilAttachmentSamples() {}
+
+safe_VkAttachmentSampleCountInfoAMD::safe_VkAttachmentSampleCountInfoAMD(const safe_VkAttachmentSampleCountInfoAMD& copy_src) {
+    sType = copy_src.sType;
+    colorAttachmentCount = copy_src.colorAttachmentCount;
+    pColorAttachmentSamples = nullptr;
+    depthStencilAttachmentSamples = copy_src.depthStencilAttachmentSamples;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pColorAttachmentSamples) {
+        pColorAttachmentSamples = new VkSampleCountFlagBits[copy_src.colorAttachmentCount];
+        memcpy((void*)pColorAttachmentSamples, (void*)copy_src.pColorAttachmentSamples,
+               sizeof(VkSampleCountFlagBits) * copy_src.colorAttachmentCount);
+    }
+}
+
+safe_VkAttachmentSampleCountInfoAMD& safe_VkAttachmentSampleCountInfoAMD::operator=(
+    const safe_VkAttachmentSampleCountInfoAMD& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pColorAttachmentSamples) delete[] pColorAttachmentSamples;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    colorAttachmentCount = copy_src.colorAttachmentCount;
+    pColorAttachmentSamples = nullptr;
+    depthStencilAttachmentSamples = copy_src.depthStencilAttachmentSamples;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pColorAttachmentSamples) {
+        pColorAttachmentSamples = new VkSampleCountFlagBits[copy_src.colorAttachmentCount];
+        memcpy((void*)pColorAttachmentSamples, (void*)copy_src.pColorAttachmentSamples,
+               sizeof(VkSampleCountFlagBits) * copy_src.colorAttachmentCount);
+    }
+
+    return *this;
+}
+
+safe_VkAttachmentSampleCountInfoAMD::~safe_VkAttachmentSampleCountInfoAMD() {
+    if (pColorAttachmentSamples) delete[] pColorAttachmentSamples;
+    FreePnextChain(pNext);
+}
+
+void safe_VkAttachmentSampleCountInfoAMD::initialize(const VkAttachmentSampleCountInfoAMD* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pColorAttachmentSamples) delete[] pColorAttachmentSamples;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    colorAttachmentCount = in_struct->colorAttachmentCount;
+    pColorAttachmentSamples = nullptr;
+    depthStencilAttachmentSamples = in_struct->depthStencilAttachmentSamples;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pColorAttachmentSamples) {
+        pColorAttachmentSamples = new VkSampleCountFlagBits[in_struct->colorAttachmentCount];
+        memcpy((void*)pColorAttachmentSamples, (void*)in_struct->pColorAttachmentSamples,
+               sizeof(VkSampleCountFlagBits) * in_struct->colorAttachmentCount);
+    }
+}
+
+void safe_VkAttachmentSampleCountInfoAMD::initialize(const safe_VkAttachmentSampleCountInfoAMD* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    colorAttachmentCount = copy_src->colorAttachmentCount;
+    pColorAttachmentSamples = nullptr;
+    depthStencilAttachmentSamples = copy_src->depthStencilAttachmentSamples;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pColorAttachmentSamples) {
+        pColorAttachmentSamples = new VkSampleCountFlagBits[copy_src->colorAttachmentCount];
+        memcpy((void*)pColorAttachmentSamples, (void*)copy_src->pColorAttachmentSamples,
+               sizeof(VkSampleCountFlagBits) * copy_src->colorAttachmentCount);
+    }
+}
+
+safe_VkMultiviewPerViewAttributesInfoNVX::safe_VkMultiviewPerViewAttributesInfoNVX(
+    const VkMultiviewPerViewAttributesInfoNVX* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      perViewAttributes(in_struct->perViewAttributes),
+      perViewAttributesPositionXOnly(in_struct->perViewAttributesPositionXOnly) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMultiviewPerViewAttributesInfoNVX::safe_VkMultiviewPerViewAttributesInfoNVX()
+    : sType(VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX),
+      pNext(nullptr),
+      perViewAttributes(),
+      perViewAttributesPositionXOnly() {}
+
+safe_VkMultiviewPerViewAttributesInfoNVX::safe_VkMultiviewPerViewAttributesInfoNVX(
+    const safe_VkMultiviewPerViewAttributesInfoNVX& copy_src) {
+    sType = copy_src.sType;
+    perViewAttributes = copy_src.perViewAttributes;
+    perViewAttributesPositionXOnly = copy_src.perViewAttributesPositionXOnly;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMultiviewPerViewAttributesInfoNVX& safe_VkMultiviewPerViewAttributesInfoNVX::operator=(
+    const safe_VkMultiviewPerViewAttributesInfoNVX& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    perViewAttributes = copy_src.perViewAttributes;
+    perViewAttributesPositionXOnly = copy_src.perViewAttributesPositionXOnly;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMultiviewPerViewAttributesInfoNVX::~safe_VkMultiviewPerViewAttributesInfoNVX() { FreePnextChain(pNext); }
+
+void safe_VkMultiviewPerViewAttributesInfoNVX::initialize(const VkMultiviewPerViewAttributesInfoNVX* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    perViewAttributes = in_struct->perViewAttributes;
+    perViewAttributesPositionXOnly = in_struct->perViewAttributesPositionXOnly;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMultiviewPerViewAttributesInfoNVX::initialize(const safe_VkMultiviewPerViewAttributesInfoNVX* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    perViewAttributes = copy_src->perViewAttributes;
+    perViewAttributesPositionXOnly = copy_src->perViewAttributesPositionXOnly;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkQueueFamilyCheckpointProperties2NV::safe_VkQueueFamilyCheckpointProperties2NV(
+    const VkQueueFamilyCheckpointProperties2NV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), checkpointExecutionStageMask(in_struct->checkpointExecutionStageMask) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkQueueFamilyCheckpointProperties2NV::safe_VkQueueFamilyCheckpointProperties2NV()
+    : sType(VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV), pNext(nullptr), checkpointExecutionStageMask() {}
+
+safe_VkQueueFamilyCheckpointProperties2NV::safe_VkQueueFamilyCheckpointProperties2NV(
+    const safe_VkQueueFamilyCheckpointProperties2NV& copy_src) {
+    sType = copy_src.sType;
+    checkpointExecutionStageMask = copy_src.checkpointExecutionStageMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkQueueFamilyCheckpointProperties2NV& safe_VkQueueFamilyCheckpointProperties2NV::operator=(
+    const safe_VkQueueFamilyCheckpointProperties2NV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    checkpointExecutionStageMask = copy_src.checkpointExecutionStageMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkQueueFamilyCheckpointProperties2NV::~safe_VkQueueFamilyCheckpointProperties2NV() { FreePnextChain(pNext); }
+
+void safe_VkQueueFamilyCheckpointProperties2NV::initialize(const VkQueueFamilyCheckpointProperties2NV* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    checkpointExecutionStageMask = in_struct->checkpointExecutionStageMask;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkQueueFamilyCheckpointProperties2NV::initialize(const safe_VkQueueFamilyCheckpointProperties2NV* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    checkpointExecutionStageMask = copy_src->checkpointExecutionStageMask;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkCheckpointData2NV::safe_VkCheckpointData2NV(const VkCheckpointData2NV* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), stage(in_struct->stage), pCheckpointMarker(in_struct->pCheckpointMarker) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkCheckpointData2NV::safe_VkCheckpointData2NV()
+    : sType(VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV), pNext(nullptr), stage(), pCheckpointMarker(nullptr) {}
+
+safe_VkCheckpointData2NV::safe_VkCheckpointData2NV(const safe_VkCheckpointData2NV& copy_src) {
+    sType = copy_src.sType;
+    stage = copy_src.stage;
+    pCheckpointMarker = copy_src.pCheckpointMarker;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkCheckpointData2NV& safe_VkCheckpointData2NV::operator=(const safe_VkCheckpointData2NV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    stage = copy_src.stage;
+    pCheckpointMarker = copy_src.pCheckpointMarker;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkCheckpointData2NV::~safe_VkCheckpointData2NV() { FreePnextChain(pNext); }
+
+void safe_VkCheckpointData2NV::initialize(const VkCheckpointData2NV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    stage = in_struct->stage;
+    pCheckpointMarker = in_struct->pCheckpointMarker;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkCheckpointData2NV::initialize(const safe_VkCheckpointData2NV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stage = copy_src->stage;
+    pCheckpointMarker = copy_src->pCheckpointMarker;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineRasterizationStateRasterizationOrderAMD::safe_VkPipelineRasterizationStateRasterizationOrderAMD(
+    const VkPipelineRasterizationStateRasterizationOrderAMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), rasterizationOrder(in_struct->rasterizationOrder) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPipelineRasterizationStateRasterizationOrderAMD::safe_VkPipelineRasterizationStateRasterizationOrderAMD()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD), pNext(nullptr), rasterizationOrder() {}
+
+safe_VkPipelineRasterizationStateRasterizationOrderAMD::safe_VkPipelineRasterizationStateRasterizationOrderAMD(
+    const safe_VkPipelineRasterizationStateRasterizationOrderAMD& copy_src) {
+    sType = copy_src.sType;
+    rasterizationOrder = copy_src.rasterizationOrder;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPipelineRasterizationStateRasterizationOrderAMD& safe_VkPipelineRasterizationStateRasterizationOrderAMD::operator=(
+    const safe_VkPipelineRasterizationStateRasterizationOrderAMD& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    rasterizationOrder = copy_src.rasterizationOrder;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineRasterizationStateRasterizationOrderAMD::~safe_VkPipelineRasterizationStateRasterizationOrderAMD() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineRasterizationStateRasterizationOrderAMD::initialize(
+    const VkPipelineRasterizationStateRasterizationOrderAMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    rasterizationOrder = in_struct->rasterizationOrder;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPipelineRasterizationStateRasterizationOrderAMD::initialize(
+    const safe_VkPipelineRasterizationStateRasterizationOrderAMD* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    rasterizationOrder = copy_src->rasterizationOrder;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDedicatedAllocationImageCreateInfoNV::safe_VkDedicatedAllocationImageCreateInfoNV(
+    const VkDedicatedAllocationImageCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), dedicatedAllocation(in_struct->dedicatedAllocation) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDedicatedAllocationImageCreateInfoNV::safe_VkDedicatedAllocationImageCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV), pNext(nullptr), dedicatedAllocation() {}
+
+safe_VkDedicatedAllocationImageCreateInfoNV::safe_VkDedicatedAllocationImageCreateInfoNV(
+    const safe_VkDedicatedAllocationImageCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    dedicatedAllocation = copy_src.dedicatedAllocation;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDedicatedAllocationImageCreateInfoNV& safe_VkDedicatedAllocationImageCreateInfoNV::operator=(
+    const safe_VkDedicatedAllocationImageCreateInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    dedicatedAllocation = copy_src.dedicatedAllocation;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDedicatedAllocationImageCreateInfoNV::~safe_VkDedicatedAllocationImageCreateInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkDedicatedAllocationImageCreateInfoNV::initialize(const VkDedicatedAllocationImageCreateInfoNV* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    dedicatedAllocation = in_struct->dedicatedAllocation;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDedicatedAllocationImageCreateInfoNV::initialize(const safe_VkDedicatedAllocationImageCreateInfoNV* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    dedicatedAllocation = copy_src->dedicatedAllocation;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDedicatedAllocationBufferCreateInfoNV::safe_VkDedicatedAllocationBufferCreateInfoNV(
+    const VkDedicatedAllocationBufferCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), dedicatedAllocation(in_struct->dedicatedAllocation) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDedicatedAllocationBufferCreateInfoNV::safe_VkDedicatedAllocationBufferCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV), pNext(nullptr), dedicatedAllocation() {}
+
+safe_VkDedicatedAllocationBufferCreateInfoNV::safe_VkDedicatedAllocationBufferCreateInfoNV(
+    const safe_VkDedicatedAllocationBufferCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    dedicatedAllocation = copy_src.dedicatedAllocation;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDedicatedAllocationBufferCreateInfoNV& safe_VkDedicatedAllocationBufferCreateInfoNV::operator=(
+    const safe_VkDedicatedAllocationBufferCreateInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    dedicatedAllocation = copy_src.dedicatedAllocation;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDedicatedAllocationBufferCreateInfoNV::~safe_VkDedicatedAllocationBufferCreateInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkDedicatedAllocationBufferCreateInfoNV::initialize(const VkDedicatedAllocationBufferCreateInfoNV* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    dedicatedAllocation = in_struct->dedicatedAllocation;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDedicatedAllocationBufferCreateInfoNV::initialize(const safe_VkDedicatedAllocationBufferCreateInfoNV* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    dedicatedAllocation = copy_src->dedicatedAllocation;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDedicatedAllocationMemoryAllocateInfoNV::safe_VkDedicatedAllocationMemoryAllocateInfoNV(
+    const VkDedicatedAllocationMemoryAllocateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), image(in_struct->image), buffer(in_struct->buffer) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDedicatedAllocationMemoryAllocateInfoNV::safe_VkDedicatedAllocationMemoryAllocateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV), pNext(nullptr), image(), buffer() {}
+
+safe_VkDedicatedAllocationMemoryAllocateInfoNV::safe_VkDedicatedAllocationMemoryAllocateInfoNV(
+    const safe_VkDedicatedAllocationMemoryAllocateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    image = copy_src.image;
+    buffer = copy_src.buffer;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDedicatedAllocationMemoryAllocateInfoNV& safe_VkDedicatedAllocationMemoryAllocateInfoNV::operator=(
+    const safe_VkDedicatedAllocationMemoryAllocateInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    image = copy_src.image;
+    buffer = copy_src.buffer;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDedicatedAllocationMemoryAllocateInfoNV::~safe_VkDedicatedAllocationMemoryAllocateInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkDedicatedAllocationMemoryAllocateInfoNV::initialize(const VkDedicatedAllocationMemoryAllocateInfoNV* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    image = in_struct->image;
+    buffer = in_struct->buffer;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDedicatedAllocationMemoryAllocateInfoNV::initialize(const safe_VkDedicatedAllocationMemoryAllocateInfoNV* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    image = copy_src->image;
+    buffer = copy_src->buffer;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkCuModuleCreateInfoNVX::safe_VkCuModuleCreateInfoNVX(const VkCuModuleCreateInfoNVX* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), dataSize(in_struct->dataSize), pData(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pData != nullptr) {
+        auto temp = new std::byte[in_struct->dataSize];
+        std::memcpy(temp, in_struct->pData, in_struct->dataSize);
+        pData = temp;
+    }
+}
+
+safe_VkCuModuleCreateInfoNVX::safe_VkCuModuleCreateInfoNVX()
+    : sType(VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX), pNext(nullptr), dataSize(), pData(nullptr) {}
+
+safe_VkCuModuleCreateInfoNVX::safe_VkCuModuleCreateInfoNVX(const safe_VkCuModuleCreateInfoNVX& copy_src) {
+    sType = copy_src.sType;
+    dataSize = copy_src.dataSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pData != nullptr) {
+        auto temp = new std::byte[copy_src.dataSize];
+        std::memcpy(temp, copy_src.pData, copy_src.dataSize);
+        pData = temp;
+    }
+}
+
+safe_VkCuModuleCreateInfoNVX& safe_VkCuModuleCreateInfoNVX::operator=(const safe_VkCuModuleCreateInfoNVX& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pData != nullptr) {
+        auto temp = reinterpret_cast<const std::byte*>(pData);
+        delete[] temp;
+    }
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    dataSize = copy_src.dataSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pData != nullptr) {
+        auto temp = new std::byte[copy_src.dataSize];
+        std::memcpy(temp, copy_src.pData, copy_src.dataSize);
+        pData = temp;
+    }
+
+    return *this;
+}
+
+safe_VkCuModuleCreateInfoNVX::~safe_VkCuModuleCreateInfoNVX() {
+    if (pData != nullptr) {
+        auto temp = reinterpret_cast<const std::byte*>(pData);
+        delete[] temp;
+    }
+    FreePnextChain(pNext);
+}
+
+void safe_VkCuModuleCreateInfoNVX::initialize(const VkCuModuleCreateInfoNVX* in_struct,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pData != nullptr) {
+        auto temp = reinterpret_cast<const std::byte*>(pData);
+        delete[] temp;
+    }
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    dataSize = in_struct->dataSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pData != nullptr) {
+        auto temp = new std::byte[in_struct->dataSize];
+        std::memcpy(temp, in_struct->pData, in_struct->dataSize);
+        pData = temp;
+    }
+}
+
+void safe_VkCuModuleCreateInfoNVX::initialize(const safe_VkCuModuleCreateInfoNVX* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    dataSize = copy_src->dataSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pData != nullptr) {
+        auto temp = new std::byte[copy_src->dataSize];
+        std::memcpy(temp, copy_src->pData, copy_src->dataSize);
+        pData = temp;
+    }
+}
+
+safe_VkCuFunctionCreateInfoNVX::safe_VkCuFunctionCreateInfoNVX(const VkCuFunctionCreateInfoNVX* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), module(in_struct->module) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    pName = SafeStringCopy(in_struct->pName);
+}
+
+safe_VkCuFunctionCreateInfoNVX::safe_VkCuFunctionCreateInfoNVX()
+    : sType(VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX), pNext(nullptr), module(), pName(nullptr) {}
+
+safe_VkCuFunctionCreateInfoNVX::safe_VkCuFunctionCreateInfoNVX(const safe_VkCuFunctionCreateInfoNVX& copy_src) {
+    sType = copy_src.sType;
+    module = copy_src.module;
+    pNext = SafePnextCopy(copy_src.pNext);
+    pName = SafeStringCopy(copy_src.pName);
+}
+
+safe_VkCuFunctionCreateInfoNVX& safe_VkCuFunctionCreateInfoNVX::operator=(const safe_VkCuFunctionCreateInfoNVX& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pName) delete[] pName;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    module = copy_src.module;
+    pNext = SafePnextCopy(copy_src.pNext);
+    pName = SafeStringCopy(copy_src.pName);
+
+    return *this;
+}
+
+safe_VkCuFunctionCreateInfoNVX::~safe_VkCuFunctionCreateInfoNVX() {
+    if (pName) delete[] pName;
+    FreePnextChain(pNext);
+}
+
+void safe_VkCuFunctionCreateInfoNVX::initialize(const VkCuFunctionCreateInfoNVX* in_struct,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pName) delete[] pName;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    module = in_struct->module;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    pName = SafeStringCopy(in_struct->pName);
+}
+
+void safe_VkCuFunctionCreateInfoNVX::initialize(const safe_VkCuFunctionCreateInfoNVX* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    module = copy_src->module;
+    pNext = SafePnextCopy(copy_src->pNext);
+    pName = SafeStringCopy(copy_src->pName);
+}
+
+safe_VkCuLaunchInfoNVX::safe_VkCuLaunchInfoNVX(const VkCuLaunchInfoNVX* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                               bool copy_pnext)
+    : sType(in_struct->sType),
+      function(in_struct->function),
+      gridDimX(in_struct->gridDimX),
+      gridDimY(in_struct->gridDimY),
+      gridDimZ(in_struct->gridDimZ),
+      blockDimX(in_struct->blockDimX),
+      blockDimY(in_struct->blockDimY),
+      blockDimZ(in_struct->blockDimZ),
+      sharedMemBytes(in_struct->sharedMemBytes),
+      paramCount(in_struct->paramCount),
+      pParams(in_struct->pParams),
+      extraCount(in_struct->extraCount),
+      pExtras(in_struct->pExtras) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkCuLaunchInfoNVX::safe_VkCuLaunchInfoNVX()
+    : sType(VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX),
+      pNext(nullptr),
+      function(),
+      gridDimX(),
+      gridDimY(),
+      gridDimZ(),
+      blockDimX(),
+      blockDimY(),
+      blockDimZ(),
+      sharedMemBytes(),
+      paramCount(),
+      pParams(nullptr),
+      extraCount(),
+      pExtras(nullptr) {}
+
+safe_VkCuLaunchInfoNVX::safe_VkCuLaunchInfoNVX(const safe_VkCuLaunchInfoNVX& copy_src) {
+    sType = copy_src.sType;
+    function = copy_src.function;
+    gridDimX = copy_src.gridDimX;
+    gridDimY = copy_src.gridDimY;
+    gridDimZ = copy_src.gridDimZ;
+    blockDimX = copy_src.blockDimX;
+    blockDimY = copy_src.blockDimY;
+    blockDimZ = copy_src.blockDimZ;
+    sharedMemBytes = copy_src.sharedMemBytes;
+    paramCount = copy_src.paramCount;
+    pParams = copy_src.pParams;
+    extraCount = copy_src.extraCount;
+    pExtras = copy_src.pExtras;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkCuLaunchInfoNVX& safe_VkCuLaunchInfoNVX::operator=(const safe_VkCuLaunchInfoNVX& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    function = copy_src.function;
+    gridDimX = copy_src.gridDimX;
+    gridDimY = copy_src.gridDimY;
+    gridDimZ = copy_src.gridDimZ;
+    blockDimX = copy_src.blockDimX;
+    blockDimY = copy_src.blockDimY;
+    blockDimZ = copy_src.blockDimZ;
+    sharedMemBytes = copy_src.sharedMemBytes;
+    paramCount = copy_src.paramCount;
+    pParams = copy_src.pParams;
+    extraCount = copy_src.extraCount;
+    pExtras = copy_src.pExtras;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkCuLaunchInfoNVX::~safe_VkCuLaunchInfoNVX() { FreePnextChain(pNext); }
+
+void safe_VkCuLaunchInfoNVX::initialize(const VkCuLaunchInfoNVX* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    function = in_struct->function;
+    gridDimX = in_struct->gridDimX;
+    gridDimY = in_struct->gridDimY;
+    gridDimZ = in_struct->gridDimZ;
+    blockDimX = in_struct->blockDimX;
+    blockDimY = in_struct->blockDimY;
+    blockDimZ = in_struct->blockDimZ;
+    sharedMemBytes = in_struct->sharedMemBytes;
+    paramCount = in_struct->paramCount;
+    pParams = in_struct->pParams;
+    extraCount = in_struct->extraCount;
+    pExtras = in_struct->pExtras;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkCuLaunchInfoNVX::initialize(const safe_VkCuLaunchInfoNVX* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    function = copy_src->function;
+    gridDimX = copy_src->gridDimX;
+    gridDimY = copy_src->gridDimY;
+    gridDimZ = copy_src->gridDimZ;
+    blockDimX = copy_src->blockDimX;
+    blockDimY = copy_src->blockDimY;
+    blockDimZ = copy_src->blockDimZ;
+    sharedMemBytes = copy_src->sharedMemBytes;
+    paramCount = copy_src->paramCount;
+    pParams = copy_src->pParams;
+    extraCount = copy_src->extraCount;
+    pExtras = copy_src->pExtras;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkImageViewHandleInfoNVX::safe_VkImageViewHandleInfoNVX(const VkImageViewHandleInfoNVX* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      imageView(in_struct->imageView),
+      descriptorType(in_struct->descriptorType),
+      sampler(in_struct->sampler) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImageViewHandleInfoNVX::safe_VkImageViewHandleInfoNVX()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX), pNext(nullptr), imageView(), descriptorType(), sampler() {}
+
+safe_VkImageViewHandleInfoNVX::safe_VkImageViewHandleInfoNVX(const safe_VkImageViewHandleInfoNVX& copy_src) {
+    sType = copy_src.sType;
+    imageView = copy_src.imageView;
+    descriptorType = copy_src.descriptorType;
+    sampler = copy_src.sampler;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImageViewHandleInfoNVX& safe_VkImageViewHandleInfoNVX::operator=(const safe_VkImageViewHandleInfoNVX& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    imageView = copy_src.imageView;
+    descriptorType = copy_src.descriptorType;
+    sampler = copy_src.sampler;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImageViewHandleInfoNVX::~safe_VkImageViewHandleInfoNVX() { FreePnextChain(pNext); }
+
+void safe_VkImageViewHandleInfoNVX::initialize(const VkImageViewHandleInfoNVX* in_struct,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    imageView = in_struct->imageView;
+    descriptorType = in_struct->descriptorType;
+    sampler = in_struct->sampler;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImageViewHandleInfoNVX::initialize(const safe_VkImageViewHandleInfoNVX* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imageView = copy_src->imageView;
+    descriptorType = copy_src->descriptorType;
+    sampler = copy_src->sampler;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkImageViewAddressPropertiesNVX::safe_VkImageViewAddressPropertiesNVX(const VkImageViewAddressPropertiesNVX* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), deviceAddress(in_struct->deviceAddress), size(in_struct->size) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImageViewAddressPropertiesNVX::safe_VkImageViewAddressPropertiesNVX()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX), pNext(nullptr), deviceAddress(), size() {}
+
+safe_VkImageViewAddressPropertiesNVX::safe_VkImageViewAddressPropertiesNVX(const safe_VkImageViewAddressPropertiesNVX& copy_src) {
+    sType = copy_src.sType;
+    deviceAddress = copy_src.deviceAddress;
+    size = copy_src.size;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImageViewAddressPropertiesNVX& safe_VkImageViewAddressPropertiesNVX::operator=(
+    const safe_VkImageViewAddressPropertiesNVX& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    deviceAddress = copy_src.deviceAddress;
+    size = copy_src.size;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImageViewAddressPropertiesNVX::~safe_VkImageViewAddressPropertiesNVX() { FreePnextChain(pNext); }
+
+void safe_VkImageViewAddressPropertiesNVX::initialize(const VkImageViewAddressPropertiesNVX* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    deviceAddress = in_struct->deviceAddress;
+    size = in_struct->size;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImageViewAddressPropertiesNVX::initialize(const safe_VkImageViewAddressPropertiesNVX* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    deviceAddress = copy_src->deviceAddress;
+    size = copy_src->size;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkTextureLODGatherFormatPropertiesAMD::safe_VkTextureLODGatherFormatPropertiesAMD(
+    const VkTextureLODGatherFormatPropertiesAMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), supportsTextureGatherLODBiasAMD(in_struct->supportsTextureGatherLODBiasAMD) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkTextureLODGatherFormatPropertiesAMD::safe_VkTextureLODGatherFormatPropertiesAMD()
+    : sType(VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD), pNext(nullptr), supportsTextureGatherLODBiasAMD() {}
+
+safe_VkTextureLODGatherFormatPropertiesAMD::safe_VkTextureLODGatherFormatPropertiesAMD(
+    const safe_VkTextureLODGatherFormatPropertiesAMD& copy_src) {
+    sType = copy_src.sType;
+    supportsTextureGatherLODBiasAMD = copy_src.supportsTextureGatherLODBiasAMD;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkTextureLODGatherFormatPropertiesAMD& safe_VkTextureLODGatherFormatPropertiesAMD::operator=(
+    const safe_VkTextureLODGatherFormatPropertiesAMD& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    supportsTextureGatherLODBiasAMD = copy_src.supportsTextureGatherLODBiasAMD;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkTextureLODGatherFormatPropertiesAMD::~safe_VkTextureLODGatherFormatPropertiesAMD() { FreePnextChain(pNext); }
+
+void safe_VkTextureLODGatherFormatPropertiesAMD::initialize(const VkTextureLODGatherFormatPropertiesAMD* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    supportsTextureGatherLODBiasAMD = in_struct->supportsTextureGatherLODBiasAMD;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkTextureLODGatherFormatPropertiesAMD::initialize(const safe_VkTextureLODGatherFormatPropertiesAMD* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    supportsTextureGatherLODBiasAMD = copy_src->supportsTextureGatherLODBiasAMD;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+#ifdef VK_USE_PLATFORM_GGP
+
+safe_VkStreamDescriptorSurfaceCreateInfoGGP::safe_VkStreamDescriptorSurfaceCreateInfoGGP(
+    const VkStreamDescriptorSurfaceCreateInfoGGP* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags), streamDescriptor(in_struct->streamDescriptor) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkStreamDescriptorSurfaceCreateInfoGGP::safe_VkStreamDescriptorSurfaceCreateInfoGGP()
+    : sType(VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP), pNext(nullptr), flags(), streamDescriptor() {}
+
+safe_VkStreamDescriptorSurfaceCreateInfoGGP::safe_VkStreamDescriptorSurfaceCreateInfoGGP(
+    const safe_VkStreamDescriptorSurfaceCreateInfoGGP& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    streamDescriptor = copy_src.streamDescriptor;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkStreamDescriptorSurfaceCreateInfoGGP& safe_VkStreamDescriptorSurfaceCreateInfoGGP::operator=(
+    const safe_VkStreamDescriptorSurfaceCreateInfoGGP& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    streamDescriptor = copy_src.streamDescriptor;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkStreamDescriptorSurfaceCreateInfoGGP::~safe_VkStreamDescriptorSurfaceCreateInfoGGP() { FreePnextChain(pNext); }
+
+void safe_VkStreamDescriptorSurfaceCreateInfoGGP::initialize(const VkStreamDescriptorSurfaceCreateInfoGGP* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    streamDescriptor = in_struct->streamDescriptor;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkStreamDescriptorSurfaceCreateInfoGGP::initialize(const safe_VkStreamDescriptorSurfaceCreateInfoGGP* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    streamDescriptor = copy_src->streamDescriptor;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+#endif  // VK_USE_PLATFORM_GGP
+
+safe_VkPhysicalDeviceCornerSampledImageFeaturesNV::safe_VkPhysicalDeviceCornerSampledImageFeaturesNV(
+    const VkPhysicalDeviceCornerSampledImageFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), cornerSampledImage(in_struct->cornerSampledImage) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceCornerSampledImageFeaturesNV::safe_VkPhysicalDeviceCornerSampledImageFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV), pNext(nullptr), cornerSampledImage() {}
+
+safe_VkPhysicalDeviceCornerSampledImageFeaturesNV::safe_VkPhysicalDeviceCornerSampledImageFeaturesNV(
+    const safe_VkPhysicalDeviceCornerSampledImageFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    cornerSampledImage = copy_src.cornerSampledImage;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceCornerSampledImageFeaturesNV& safe_VkPhysicalDeviceCornerSampledImageFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceCornerSampledImageFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    cornerSampledImage = copy_src.cornerSampledImage;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceCornerSampledImageFeaturesNV::~safe_VkPhysicalDeviceCornerSampledImageFeaturesNV() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceCornerSampledImageFeaturesNV::initialize(const VkPhysicalDeviceCornerSampledImageFeaturesNV* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    cornerSampledImage = in_struct->cornerSampledImage;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceCornerSampledImageFeaturesNV::initialize(
+    const safe_VkPhysicalDeviceCornerSampledImageFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    cornerSampledImage = copy_src->cornerSampledImage;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkExternalMemoryImageCreateInfoNV::safe_VkExternalMemoryImageCreateInfoNV(const VkExternalMemoryImageCreateInfoNV* in_struct,
+                                                                               [[maybe_unused]] PNextCopyState* copy_state,
+                                                                               bool copy_pnext)
+    : sType(in_struct->sType), handleTypes(in_struct->handleTypes) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkExternalMemoryImageCreateInfoNV::safe_VkExternalMemoryImageCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV), pNext(nullptr), handleTypes() {}
+
+safe_VkExternalMemoryImageCreateInfoNV::safe_VkExternalMemoryImageCreateInfoNV(
+    const safe_VkExternalMemoryImageCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    handleTypes = copy_src.handleTypes;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkExternalMemoryImageCreateInfoNV& safe_VkExternalMemoryImageCreateInfoNV::operator=(
+    const safe_VkExternalMemoryImageCreateInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    handleTypes = copy_src.handleTypes;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkExternalMemoryImageCreateInfoNV::~safe_VkExternalMemoryImageCreateInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkExternalMemoryImageCreateInfoNV::initialize(const VkExternalMemoryImageCreateInfoNV* in_struct,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    handleTypes = in_struct->handleTypes;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkExternalMemoryImageCreateInfoNV::initialize(const safe_VkExternalMemoryImageCreateInfoNV* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    handleTypes = copy_src->handleTypes;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkExportMemoryAllocateInfoNV::safe_VkExportMemoryAllocateInfoNV(const VkExportMemoryAllocateInfoNV* in_struct,
+                                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), handleTypes(in_struct->handleTypes) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkExportMemoryAllocateInfoNV::safe_VkExportMemoryAllocateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV), pNext(nullptr), handleTypes() {}
+
+safe_VkExportMemoryAllocateInfoNV::safe_VkExportMemoryAllocateInfoNV(const safe_VkExportMemoryAllocateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    handleTypes = copy_src.handleTypes;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkExportMemoryAllocateInfoNV& safe_VkExportMemoryAllocateInfoNV::operator=(const safe_VkExportMemoryAllocateInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    handleTypes = copy_src.handleTypes;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkExportMemoryAllocateInfoNV::~safe_VkExportMemoryAllocateInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkExportMemoryAllocateInfoNV::initialize(const VkExportMemoryAllocateInfoNV* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    handleTypes = in_struct->handleTypes;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkExportMemoryAllocateInfoNV::initialize(const safe_VkExportMemoryAllocateInfoNV* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    handleTypes = copy_src->handleTypes;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+
+safe_VkImportMemoryWin32HandleInfoNV::safe_VkImportMemoryWin32HandleInfoNV(const VkImportMemoryWin32HandleInfoNV* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), handleType(in_struct->handleType), handle(in_struct->handle) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImportMemoryWin32HandleInfoNV::safe_VkImportMemoryWin32HandleInfoNV()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV), pNext(nullptr), handleType(), handle() {}
+
+safe_VkImportMemoryWin32HandleInfoNV::safe_VkImportMemoryWin32HandleInfoNV(const safe_VkImportMemoryWin32HandleInfoNV& copy_src) {
+    sType = copy_src.sType;
+    handleType = copy_src.handleType;
+    handle = copy_src.handle;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImportMemoryWin32HandleInfoNV& safe_VkImportMemoryWin32HandleInfoNV::operator=(
+    const safe_VkImportMemoryWin32HandleInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    handleType = copy_src.handleType;
+    handle = copy_src.handle;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImportMemoryWin32HandleInfoNV::~safe_VkImportMemoryWin32HandleInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkImportMemoryWin32HandleInfoNV::initialize(const VkImportMemoryWin32HandleInfoNV* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    handleType = in_struct->handleType;
+    handle = in_struct->handle;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImportMemoryWin32HandleInfoNV::initialize(const safe_VkImportMemoryWin32HandleInfoNV* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    handleType = copy_src->handleType;
+    handle = copy_src->handle;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkExportMemoryWin32HandleInfoNV::safe_VkExportMemoryWin32HandleInfoNV(const VkExportMemoryWin32HandleInfoNV* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), pAttributes(nullptr), dwAccess(in_struct->dwAccess) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pAttributes) {
+        pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
+    }
+}
+
+safe_VkExportMemoryWin32HandleInfoNV::safe_VkExportMemoryWin32HandleInfoNV()
+    : sType(VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV), pNext(nullptr), pAttributes(nullptr), dwAccess() {}
+
+safe_VkExportMemoryWin32HandleInfoNV::safe_VkExportMemoryWin32HandleInfoNV(const safe_VkExportMemoryWin32HandleInfoNV& copy_src) {
+    sType = copy_src.sType;
+    pAttributes = nullptr;
+    dwAccess = copy_src.dwAccess;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pAttributes) {
+        pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes);
+    }
+}
+
+safe_VkExportMemoryWin32HandleInfoNV& safe_VkExportMemoryWin32HandleInfoNV::operator=(
+    const safe_VkExportMemoryWin32HandleInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pAttributes) delete pAttributes;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pAttributes = nullptr;
+    dwAccess = copy_src.dwAccess;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pAttributes) {
+        pAttributes = new SECURITY_ATTRIBUTES(*copy_src.pAttributes);
+    }
+
+    return *this;
+}
+
+safe_VkExportMemoryWin32HandleInfoNV::~safe_VkExportMemoryWin32HandleInfoNV() {
+    if (pAttributes) delete pAttributes;
+    FreePnextChain(pNext);
+}
+
+void safe_VkExportMemoryWin32HandleInfoNV::initialize(const VkExportMemoryWin32HandleInfoNV* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pAttributes) delete pAttributes;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pAttributes = nullptr;
+    dwAccess = in_struct->dwAccess;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pAttributes) {
+        pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
+    }
+}
+
+void safe_VkExportMemoryWin32HandleInfoNV::initialize(const safe_VkExportMemoryWin32HandleInfoNV* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pAttributes = nullptr;
+    dwAccess = copy_src->dwAccess;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pAttributes) {
+        pAttributes = new SECURITY_ATTRIBUTES(*copy_src->pAttributes);
+    }
+}
+
+safe_VkWin32KeyedMutexAcquireReleaseInfoNV::safe_VkWin32KeyedMutexAcquireReleaseInfoNV(
+    const VkWin32KeyedMutexAcquireReleaseInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      acquireCount(in_struct->acquireCount),
+      pAcquireSyncs(nullptr),
+      pAcquireKeys(nullptr),
+      pAcquireTimeoutMilliseconds(nullptr),
+      releaseCount(in_struct->releaseCount),
+      pReleaseSyncs(nullptr),
+      pReleaseKeys(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (acquireCount && in_struct->pAcquireSyncs) {
+        pAcquireSyncs = new VkDeviceMemory[acquireCount];
+        for (uint32_t i = 0; i < acquireCount; ++i) {
+            pAcquireSyncs[i] = in_struct->pAcquireSyncs[i];
+        }
+    }
+
+    if (in_struct->pAcquireKeys) {
+        pAcquireKeys = new uint64_t[in_struct->acquireCount];
+        memcpy((void*)pAcquireKeys, (void*)in_struct->pAcquireKeys, sizeof(uint64_t) * in_struct->acquireCount);
+    }
+
+    if (in_struct->pAcquireTimeoutMilliseconds) {
+        pAcquireTimeoutMilliseconds = new uint32_t[in_struct->acquireCount];
+        memcpy((void*)pAcquireTimeoutMilliseconds, (void*)in_struct->pAcquireTimeoutMilliseconds,
+               sizeof(uint32_t) * in_struct->acquireCount);
+    }
+    if (releaseCount && in_struct->pReleaseSyncs) {
+        pReleaseSyncs = new VkDeviceMemory[releaseCount];
+        for (uint32_t i = 0; i < releaseCount; ++i) {
+            pReleaseSyncs[i] = in_struct->pReleaseSyncs[i];
+        }
+    }
+
+    if (in_struct->pReleaseKeys) {
+        pReleaseKeys = new uint64_t[in_struct->releaseCount];
+        memcpy((void*)pReleaseKeys, (void*)in_struct->pReleaseKeys, sizeof(uint64_t) * in_struct->releaseCount);
+    }
+}
+
+safe_VkWin32KeyedMutexAcquireReleaseInfoNV::safe_VkWin32KeyedMutexAcquireReleaseInfoNV()
+    : sType(VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV),
+      pNext(nullptr),
+      acquireCount(),
+      pAcquireSyncs(nullptr),
+      pAcquireKeys(nullptr),
+      pAcquireTimeoutMilliseconds(nullptr),
+      releaseCount(),
+      pReleaseSyncs(nullptr),
+      pReleaseKeys(nullptr) {}
+
+safe_VkWin32KeyedMutexAcquireReleaseInfoNV::safe_VkWin32KeyedMutexAcquireReleaseInfoNV(
+    const safe_VkWin32KeyedMutexAcquireReleaseInfoNV& copy_src) {
+    sType = copy_src.sType;
+    acquireCount = copy_src.acquireCount;
+    pAcquireSyncs = nullptr;
+    pAcquireKeys = nullptr;
+    pAcquireTimeoutMilliseconds = nullptr;
+    releaseCount = copy_src.releaseCount;
+    pReleaseSyncs = nullptr;
+    pReleaseKeys = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (acquireCount && copy_src.pAcquireSyncs) {
+        pAcquireSyncs = new VkDeviceMemory[acquireCount];
+        for (uint32_t i = 0; i < acquireCount; ++i) {
+            pAcquireSyncs[i] = copy_src.pAcquireSyncs[i];
+        }
+    }
+
+    if (copy_src.pAcquireKeys) {
+        pAcquireKeys = new uint64_t[copy_src.acquireCount];
+        memcpy((void*)pAcquireKeys, (void*)copy_src.pAcquireKeys, sizeof(uint64_t) * copy_src.acquireCount);
+    }
+
+    if (copy_src.pAcquireTimeoutMilliseconds) {
+        pAcquireTimeoutMilliseconds = new uint32_t[copy_src.acquireCount];
+        memcpy((void*)pAcquireTimeoutMilliseconds, (void*)copy_src.pAcquireTimeoutMilliseconds,
+               sizeof(uint32_t) * copy_src.acquireCount);
+    }
+    if (releaseCount && copy_src.pReleaseSyncs) {
+        pReleaseSyncs = new VkDeviceMemory[releaseCount];
+        for (uint32_t i = 0; i < releaseCount; ++i) {
+            pReleaseSyncs[i] = copy_src.pReleaseSyncs[i];
+        }
+    }
+
+    if (copy_src.pReleaseKeys) {
+        pReleaseKeys = new uint64_t[copy_src.releaseCount];
+        memcpy((void*)pReleaseKeys, (void*)copy_src.pReleaseKeys, sizeof(uint64_t) * copy_src.releaseCount);
+    }
+}
+
+safe_VkWin32KeyedMutexAcquireReleaseInfoNV& safe_VkWin32KeyedMutexAcquireReleaseInfoNV::operator=(
+    const safe_VkWin32KeyedMutexAcquireReleaseInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pAcquireSyncs) delete[] pAcquireSyncs;
+    if (pAcquireKeys) delete[] pAcquireKeys;
+    if (pAcquireTimeoutMilliseconds) delete[] pAcquireTimeoutMilliseconds;
+    if (pReleaseSyncs) delete[] pReleaseSyncs;
+    if (pReleaseKeys) delete[] pReleaseKeys;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    acquireCount = copy_src.acquireCount;
+    pAcquireSyncs = nullptr;
+    pAcquireKeys = nullptr;
+    pAcquireTimeoutMilliseconds = nullptr;
+    releaseCount = copy_src.releaseCount;
+    pReleaseSyncs = nullptr;
+    pReleaseKeys = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (acquireCount && copy_src.pAcquireSyncs) {
+        pAcquireSyncs = new VkDeviceMemory[acquireCount];
+        for (uint32_t i = 0; i < acquireCount; ++i) {
+            pAcquireSyncs[i] = copy_src.pAcquireSyncs[i];
+        }
+    }
+
+    if (copy_src.pAcquireKeys) {
+        pAcquireKeys = new uint64_t[copy_src.acquireCount];
+        memcpy((void*)pAcquireKeys, (void*)copy_src.pAcquireKeys, sizeof(uint64_t) * copy_src.acquireCount);
+    }
+
+    if (copy_src.pAcquireTimeoutMilliseconds) {
+        pAcquireTimeoutMilliseconds = new uint32_t[copy_src.acquireCount];
+        memcpy((void*)pAcquireTimeoutMilliseconds, (void*)copy_src.pAcquireTimeoutMilliseconds,
+               sizeof(uint32_t) * copy_src.acquireCount);
+    }
+    if (releaseCount && copy_src.pReleaseSyncs) {
+        pReleaseSyncs = new VkDeviceMemory[releaseCount];
+        for (uint32_t i = 0; i < releaseCount; ++i) {
+            pReleaseSyncs[i] = copy_src.pReleaseSyncs[i];
+        }
+    }
+
+    if (copy_src.pReleaseKeys) {
+        pReleaseKeys = new uint64_t[copy_src.releaseCount];
+        memcpy((void*)pReleaseKeys, (void*)copy_src.pReleaseKeys, sizeof(uint64_t) * copy_src.releaseCount);
+    }
+
+    return *this;
+}
+
+safe_VkWin32KeyedMutexAcquireReleaseInfoNV::~safe_VkWin32KeyedMutexAcquireReleaseInfoNV() {
+    if (pAcquireSyncs) delete[] pAcquireSyncs;
+    if (pAcquireKeys) delete[] pAcquireKeys;
+    if (pAcquireTimeoutMilliseconds) delete[] pAcquireTimeoutMilliseconds;
+    if (pReleaseSyncs) delete[] pReleaseSyncs;
+    if (pReleaseKeys) delete[] pReleaseKeys;
+    FreePnextChain(pNext);
+}
+
+void safe_VkWin32KeyedMutexAcquireReleaseInfoNV::initialize(const VkWin32KeyedMutexAcquireReleaseInfoNV* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pAcquireSyncs) delete[] pAcquireSyncs;
+    if (pAcquireKeys) delete[] pAcquireKeys;
+    if (pAcquireTimeoutMilliseconds) delete[] pAcquireTimeoutMilliseconds;
+    if (pReleaseSyncs) delete[] pReleaseSyncs;
+    if (pReleaseKeys) delete[] pReleaseKeys;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    acquireCount = in_struct->acquireCount;
+    pAcquireSyncs = nullptr;
+    pAcquireKeys = nullptr;
+    pAcquireTimeoutMilliseconds = nullptr;
+    releaseCount = in_struct->releaseCount;
+    pReleaseSyncs = nullptr;
+    pReleaseKeys = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (acquireCount && in_struct->pAcquireSyncs) {
+        pAcquireSyncs = new VkDeviceMemory[acquireCount];
+        for (uint32_t i = 0; i < acquireCount; ++i) {
+            pAcquireSyncs[i] = in_struct->pAcquireSyncs[i];
+        }
+    }
+
+    if (in_struct->pAcquireKeys) {
+        pAcquireKeys = new uint64_t[in_struct->acquireCount];
+        memcpy((void*)pAcquireKeys, (void*)in_struct->pAcquireKeys, sizeof(uint64_t) * in_struct->acquireCount);
+    }
+
+    if (in_struct->pAcquireTimeoutMilliseconds) {
+        pAcquireTimeoutMilliseconds = new uint32_t[in_struct->acquireCount];
+        memcpy((void*)pAcquireTimeoutMilliseconds, (void*)in_struct->pAcquireTimeoutMilliseconds,
+               sizeof(uint32_t) * in_struct->acquireCount);
+    }
+    if (releaseCount && in_struct->pReleaseSyncs) {
+        pReleaseSyncs = new VkDeviceMemory[releaseCount];
+        for (uint32_t i = 0; i < releaseCount; ++i) {
+            pReleaseSyncs[i] = in_struct->pReleaseSyncs[i];
+        }
+    }
+
+    if (in_struct->pReleaseKeys) {
+        pReleaseKeys = new uint64_t[in_struct->releaseCount];
+        memcpy((void*)pReleaseKeys, (void*)in_struct->pReleaseKeys, sizeof(uint64_t) * in_struct->releaseCount);
+    }
+}
+
+void safe_VkWin32KeyedMutexAcquireReleaseInfoNV::initialize(const safe_VkWin32KeyedMutexAcquireReleaseInfoNV* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    acquireCount = copy_src->acquireCount;
+    pAcquireSyncs = nullptr;
+    pAcquireKeys = nullptr;
+    pAcquireTimeoutMilliseconds = nullptr;
+    releaseCount = copy_src->releaseCount;
+    pReleaseSyncs = nullptr;
+    pReleaseKeys = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (acquireCount && copy_src->pAcquireSyncs) {
+        pAcquireSyncs = new VkDeviceMemory[acquireCount];
+        for (uint32_t i = 0; i < acquireCount; ++i) {
+            pAcquireSyncs[i] = copy_src->pAcquireSyncs[i];
+        }
+    }
+
+    if (copy_src->pAcquireKeys) {
+        pAcquireKeys = new uint64_t[copy_src->acquireCount];
+        memcpy((void*)pAcquireKeys, (void*)copy_src->pAcquireKeys, sizeof(uint64_t) * copy_src->acquireCount);
+    }
+
+    if (copy_src->pAcquireTimeoutMilliseconds) {
+        pAcquireTimeoutMilliseconds = new uint32_t[copy_src->acquireCount];
+        memcpy((void*)pAcquireTimeoutMilliseconds, (void*)copy_src->pAcquireTimeoutMilliseconds,
+               sizeof(uint32_t) * copy_src->acquireCount);
+    }
+    if (releaseCount && copy_src->pReleaseSyncs) {
+        pReleaseSyncs = new VkDeviceMemory[releaseCount];
+        for (uint32_t i = 0; i < releaseCount; ++i) {
+            pReleaseSyncs[i] = copy_src->pReleaseSyncs[i];
+        }
+    }
+
+    if (copy_src->pReleaseKeys) {
+        pReleaseKeys = new uint64_t[copy_src->releaseCount];
+        memcpy((void*)pReleaseKeys, (void*)copy_src->pReleaseKeys, sizeof(uint64_t) * copy_src->releaseCount);
+    }
+}
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_VI_NN
+
+safe_VkViSurfaceCreateInfoNN::safe_VkViSurfaceCreateInfoNN(const VkViSurfaceCreateInfoNN* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags), window(in_struct->window) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkViSurfaceCreateInfoNN::safe_VkViSurfaceCreateInfoNN()
+    : sType(VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN), pNext(nullptr), flags(), window(nullptr) {}
+
+safe_VkViSurfaceCreateInfoNN::safe_VkViSurfaceCreateInfoNN(const safe_VkViSurfaceCreateInfoNN& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    window = copy_src.window;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkViSurfaceCreateInfoNN& safe_VkViSurfaceCreateInfoNN::operator=(const safe_VkViSurfaceCreateInfoNN& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    window = copy_src.window;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkViSurfaceCreateInfoNN::~safe_VkViSurfaceCreateInfoNN() { FreePnextChain(pNext); }
+
+void safe_VkViSurfaceCreateInfoNN::initialize(const VkViSurfaceCreateInfoNN* in_struct,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    window = in_struct->window;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkViSurfaceCreateInfoNN::initialize(const safe_VkViSurfaceCreateInfoNN* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    window = copy_src->window;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+#endif  // VK_USE_PLATFORM_VI_NN
+
+safe_VkPipelineViewportWScalingStateCreateInfoNV::safe_VkPipelineViewportWScalingStateCreateInfoNV(
+    const VkPipelineViewportWScalingStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      viewportWScalingEnable(in_struct->viewportWScalingEnable),
+      viewportCount(in_struct->viewportCount),
+      pViewportWScalings(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pViewportWScalings) {
+        pViewportWScalings = new VkViewportWScalingNV[in_struct->viewportCount];
+        memcpy((void*)pViewportWScalings, (void*)in_struct->pViewportWScalings,
+               sizeof(VkViewportWScalingNV) * in_struct->viewportCount);
+    }
+}
+
+safe_VkPipelineViewportWScalingStateCreateInfoNV::safe_VkPipelineViewportWScalingStateCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV),
+      pNext(nullptr),
+      viewportWScalingEnable(),
+      viewportCount(),
+      pViewportWScalings(nullptr) {}
+
+safe_VkPipelineViewportWScalingStateCreateInfoNV::safe_VkPipelineViewportWScalingStateCreateInfoNV(
+    const safe_VkPipelineViewportWScalingStateCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    viewportWScalingEnable = copy_src.viewportWScalingEnable;
+    viewportCount = copy_src.viewportCount;
+    pViewportWScalings = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pViewportWScalings) {
+        pViewportWScalings = new VkViewportWScalingNV[copy_src.viewportCount];
+        memcpy((void*)pViewportWScalings, (void*)copy_src.pViewportWScalings,
+               sizeof(VkViewportWScalingNV) * copy_src.viewportCount);
+    }
+}
+
+safe_VkPipelineViewportWScalingStateCreateInfoNV& safe_VkPipelineViewportWScalingStateCreateInfoNV::operator=(
+    const safe_VkPipelineViewportWScalingStateCreateInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pViewportWScalings) delete[] pViewportWScalings;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    viewportWScalingEnable = copy_src.viewportWScalingEnable;
+    viewportCount = copy_src.viewportCount;
+    pViewportWScalings = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pViewportWScalings) {
+        pViewportWScalings = new VkViewportWScalingNV[copy_src.viewportCount];
+        memcpy((void*)pViewportWScalings, (void*)copy_src.pViewportWScalings,
+               sizeof(VkViewportWScalingNV) * copy_src.viewportCount);
+    }
+
+    return *this;
+}
+
+safe_VkPipelineViewportWScalingStateCreateInfoNV::~safe_VkPipelineViewportWScalingStateCreateInfoNV() {
+    if (pViewportWScalings) delete[] pViewportWScalings;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineViewportWScalingStateCreateInfoNV::initialize(const VkPipelineViewportWScalingStateCreateInfoNV* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pViewportWScalings) delete[] pViewportWScalings;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    viewportWScalingEnable = in_struct->viewportWScalingEnable;
+    viewportCount = in_struct->viewportCount;
+    pViewportWScalings = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pViewportWScalings) {
+        pViewportWScalings = new VkViewportWScalingNV[in_struct->viewportCount];
+        memcpy((void*)pViewportWScalings, (void*)in_struct->pViewportWScalings,
+               sizeof(VkViewportWScalingNV) * in_struct->viewportCount);
+    }
+}
+
+void safe_VkPipelineViewportWScalingStateCreateInfoNV::initialize(const safe_VkPipelineViewportWScalingStateCreateInfoNV* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    viewportWScalingEnable = copy_src->viewportWScalingEnable;
+    viewportCount = copy_src->viewportCount;
+    pViewportWScalings = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pViewportWScalings) {
+        pViewportWScalings = new VkViewportWScalingNV[copy_src->viewportCount];
+        memcpy((void*)pViewportWScalings, (void*)copy_src->pViewportWScalings,
+               sizeof(VkViewportWScalingNV) * copy_src->viewportCount);
+    }
+}
+
+safe_VkPresentTimesInfoGOOGLE::safe_VkPresentTimesInfoGOOGLE(const VkPresentTimesInfoGOOGLE* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), swapchainCount(in_struct->swapchainCount), pTimes(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pTimes) {
+        pTimes = new VkPresentTimeGOOGLE[in_struct->swapchainCount];
+        memcpy((void*)pTimes, (void*)in_struct->pTimes, sizeof(VkPresentTimeGOOGLE) * in_struct->swapchainCount);
+    }
+}
+
+safe_VkPresentTimesInfoGOOGLE::safe_VkPresentTimesInfoGOOGLE()
+    : sType(VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE), pNext(nullptr), swapchainCount(), pTimes(nullptr) {}
+
+safe_VkPresentTimesInfoGOOGLE::safe_VkPresentTimesInfoGOOGLE(const safe_VkPresentTimesInfoGOOGLE& copy_src) {
+    sType = copy_src.sType;
+    swapchainCount = copy_src.swapchainCount;
+    pTimes = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pTimes) {
+        pTimes = new VkPresentTimeGOOGLE[copy_src.swapchainCount];
+        memcpy((void*)pTimes, (void*)copy_src.pTimes, sizeof(VkPresentTimeGOOGLE) * copy_src.swapchainCount);
+    }
+}
+
+safe_VkPresentTimesInfoGOOGLE& safe_VkPresentTimesInfoGOOGLE::operator=(const safe_VkPresentTimesInfoGOOGLE& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pTimes) delete[] pTimes;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    swapchainCount = copy_src.swapchainCount;
+    pTimes = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pTimes) {
+        pTimes = new VkPresentTimeGOOGLE[copy_src.swapchainCount];
+        memcpy((void*)pTimes, (void*)copy_src.pTimes, sizeof(VkPresentTimeGOOGLE) * copy_src.swapchainCount);
+    }
+
+    return *this;
+}
+
+safe_VkPresentTimesInfoGOOGLE::~safe_VkPresentTimesInfoGOOGLE() {
+    if (pTimes) delete[] pTimes;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPresentTimesInfoGOOGLE::initialize(const VkPresentTimesInfoGOOGLE* in_struct,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pTimes) delete[] pTimes;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    swapchainCount = in_struct->swapchainCount;
+    pTimes = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pTimes) {
+        pTimes = new VkPresentTimeGOOGLE[in_struct->swapchainCount];
+        memcpy((void*)pTimes, (void*)in_struct->pTimes, sizeof(VkPresentTimeGOOGLE) * in_struct->swapchainCount);
+    }
+}
+
+void safe_VkPresentTimesInfoGOOGLE::initialize(const safe_VkPresentTimesInfoGOOGLE* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    swapchainCount = copy_src->swapchainCount;
+    pTimes = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pTimes) {
+        pTimes = new VkPresentTimeGOOGLE[copy_src->swapchainCount];
+        memcpy((void*)pTimes, (void*)copy_src->pTimes, sizeof(VkPresentTimeGOOGLE) * copy_src->swapchainCount);
+    }
+}
+
+safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
+    const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), perViewPositionAllComponents(in_struct->perViewPositionAllComponents) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX),
+      pNext(nullptr),
+      perViewPositionAllComponents() {}
+
+safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
+    const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& copy_src) {
+    sType = copy_src.sType;
+    perViewPositionAllComponents = copy_src.perViewPositionAllComponents;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX&
+safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::operator=(
+    const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    perViewPositionAllComponents = copy_src.perViewPositionAllComponents;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::~safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::initialize(
+    const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    perViewPositionAllComponents = in_struct->perViewPositionAllComponents;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::initialize(
+    const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    perViewPositionAllComponents = copy_src->perViewPositionAllComponents;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineViewportSwizzleStateCreateInfoNV::safe_VkPipelineViewportSwizzleStateCreateInfoNV(
+    const VkPipelineViewportSwizzleStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags), viewportCount(in_struct->viewportCount), pViewportSwizzles(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pViewportSwizzles) {
+        pViewportSwizzles = new VkViewportSwizzleNV[in_struct->viewportCount];
+        memcpy((void*)pViewportSwizzles, (void*)in_struct->pViewportSwizzles,
+               sizeof(VkViewportSwizzleNV) * in_struct->viewportCount);
+    }
+}
+
+safe_VkPipelineViewportSwizzleStateCreateInfoNV::safe_VkPipelineViewportSwizzleStateCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV),
+      pNext(nullptr),
+      flags(),
+      viewportCount(),
+      pViewportSwizzles(nullptr) {}
+
+safe_VkPipelineViewportSwizzleStateCreateInfoNV::safe_VkPipelineViewportSwizzleStateCreateInfoNV(
+    const safe_VkPipelineViewportSwizzleStateCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    viewportCount = copy_src.viewportCount;
+    pViewportSwizzles = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pViewportSwizzles) {
+        pViewportSwizzles = new VkViewportSwizzleNV[copy_src.viewportCount];
+        memcpy((void*)pViewportSwizzles, (void*)copy_src.pViewportSwizzles, sizeof(VkViewportSwizzleNV) * copy_src.viewportCount);
+    }
+}
+
+safe_VkPipelineViewportSwizzleStateCreateInfoNV& safe_VkPipelineViewportSwizzleStateCreateInfoNV::operator=(
+    const safe_VkPipelineViewportSwizzleStateCreateInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pViewportSwizzles) delete[] pViewportSwizzles;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    viewportCount = copy_src.viewportCount;
+    pViewportSwizzles = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pViewportSwizzles) {
+        pViewportSwizzles = new VkViewportSwizzleNV[copy_src.viewportCount];
+        memcpy((void*)pViewportSwizzles, (void*)copy_src.pViewportSwizzles, sizeof(VkViewportSwizzleNV) * copy_src.viewportCount);
+    }
+
+    return *this;
+}
+
+safe_VkPipelineViewportSwizzleStateCreateInfoNV::~safe_VkPipelineViewportSwizzleStateCreateInfoNV() {
+    if (pViewportSwizzles) delete[] pViewportSwizzles;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineViewportSwizzleStateCreateInfoNV::initialize(const VkPipelineViewportSwizzleStateCreateInfoNV* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pViewportSwizzles) delete[] pViewportSwizzles;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    viewportCount = in_struct->viewportCount;
+    pViewportSwizzles = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pViewportSwizzles) {
+        pViewportSwizzles = new VkViewportSwizzleNV[in_struct->viewportCount];
+        memcpy((void*)pViewportSwizzles, (void*)in_struct->pViewportSwizzles,
+               sizeof(VkViewportSwizzleNV) * in_struct->viewportCount);
+    }
+}
+
+void safe_VkPipelineViewportSwizzleStateCreateInfoNV::initialize(const safe_VkPipelineViewportSwizzleStateCreateInfoNV* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    viewportCount = copy_src->viewportCount;
+    pViewportSwizzles = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pViewportSwizzles) {
+        pViewportSwizzles = new VkViewportSwizzleNV[copy_src->viewportCount];
+        memcpy((void*)pViewportSwizzles, (void*)copy_src->pViewportSwizzles, sizeof(VkViewportSwizzleNV) * copy_src->viewportCount);
+    }
+}
+
+safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG::safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG(
+    const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), relaxedLineRasterization(in_struct->relaxedLineRasterization) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG::safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG),
+      pNext(nullptr),
+      relaxedLineRasterization() {}
+
+safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG::safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG(
+    const safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG& copy_src) {
+    sType = copy_src.sType;
+    relaxedLineRasterization = copy_src.relaxedLineRasterization;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG& safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG::operator=(
+    const safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    relaxedLineRasterization = copy_src.relaxedLineRasterization;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG::~safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG::initialize(
+    const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    relaxedLineRasterization = in_struct->relaxedLineRasterization;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG::initialize(
+    const safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    relaxedLineRasterization = copy_src->relaxedLineRasterization;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+
+safe_VkAndroidHardwareBufferUsageANDROID::safe_VkAndroidHardwareBufferUsageANDROID(
+    const VkAndroidHardwareBufferUsageANDROID* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), androidHardwareBufferUsage(in_struct->androidHardwareBufferUsage) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkAndroidHardwareBufferUsageANDROID::safe_VkAndroidHardwareBufferUsageANDROID()
+    : sType(VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID), pNext(nullptr), androidHardwareBufferUsage() {}
+
+safe_VkAndroidHardwareBufferUsageANDROID::safe_VkAndroidHardwareBufferUsageANDROID(
+    const safe_VkAndroidHardwareBufferUsageANDROID& copy_src) {
+    sType = copy_src.sType;
+    androidHardwareBufferUsage = copy_src.androidHardwareBufferUsage;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkAndroidHardwareBufferUsageANDROID& safe_VkAndroidHardwareBufferUsageANDROID::operator=(
+    const safe_VkAndroidHardwareBufferUsageANDROID& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    androidHardwareBufferUsage = copy_src.androidHardwareBufferUsage;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkAndroidHardwareBufferUsageANDROID::~safe_VkAndroidHardwareBufferUsageANDROID() { FreePnextChain(pNext); }
+
+void safe_VkAndroidHardwareBufferUsageANDROID::initialize(const VkAndroidHardwareBufferUsageANDROID* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    androidHardwareBufferUsage = in_struct->androidHardwareBufferUsage;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkAndroidHardwareBufferUsageANDROID::initialize(const safe_VkAndroidHardwareBufferUsageANDROID* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    androidHardwareBufferUsage = copy_src->androidHardwareBufferUsage;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkAndroidHardwareBufferPropertiesANDROID::safe_VkAndroidHardwareBufferPropertiesANDROID(
+    const VkAndroidHardwareBufferPropertiesANDROID* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), allocationSize(in_struct->allocationSize), memoryTypeBits(in_struct->memoryTypeBits) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkAndroidHardwareBufferPropertiesANDROID::safe_VkAndroidHardwareBufferPropertiesANDROID()
+    : sType(VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID), pNext(nullptr), allocationSize(), memoryTypeBits() {}
+
+safe_VkAndroidHardwareBufferPropertiesANDROID::safe_VkAndroidHardwareBufferPropertiesANDROID(
+    const safe_VkAndroidHardwareBufferPropertiesANDROID& copy_src) {
+    sType = copy_src.sType;
+    allocationSize = copy_src.allocationSize;
+    memoryTypeBits = copy_src.memoryTypeBits;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkAndroidHardwareBufferPropertiesANDROID& safe_VkAndroidHardwareBufferPropertiesANDROID::operator=(
+    const safe_VkAndroidHardwareBufferPropertiesANDROID& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    allocationSize = copy_src.allocationSize;
+    memoryTypeBits = copy_src.memoryTypeBits;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkAndroidHardwareBufferPropertiesANDROID::~safe_VkAndroidHardwareBufferPropertiesANDROID() { FreePnextChain(pNext); }
+
+void safe_VkAndroidHardwareBufferPropertiesANDROID::initialize(const VkAndroidHardwareBufferPropertiesANDROID* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    allocationSize = in_struct->allocationSize;
+    memoryTypeBits = in_struct->memoryTypeBits;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkAndroidHardwareBufferPropertiesANDROID::initialize(const safe_VkAndroidHardwareBufferPropertiesANDROID* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    allocationSize = copy_src->allocationSize;
+    memoryTypeBits = copy_src->memoryTypeBits;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkAndroidHardwareBufferFormatPropertiesANDROID::safe_VkAndroidHardwareBufferFormatPropertiesANDROID(
+    const VkAndroidHardwareBufferFormatPropertiesANDROID* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      format(in_struct->format),
+      externalFormat(in_struct->externalFormat),
+      formatFeatures(in_struct->formatFeatures),
+      samplerYcbcrConversionComponents(in_struct->samplerYcbcrConversionComponents),
+      suggestedYcbcrModel(in_struct->suggestedYcbcrModel),
+      suggestedYcbcrRange(in_struct->suggestedYcbcrRange),
+      suggestedXChromaOffset(in_struct->suggestedXChromaOffset),
+      suggestedYChromaOffset(in_struct->suggestedYChromaOffset) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkAndroidHardwareBufferFormatPropertiesANDROID::safe_VkAndroidHardwareBufferFormatPropertiesANDROID()
+    : sType(VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID),
+      pNext(nullptr),
+      format(),
+      externalFormat(),
+      formatFeatures(),
+      samplerYcbcrConversionComponents(),
+      suggestedYcbcrModel(),
+      suggestedYcbcrRange(),
+      suggestedXChromaOffset(),
+      suggestedYChromaOffset() {}
+
+safe_VkAndroidHardwareBufferFormatPropertiesANDROID::safe_VkAndroidHardwareBufferFormatPropertiesANDROID(
+    const safe_VkAndroidHardwareBufferFormatPropertiesANDROID& copy_src) {
+    sType = copy_src.sType;
+    format = copy_src.format;
+    externalFormat = copy_src.externalFormat;
+    formatFeatures = copy_src.formatFeatures;
+    samplerYcbcrConversionComponents = copy_src.samplerYcbcrConversionComponents;
+    suggestedYcbcrModel = copy_src.suggestedYcbcrModel;
+    suggestedYcbcrRange = copy_src.suggestedYcbcrRange;
+    suggestedXChromaOffset = copy_src.suggestedXChromaOffset;
+    suggestedYChromaOffset = copy_src.suggestedYChromaOffset;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkAndroidHardwareBufferFormatPropertiesANDROID& safe_VkAndroidHardwareBufferFormatPropertiesANDROID::operator=(
+    const safe_VkAndroidHardwareBufferFormatPropertiesANDROID& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    format = copy_src.format;
+    externalFormat = copy_src.externalFormat;
+    formatFeatures = copy_src.formatFeatures;
+    samplerYcbcrConversionComponents = copy_src.samplerYcbcrConversionComponents;
+    suggestedYcbcrModel = copy_src.suggestedYcbcrModel;
+    suggestedYcbcrRange = copy_src.suggestedYcbcrRange;
+    suggestedXChromaOffset = copy_src.suggestedXChromaOffset;
+    suggestedYChromaOffset = copy_src.suggestedYChromaOffset;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkAndroidHardwareBufferFormatPropertiesANDROID::~safe_VkAndroidHardwareBufferFormatPropertiesANDROID() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkAndroidHardwareBufferFormatPropertiesANDROID::initialize(
+    const VkAndroidHardwareBufferFormatPropertiesANDROID* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    format = in_struct->format;
+    externalFormat = in_struct->externalFormat;
+    formatFeatures = in_struct->formatFeatures;
+    samplerYcbcrConversionComponents = in_struct->samplerYcbcrConversionComponents;
+    suggestedYcbcrModel = in_struct->suggestedYcbcrModel;
+    suggestedYcbcrRange = in_struct->suggestedYcbcrRange;
+    suggestedXChromaOffset = in_struct->suggestedXChromaOffset;
+    suggestedYChromaOffset = in_struct->suggestedYChromaOffset;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkAndroidHardwareBufferFormatPropertiesANDROID::initialize(
+    const safe_VkAndroidHardwareBufferFormatPropertiesANDROID* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    format = copy_src->format;
+    externalFormat = copy_src->externalFormat;
+    formatFeatures = copy_src->formatFeatures;
+    samplerYcbcrConversionComponents = copy_src->samplerYcbcrConversionComponents;
+    suggestedYcbcrModel = copy_src->suggestedYcbcrModel;
+    suggestedYcbcrRange = copy_src->suggestedYcbcrRange;
+    suggestedXChromaOffset = copy_src->suggestedXChromaOffset;
+    suggestedYChromaOffset = copy_src->suggestedYChromaOffset;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkImportAndroidHardwareBufferInfoANDROID::safe_VkImportAndroidHardwareBufferInfoANDROID(
+    const VkImportAndroidHardwareBufferInfoANDROID* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), buffer(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    buffer = in_struct->buffer;
+}
+
+safe_VkImportAndroidHardwareBufferInfoANDROID::safe_VkImportAndroidHardwareBufferInfoANDROID()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID), pNext(nullptr), buffer(nullptr) {}
+
+safe_VkImportAndroidHardwareBufferInfoANDROID::safe_VkImportAndroidHardwareBufferInfoANDROID(
+    const safe_VkImportAndroidHardwareBufferInfoANDROID& copy_src) {
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+    buffer = copy_src.buffer;
+}
+
+safe_VkImportAndroidHardwareBufferInfoANDROID& safe_VkImportAndroidHardwareBufferInfoANDROID::operator=(
+    const safe_VkImportAndroidHardwareBufferInfoANDROID& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+    buffer = copy_src.buffer;
+
+    return *this;
+}
+
+safe_VkImportAndroidHardwareBufferInfoANDROID::~safe_VkImportAndroidHardwareBufferInfoANDROID() { FreePnextChain(pNext); }
+
+void safe_VkImportAndroidHardwareBufferInfoANDROID::initialize(const VkImportAndroidHardwareBufferInfoANDROID* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    buffer = in_struct->buffer;
+}
+
+void safe_VkImportAndroidHardwareBufferInfoANDROID::initialize(const safe_VkImportAndroidHardwareBufferInfoANDROID* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pNext = SafePnextCopy(copy_src->pNext);
+    buffer = copy_src->buffer;
+}
+
+safe_VkMemoryGetAndroidHardwareBufferInfoANDROID::safe_VkMemoryGetAndroidHardwareBufferInfoANDROID(
+    const VkMemoryGetAndroidHardwareBufferInfoANDROID* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), memory(in_struct->memory) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMemoryGetAndroidHardwareBufferInfoANDROID::safe_VkMemoryGetAndroidHardwareBufferInfoANDROID()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID), pNext(nullptr), memory() {}
+
+safe_VkMemoryGetAndroidHardwareBufferInfoANDROID::safe_VkMemoryGetAndroidHardwareBufferInfoANDROID(
+    const safe_VkMemoryGetAndroidHardwareBufferInfoANDROID& copy_src) {
+    sType = copy_src.sType;
+    memory = copy_src.memory;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMemoryGetAndroidHardwareBufferInfoANDROID& safe_VkMemoryGetAndroidHardwareBufferInfoANDROID::operator=(
+    const safe_VkMemoryGetAndroidHardwareBufferInfoANDROID& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    memory = copy_src.memory;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMemoryGetAndroidHardwareBufferInfoANDROID::~safe_VkMemoryGetAndroidHardwareBufferInfoANDROID() { FreePnextChain(pNext); }
+
+void safe_VkMemoryGetAndroidHardwareBufferInfoANDROID::initialize(const VkMemoryGetAndroidHardwareBufferInfoANDROID* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    memory = in_struct->memory;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMemoryGetAndroidHardwareBufferInfoANDROID::initialize(const safe_VkMemoryGetAndroidHardwareBufferInfoANDROID* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memory = copy_src->memory;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkExternalFormatANDROID::safe_VkExternalFormatANDROID(const VkExternalFormatANDROID* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), externalFormat(in_struct->externalFormat) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkExternalFormatANDROID::safe_VkExternalFormatANDROID()
+    : sType(VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID), pNext(nullptr), externalFormat() {}
+
+safe_VkExternalFormatANDROID::safe_VkExternalFormatANDROID(const safe_VkExternalFormatANDROID& copy_src) {
+    sType = copy_src.sType;
+    externalFormat = copy_src.externalFormat;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkExternalFormatANDROID& safe_VkExternalFormatANDROID::operator=(const safe_VkExternalFormatANDROID& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    externalFormat = copy_src.externalFormat;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkExternalFormatANDROID::~safe_VkExternalFormatANDROID() { FreePnextChain(pNext); }
+
+void safe_VkExternalFormatANDROID::initialize(const VkExternalFormatANDROID* in_struct,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    externalFormat = in_struct->externalFormat;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkExternalFormatANDROID::initialize(const safe_VkExternalFormatANDROID* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    externalFormat = copy_src->externalFormat;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkAndroidHardwareBufferFormatProperties2ANDROID::safe_VkAndroidHardwareBufferFormatProperties2ANDROID(
+    const VkAndroidHardwareBufferFormatProperties2ANDROID* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      format(in_struct->format),
+      externalFormat(in_struct->externalFormat),
+      formatFeatures(in_struct->formatFeatures),
+      samplerYcbcrConversionComponents(in_struct->samplerYcbcrConversionComponents),
+      suggestedYcbcrModel(in_struct->suggestedYcbcrModel),
+      suggestedYcbcrRange(in_struct->suggestedYcbcrRange),
+      suggestedXChromaOffset(in_struct->suggestedXChromaOffset),
+      suggestedYChromaOffset(in_struct->suggestedYChromaOffset) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkAndroidHardwareBufferFormatProperties2ANDROID::safe_VkAndroidHardwareBufferFormatProperties2ANDROID()
+    : sType(VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID),
+      pNext(nullptr),
+      format(),
+      externalFormat(),
+      formatFeatures(),
+      samplerYcbcrConversionComponents(),
+      suggestedYcbcrModel(),
+      suggestedYcbcrRange(),
+      suggestedXChromaOffset(),
+      suggestedYChromaOffset() {}
+
+safe_VkAndroidHardwareBufferFormatProperties2ANDROID::safe_VkAndroidHardwareBufferFormatProperties2ANDROID(
+    const safe_VkAndroidHardwareBufferFormatProperties2ANDROID& copy_src) {
+    sType = copy_src.sType;
+    format = copy_src.format;
+    externalFormat = copy_src.externalFormat;
+    formatFeatures = copy_src.formatFeatures;
+    samplerYcbcrConversionComponents = copy_src.samplerYcbcrConversionComponents;
+    suggestedYcbcrModel = copy_src.suggestedYcbcrModel;
+    suggestedYcbcrRange = copy_src.suggestedYcbcrRange;
+    suggestedXChromaOffset = copy_src.suggestedXChromaOffset;
+    suggestedYChromaOffset = copy_src.suggestedYChromaOffset;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkAndroidHardwareBufferFormatProperties2ANDROID& safe_VkAndroidHardwareBufferFormatProperties2ANDROID::operator=(
+    const safe_VkAndroidHardwareBufferFormatProperties2ANDROID& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    format = copy_src.format;
+    externalFormat = copy_src.externalFormat;
+    formatFeatures = copy_src.formatFeatures;
+    samplerYcbcrConversionComponents = copy_src.samplerYcbcrConversionComponents;
+    suggestedYcbcrModel = copy_src.suggestedYcbcrModel;
+    suggestedYcbcrRange = copy_src.suggestedYcbcrRange;
+    suggestedXChromaOffset = copy_src.suggestedXChromaOffset;
+    suggestedYChromaOffset = copy_src.suggestedYChromaOffset;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkAndroidHardwareBufferFormatProperties2ANDROID::~safe_VkAndroidHardwareBufferFormatProperties2ANDROID() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkAndroidHardwareBufferFormatProperties2ANDROID::initialize(
+    const VkAndroidHardwareBufferFormatProperties2ANDROID* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    format = in_struct->format;
+    externalFormat = in_struct->externalFormat;
+    formatFeatures = in_struct->formatFeatures;
+    samplerYcbcrConversionComponents = in_struct->samplerYcbcrConversionComponents;
+    suggestedYcbcrModel = in_struct->suggestedYcbcrModel;
+    suggestedYcbcrRange = in_struct->suggestedYcbcrRange;
+    suggestedXChromaOffset = in_struct->suggestedXChromaOffset;
+    suggestedYChromaOffset = in_struct->suggestedYChromaOffset;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkAndroidHardwareBufferFormatProperties2ANDROID::initialize(
+    const safe_VkAndroidHardwareBufferFormatProperties2ANDROID* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    format = copy_src->format;
+    externalFormat = copy_src->externalFormat;
+    formatFeatures = copy_src->formatFeatures;
+    samplerYcbcrConversionComponents = copy_src->samplerYcbcrConversionComponents;
+    suggestedYcbcrModel = copy_src->suggestedYcbcrModel;
+    suggestedYcbcrRange = copy_src->suggestedYcbcrRange;
+    suggestedXChromaOffset = copy_src->suggestedXChromaOffset;
+    suggestedYChromaOffset = copy_src->suggestedYChromaOffset;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+#endif  // VK_USE_PLATFORM_ANDROID_KHR
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+
+safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX::safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX(
+    const VkPhysicalDeviceShaderEnqueueFeaturesAMDX* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), shaderEnqueue(in_struct->shaderEnqueue) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX::safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX), pNext(nullptr), shaderEnqueue() {}
+
+safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX::safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX(
+    const safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX& copy_src) {
+    sType = copy_src.sType;
+    shaderEnqueue = copy_src.shaderEnqueue;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX& safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX::operator=(
+    const safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderEnqueue = copy_src.shaderEnqueue;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX::~safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX::initialize(const VkPhysicalDeviceShaderEnqueueFeaturesAMDX* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderEnqueue = in_struct->shaderEnqueue;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX::initialize(const safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderEnqueue = copy_src->shaderEnqueue;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX::safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX(
+    const VkPhysicalDeviceShaderEnqueuePropertiesAMDX* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      maxExecutionGraphDepth(in_struct->maxExecutionGraphDepth),
+      maxExecutionGraphShaderOutputNodes(in_struct->maxExecutionGraphShaderOutputNodes),
+      maxExecutionGraphShaderPayloadSize(in_struct->maxExecutionGraphShaderPayloadSize),
+      maxExecutionGraphShaderPayloadCount(in_struct->maxExecutionGraphShaderPayloadCount),
+      executionGraphDispatchAddressAlignment(in_struct->executionGraphDispatchAddressAlignment) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX::safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX),
+      pNext(nullptr),
+      maxExecutionGraphDepth(),
+      maxExecutionGraphShaderOutputNodes(),
+      maxExecutionGraphShaderPayloadSize(),
+      maxExecutionGraphShaderPayloadCount(),
+      executionGraphDispatchAddressAlignment() {}
+
+safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX::safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX(
+    const safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX& copy_src) {
+    sType = copy_src.sType;
+    maxExecutionGraphDepth = copy_src.maxExecutionGraphDepth;
+    maxExecutionGraphShaderOutputNodes = copy_src.maxExecutionGraphShaderOutputNodes;
+    maxExecutionGraphShaderPayloadSize = copy_src.maxExecutionGraphShaderPayloadSize;
+    maxExecutionGraphShaderPayloadCount = copy_src.maxExecutionGraphShaderPayloadCount;
+    executionGraphDispatchAddressAlignment = copy_src.executionGraphDispatchAddressAlignment;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX& safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX::operator=(
+    const safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxExecutionGraphDepth = copy_src.maxExecutionGraphDepth;
+    maxExecutionGraphShaderOutputNodes = copy_src.maxExecutionGraphShaderOutputNodes;
+    maxExecutionGraphShaderPayloadSize = copy_src.maxExecutionGraphShaderPayloadSize;
+    maxExecutionGraphShaderPayloadCount = copy_src.maxExecutionGraphShaderPayloadCount;
+    executionGraphDispatchAddressAlignment = copy_src.executionGraphDispatchAddressAlignment;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX::~safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX::initialize(const VkPhysicalDeviceShaderEnqueuePropertiesAMDX* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxExecutionGraphDepth = in_struct->maxExecutionGraphDepth;
+    maxExecutionGraphShaderOutputNodes = in_struct->maxExecutionGraphShaderOutputNodes;
+    maxExecutionGraphShaderPayloadSize = in_struct->maxExecutionGraphShaderPayloadSize;
+    maxExecutionGraphShaderPayloadCount = in_struct->maxExecutionGraphShaderPayloadCount;
+    executionGraphDispatchAddressAlignment = in_struct->executionGraphDispatchAddressAlignment;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX::initialize(const safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxExecutionGraphDepth = copy_src->maxExecutionGraphDepth;
+    maxExecutionGraphShaderOutputNodes = copy_src->maxExecutionGraphShaderOutputNodes;
+    maxExecutionGraphShaderPayloadSize = copy_src->maxExecutionGraphShaderPayloadSize;
+    maxExecutionGraphShaderPayloadCount = copy_src->maxExecutionGraphShaderPayloadCount;
+    executionGraphDispatchAddressAlignment = copy_src->executionGraphDispatchAddressAlignment;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkExecutionGraphPipelineScratchSizeAMDX::safe_VkExecutionGraphPipelineScratchSizeAMDX(
+    const VkExecutionGraphPipelineScratchSizeAMDX* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), size(in_struct->size) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkExecutionGraphPipelineScratchSizeAMDX::safe_VkExecutionGraphPipelineScratchSizeAMDX()
+    : sType(VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX), pNext(nullptr), size() {}
+
+safe_VkExecutionGraphPipelineScratchSizeAMDX::safe_VkExecutionGraphPipelineScratchSizeAMDX(
+    const safe_VkExecutionGraphPipelineScratchSizeAMDX& copy_src) {
+    sType = copy_src.sType;
+    size = copy_src.size;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkExecutionGraphPipelineScratchSizeAMDX& safe_VkExecutionGraphPipelineScratchSizeAMDX::operator=(
+    const safe_VkExecutionGraphPipelineScratchSizeAMDX& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    size = copy_src.size;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkExecutionGraphPipelineScratchSizeAMDX::~safe_VkExecutionGraphPipelineScratchSizeAMDX() { FreePnextChain(pNext); }
+
+void safe_VkExecutionGraphPipelineScratchSizeAMDX::initialize(const VkExecutionGraphPipelineScratchSizeAMDX* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    size = in_struct->size;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkExecutionGraphPipelineScratchSizeAMDX::initialize(const safe_VkExecutionGraphPipelineScratchSizeAMDX* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    size = copy_src->size;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkExecutionGraphPipelineCreateInfoAMDX::safe_VkExecutionGraphPipelineCreateInfoAMDX(
+    const VkExecutionGraphPipelineCreateInfoAMDX* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      stageCount(in_struct->stageCount),
+      pStages(nullptr),
+      pLibraryInfo(nullptr),
+      layout(in_struct->layout),
+      basePipelineHandle(in_struct->basePipelineHandle),
+      basePipelineIndex(in_struct->basePipelineIndex) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (stageCount && in_struct->pStages) {
+        pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&in_struct->pStages[i]);
+        }
+    }
+    if (in_struct->pLibraryInfo) pLibraryInfo = new safe_VkPipelineLibraryCreateInfoKHR(in_struct->pLibraryInfo);
+}
+
+safe_VkExecutionGraphPipelineCreateInfoAMDX::safe_VkExecutionGraphPipelineCreateInfoAMDX()
+    : sType(VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX),
+      pNext(nullptr),
+      flags(),
+      stageCount(),
+      pStages(nullptr),
+      pLibraryInfo(nullptr),
+      layout(),
+      basePipelineHandle(),
+      basePipelineIndex() {}
+
+safe_VkExecutionGraphPipelineCreateInfoAMDX::safe_VkExecutionGraphPipelineCreateInfoAMDX(
+    const safe_VkExecutionGraphPipelineCreateInfoAMDX& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    stageCount = copy_src.stageCount;
+    pStages = nullptr;
+    pLibraryInfo = nullptr;
+    layout = copy_src.layout;
+    basePipelineHandle = copy_src.basePipelineHandle;
+    basePipelineIndex = copy_src.basePipelineIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (stageCount && copy_src.pStages) {
+        pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&copy_src.pStages[i]);
+        }
+    }
+    if (copy_src.pLibraryInfo) pLibraryInfo = new safe_VkPipelineLibraryCreateInfoKHR(*copy_src.pLibraryInfo);
+}
+
+safe_VkExecutionGraphPipelineCreateInfoAMDX& safe_VkExecutionGraphPipelineCreateInfoAMDX::operator=(
+    const safe_VkExecutionGraphPipelineCreateInfoAMDX& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pStages) delete[] pStages;
+    if (pLibraryInfo) delete pLibraryInfo;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    stageCount = copy_src.stageCount;
+    pStages = nullptr;
+    pLibraryInfo = nullptr;
+    layout = copy_src.layout;
+    basePipelineHandle = copy_src.basePipelineHandle;
+    basePipelineIndex = copy_src.basePipelineIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (stageCount && copy_src.pStages) {
+        pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&copy_src.pStages[i]);
+        }
+    }
+    if (copy_src.pLibraryInfo) pLibraryInfo = new safe_VkPipelineLibraryCreateInfoKHR(*copy_src.pLibraryInfo);
+
+    return *this;
+}
+
+safe_VkExecutionGraphPipelineCreateInfoAMDX::~safe_VkExecutionGraphPipelineCreateInfoAMDX() {
+    if (pStages) delete[] pStages;
+    if (pLibraryInfo) delete pLibraryInfo;
+    FreePnextChain(pNext);
+}
+
+void safe_VkExecutionGraphPipelineCreateInfoAMDX::initialize(const VkExecutionGraphPipelineCreateInfoAMDX* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pStages) delete[] pStages;
+    if (pLibraryInfo) delete pLibraryInfo;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    stageCount = in_struct->stageCount;
+    pStages = nullptr;
+    pLibraryInfo = nullptr;
+    layout = in_struct->layout;
+    basePipelineHandle = in_struct->basePipelineHandle;
+    basePipelineIndex = in_struct->basePipelineIndex;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (stageCount && in_struct->pStages) {
+        pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&in_struct->pStages[i]);
+        }
+    }
+    if (in_struct->pLibraryInfo) pLibraryInfo = new safe_VkPipelineLibraryCreateInfoKHR(in_struct->pLibraryInfo);
+}
+
+void safe_VkExecutionGraphPipelineCreateInfoAMDX::initialize(const safe_VkExecutionGraphPipelineCreateInfoAMDX* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    stageCount = copy_src->stageCount;
+    pStages = nullptr;
+    pLibraryInfo = nullptr;
+    layout = copy_src->layout;
+    basePipelineHandle = copy_src->basePipelineHandle;
+    basePipelineIndex = copy_src->basePipelineIndex;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (stageCount && copy_src->pStages) {
+        pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&copy_src->pStages[i]);
+        }
+    }
+    if (copy_src->pLibraryInfo) pLibraryInfo = new safe_VkPipelineLibraryCreateInfoKHR(*copy_src->pLibraryInfo);
+}
+
+safe_VkDeviceOrHostAddressConstAMDX::safe_VkDeviceOrHostAddressConstAMDX(const VkDeviceOrHostAddressConstAMDX* in_struct,
+                                                                         PNextCopyState*) {
+    initialize(in_struct);
+}
+
+safe_VkDeviceOrHostAddressConstAMDX::safe_VkDeviceOrHostAddressConstAMDX() : hostAddress(nullptr) {}
+
+safe_VkDeviceOrHostAddressConstAMDX::safe_VkDeviceOrHostAddressConstAMDX(const safe_VkDeviceOrHostAddressConstAMDX& copy_src) {
+    deviceAddress = copy_src.deviceAddress;
+    hostAddress = copy_src.hostAddress;
+}
+
+safe_VkDeviceOrHostAddressConstAMDX& safe_VkDeviceOrHostAddressConstAMDX::operator=(
+    const safe_VkDeviceOrHostAddressConstAMDX& copy_src) {
+    if (&copy_src == this) return *this;
+
+    deviceAddress = copy_src.deviceAddress;
+    hostAddress = copy_src.hostAddress;
+
+    return *this;
+}
+
+safe_VkDeviceOrHostAddressConstAMDX::~safe_VkDeviceOrHostAddressConstAMDX() {}
+
+void safe_VkDeviceOrHostAddressConstAMDX::initialize(const VkDeviceOrHostAddressConstAMDX* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    deviceAddress = in_struct->deviceAddress;
+    hostAddress = in_struct->hostAddress;
+}
+
+void safe_VkDeviceOrHostAddressConstAMDX::initialize(const safe_VkDeviceOrHostAddressConstAMDX* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    deviceAddress = copy_src->deviceAddress;
+    hostAddress = copy_src->hostAddress;
+}
+
+safe_VkPipelineShaderStageNodeCreateInfoAMDX::safe_VkPipelineShaderStageNodeCreateInfoAMDX(
+    const VkPipelineShaderStageNodeCreateInfoAMDX* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), index(in_struct->index) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    pName = SafeStringCopy(in_struct->pName);
+}
+
+safe_VkPipelineShaderStageNodeCreateInfoAMDX::safe_VkPipelineShaderStageNodeCreateInfoAMDX()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX), pNext(nullptr), pName(nullptr), index() {}
+
+safe_VkPipelineShaderStageNodeCreateInfoAMDX::safe_VkPipelineShaderStageNodeCreateInfoAMDX(
+    const safe_VkPipelineShaderStageNodeCreateInfoAMDX& copy_src) {
+    sType = copy_src.sType;
+    index = copy_src.index;
+    pNext = SafePnextCopy(copy_src.pNext);
+    pName = SafeStringCopy(copy_src.pName);
+}
+
+safe_VkPipelineShaderStageNodeCreateInfoAMDX& safe_VkPipelineShaderStageNodeCreateInfoAMDX::operator=(
+    const safe_VkPipelineShaderStageNodeCreateInfoAMDX& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pName) delete[] pName;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    index = copy_src.index;
+    pNext = SafePnextCopy(copy_src.pNext);
+    pName = SafeStringCopy(copy_src.pName);
+
+    return *this;
+}
+
+safe_VkPipelineShaderStageNodeCreateInfoAMDX::~safe_VkPipelineShaderStageNodeCreateInfoAMDX() {
+    if (pName) delete[] pName;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineShaderStageNodeCreateInfoAMDX::initialize(const VkPipelineShaderStageNodeCreateInfoAMDX* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pName) delete[] pName;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    index = in_struct->index;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    pName = SafeStringCopy(in_struct->pName);
+}
+
+void safe_VkPipelineShaderStageNodeCreateInfoAMDX::initialize(const safe_VkPipelineShaderStageNodeCreateInfoAMDX* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    index = copy_src->index;
+    pNext = SafePnextCopy(copy_src->pNext);
+    pName = SafeStringCopy(copy_src->pName);
+}
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+
+safe_VkPipelineCoverageToColorStateCreateInfoNV::safe_VkPipelineCoverageToColorStateCreateInfoNV(
+    const VkPipelineCoverageToColorStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      coverageToColorEnable(in_struct->coverageToColorEnable),
+      coverageToColorLocation(in_struct->coverageToColorLocation) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPipelineCoverageToColorStateCreateInfoNV::safe_VkPipelineCoverageToColorStateCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV),
+      pNext(nullptr),
+      flags(),
+      coverageToColorEnable(),
+      coverageToColorLocation() {}
+
+safe_VkPipelineCoverageToColorStateCreateInfoNV::safe_VkPipelineCoverageToColorStateCreateInfoNV(
+    const safe_VkPipelineCoverageToColorStateCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    coverageToColorEnable = copy_src.coverageToColorEnable;
+    coverageToColorLocation = copy_src.coverageToColorLocation;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPipelineCoverageToColorStateCreateInfoNV& safe_VkPipelineCoverageToColorStateCreateInfoNV::operator=(
+    const safe_VkPipelineCoverageToColorStateCreateInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    coverageToColorEnable = copy_src.coverageToColorEnable;
+    coverageToColorLocation = copy_src.coverageToColorLocation;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineCoverageToColorStateCreateInfoNV::~safe_VkPipelineCoverageToColorStateCreateInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkPipelineCoverageToColorStateCreateInfoNV::initialize(const VkPipelineCoverageToColorStateCreateInfoNV* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    coverageToColorEnable = in_struct->coverageToColorEnable;
+    coverageToColorLocation = in_struct->coverageToColorLocation;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPipelineCoverageToColorStateCreateInfoNV::initialize(const safe_VkPipelineCoverageToColorStateCreateInfoNV* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    coverageToColorEnable = copy_src->coverageToColorEnable;
+    coverageToColorLocation = copy_src->coverageToColorLocation;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineCoverageModulationStateCreateInfoNV::safe_VkPipelineCoverageModulationStateCreateInfoNV(
+    const VkPipelineCoverageModulationStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      coverageModulationMode(in_struct->coverageModulationMode),
+      coverageModulationTableEnable(in_struct->coverageModulationTableEnable),
+      coverageModulationTableCount(in_struct->coverageModulationTableCount),
+      pCoverageModulationTable(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pCoverageModulationTable) {
+        pCoverageModulationTable = new float[in_struct->coverageModulationTableCount];
+        memcpy((void*)pCoverageModulationTable, (void*)in_struct->pCoverageModulationTable,
+               sizeof(float) * in_struct->coverageModulationTableCount);
+    }
+}
+
+safe_VkPipelineCoverageModulationStateCreateInfoNV::safe_VkPipelineCoverageModulationStateCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV),
+      pNext(nullptr),
+      flags(),
+      coverageModulationMode(),
+      coverageModulationTableEnable(),
+      coverageModulationTableCount(),
+      pCoverageModulationTable(nullptr) {}
+
+safe_VkPipelineCoverageModulationStateCreateInfoNV::safe_VkPipelineCoverageModulationStateCreateInfoNV(
+    const safe_VkPipelineCoverageModulationStateCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    coverageModulationMode = copy_src.coverageModulationMode;
+    coverageModulationTableEnable = copy_src.coverageModulationTableEnable;
+    coverageModulationTableCount = copy_src.coverageModulationTableCount;
+    pCoverageModulationTable = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pCoverageModulationTable) {
+        pCoverageModulationTable = new float[copy_src.coverageModulationTableCount];
+        memcpy((void*)pCoverageModulationTable, (void*)copy_src.pCoverageModulationTable,
+               sizeof(float) * copy_src.coverageModulationTableCount);
+    }
+}
+
+safe_VkPipelineCoverageModulationStateCreateInfoNV& safe_VkPipelineCoverageModulationStateCreateInfoNV::operator=(
+    const safe_VkPipelineCoverageModulationStateCreateInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pCoverageModulationTable) delete[] pCoverageModulationTable;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    coverageModulationMode = copy_src.coverageModulationMode;
+    coverageModulationTableEnable = copy_src.coverageModulationTableEnable;
+    coverageModulationTableCount = copy_src.coverageModulationTableCount;
+    pCoverageModulationTable = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pCoverageModulationTable) {
+        pCoverageModulationTable = new float[copy_src.coverageModulationTableCount];
+        memcpy((void*)pCoverageModulationTable, (void*)copy_src.pCoverageModulationTable,
+               sizeof(float) * copy_src.coverageModulationTableCount);
+    }
+
+    return *this;
+}
+
+safe_VkPipelineCoverageModulationStateCreateInfoNV::~safe_VkPipelineCoverageModulationStateCreateInfoNV() {
+    if (pCoverageModulationTable) delete[] pCoverageModulationTable;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineCoverageModulationStateCreateInfoNV::initialize(const VkPipelineCoverageModulationStateCreateInfoNV* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pCoverageModulationTable) delete[] pCoverageModulationTable;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    coverageModulationMode = in_struct->coverageModulationMode;
+    coverageModulationTableEnable = in_struct->coverageModulationTableEnable;
+    coverageModulationTableCount = in_struct->coverageModulationTableCount;
+    pCoverageModulationTable = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pCoverageModulationTable) {
+        pCoverageModulationTable = new float[in_struct->coverageModulationTableCount];
+        memcpy((void*)pCoverageModulationTable, (void*)in_struct->pCoverageModulationTable,
+               sizeof(float) * in_struct->coverageModulationTableCount);
+    }
+}
+
+void safe_VkPipelineCoverageModulationStateCreateInfoNV::initialize(
+    const safe_VkPipelineCoverageModulationStateCreateInfoNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    coverageModulationMode = copy_src->coverageModulationMode;
+    coverageModulationTableEnable = copy_src->coverageModulationTableEnable;
+    coverageModulationTableCount = copy_src->coverageModulationTableCount;
+    pCoverageModulationTable = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pCoverageModulationTable) {
+        pCoverageModulationTable = new float[copy_src->coverageModulationTableCount];
+        memcpy((void*)pCoverageModulationTable, (void*)copy_src->pCoverageModulationTable,
+               sizeof(float) * copy_src->coverageModulationTableCount);
+    }
+}
+
+safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV::safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
+    const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), shaderSMCount(in_struct->shaderSMCount), shaderWarpsPerSM(in_struct->shaderWarpsPerSM) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV::safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV),
+      pNext(nullptr),
+      shaderSMCount(),
+      shaderWarpsPerSM() {}
+
+safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV::safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
+    const safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    shaderSMCount = copy_src.shaderSMCount;
+    shaderWarpsPerSM = copy_src.shaderWarpsPerSM;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV::operator=(
+    const safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderSMCount = copy_src.shaderSMCount;
+    shaderWarpsPerSM = copy_src.shaderWarpsPerSM;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV::~safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV::initialize(const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderSMCount = in_struct->shaderSMCount;
+    shaderWarpsPerSM = in_struct->shaderWarpsPerSM;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV::initialize(
+    const safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderSMCount = copy_src->shaderSMCount;
+    shaderWarpsPerSM = copy_src->shaderWarpsPerSM;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
+    const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), shaderSMBuiltins(in_struct->shaderSMBuiltins) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV), pNext(nullptr), shaderSMBuiltins() {}
+
+safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
+    const safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    shaderSMBuiltins = copy_src.shaderSMBuiltins;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderSMBuiltins = copy_src.shaderSMBuiltins;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::~safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::initialize(const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderSMBuiltins = in_struct->shaderSMBuiltins;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::initialize(const safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderSMBuiltins = copy_src->shaderSMBuiltins;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkShadingRatePaletteNV::safe_VkShadingRatePaletteNV(const VkShadingRatePaletteNV* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state)
+    : shadingRatePaletteEntryCount(in_struct->shadingRatePaletteEntryCount), pShadingRatePaletteEntries(nullptr) {
+    if (in_struct->pShadingRatePaletteEntries) {
+        pShadingRatePaletteEntries = new VkShadingRatePaletteEntryNV[in_struct->shadingRatePaletteEntryCount];
+        memcpy((void*)pShadingRatePaletteEntries, (void*)in_struct->pShadingRatePaletteEntries,
+               sizeof(VkShadingRatePaletteEntryNV) * in_struct->shadingRatePaletteEntryCount);
+    }
+}
+
+safe_VkShadingRatePaletteNV::safe_VkShadingRatePaletteNV() : shadingRatePaletteEntryCount(), pShadingRatePaletteEntries(nullptr) {}
+
+safe_VkShadingRatePaletteNV::safe_VkShadingRatePaletteNV(const safe_VkShadingRatePaletteNV& copy_src) {
+    shadingRatePaletteEntryCount = copy_src.shadingRatePaletteEntryCount;
+    pShadingRatePaletteEntries = nullptr;
+
+    if (copy_src.pShadingRatePaletteEntries) {
+        pShadingRatePaletteEntries = new VkShadingRatePaletteEntryNV[copy_src.shadingRatePaletteEntryCount];
+        memcpy((void*)pShadingRatePaletteEntries, (void*)copy_src.pShadingRatePaletteEntries,
+               sizeof(VkShadingRatePaletteEntryNV) * copy_src.shadingRatePaletteEntryCount);
+    }
+}
+
+safe_VkShadingRatePaletteNV& safe_VkShadingRatePaletteNV::operator=(const safe_VkShadingRatePaletteNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pShadingRatePaletteEntries) delete[] pShadingRatePaletteEntries;
+
+    shadingRatePaletteEntryCount = copy_src.shadingRatePaletteEntryCount;
+    pShadingRatePaletteEntries = nullptr;
+
+    if (copy_src.pShadingRatePaletteEntries) {
+        pShadingRatePaletteEntries = new VkShadingRatePaletteEntryNV[copy_src.shadingRatePaletteEntryCount];
+        memcpy((void*)pShadingRatePaletteEntries, (void*)copy_src.pShadingRatePaletteEntries,
+               sizeof(VkShadingRatePaletteEntryNV) * copy_src.shadingRatePaletteEntryCount);
+    }
+
+    return *this;
+}
+
+safe_VkShadingRatePaletteNV::~safe_VkShadingRatePaletteNV() {
+    if (pShadingRatePaletteEntries) delete[] pShadingRatePaletteEntries;
+}
+
+void safe_VkShadingRatePaletteNV::initialize(const VkShadingRatePaletteNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pShadingRatePaletteEntries) delete[] pShadingRatePaletteEntries;
+    shadingRatePaletteEntryCount = in_struct->shadingRatePaletteEntryCount;
+    pShadingRatePaletteEntries = nullptr;
+
+    if (in_struct->pShadingRatePaletteEntries) {
+        pShadingRatePaletteEntries = new VkShadingRatePaletteEntryNV[in_struct->shadingRatePaletteEntryCount];
+        memcpy((void*)pShadingRatePaletteEntries, (void*)in_struct->pShadingRatePaletteEntries,
+               sizeof(VkShadingRatePaletteEntryNV) * in_struct->shadingRatePaletteEntryCount);
+    }
+}
+
+void safe_VkShadingRatePaletteNV::initialize(const safe_VkShadingRatePaletteNV* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    shadingRatePaletteEntryCount = copy_src->shadingRatePaletteEntryCount;
+    pShadingRatePaletteEntries = nullptr;
+
+    if (copy_src->pShadingRatePaletteEntries) {
+        pShadingRatePaletteEntries = new VkShadingRatePaletteEntryNV[copy_src->shadingRatePaletteEntryCount];
+        memcpy((void*)pShadingRatePaletteEntries, (void*)copy_src->pShadingRatePaletteEntries,
+               sizeof(VkShadingRatePaletteEntryNV) * copy_src->shadingRatePaletteEntryCount);
+    }
+}
+
+safe_VkPipelineViewportShadingRateImageStateCreateInfoNV::safe_VkPipelineViewportShadingRateImageStateCreateInfoNV(
+    const VkPipelineViewportShadingRateImageStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      shadingRateImageEnable(in_struct->shadingRateImageEnable),
+      viewportCount(in_struct->viewportCount),
+      pShadingRatePalettes(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (viewportCount && in_struct->pShadingRatePalettes) {
+        pShadingRatePalettes = new safe_VkShadingRatePaletteNV[viewportCount];
+        for (uint32_t i = 0; i < viewportCount; ++i) {
+            pShadingRatePalettes[i].initialize(&in_struct->pShadingRatePalettes[i]);
+        }
+    }
+}
+
+safe_VkPipelineViewportShadingRateImageStateCreateInfoNV::safe_VkPipelineViewportShadingRateImageStateCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV),
+      pNext(nullptr),
+      shadingRateImageEnable(),
+      viewportCount(),
+      pShadingRatePalettes(nullptr) {}
+
+safe_VkPipelineViewportShadingRateImageStateCreateInfoNV::safe_VkPipelineViewportShadingRateImageStateCreateInfoNV(
+    const safe_VkPipelineViewportShadingRateImageStateCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    shadingRateImageEnable = copy_src.shadingRateImageEnable;
+    viewportCount = copy_src.viewportCount;
+    pShadingRatePalettes = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (viewportCount && copy_src.pShadingRatePalettes) {
+        pShadingRatePalettes = new safe_VkShadingRatePaletteNV[viewportCount];
+        for (uint32_t i = 0; i < viewportCount; ++i) {
+            pShadingRatePalettes[i].initialize(&copy_src.pShadingRatePalettes[i]);
+        }
+    }
+}
+
+safe_VkPipelineViewportShadingRateImageStateCreateInfoNV& safe_VkPipelineViewportShadingRateImageStateCreateInfoNV::operator=(
+    const safe_VkPipelineViewportShadingRateImageStateCreateInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pShadingRatePalettes) delete[] pShadingRatePalettes;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shadingRateImageEnable = copy_src.shadingRateImageEnable;
+    viewportCount = copy_src.viewportCount;
+    pShadingRatePalettes = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (viewportCount && copy_src.pShadingRatePalettes) {
+        pShadingRatePalettes = new safe_VkShadingRatePaletteNV[viewportCount];
+        for (uint32_t i = 0; i < viewportCount; ++i) {
+            pShadingRatePalettes[i].initialize(&copy_src.pShadingRatePalettes[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkPipelineViewportShadingRateImageStateCreateInfoNV::~safe_VkPipelineViewportShadingRateImageStateCreateInfoNV() {
+    if (pShadingRatePalettes) delete[] pShadingRatePalettes;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineViewportShadingRateImageStateCreateInfoNV::initialize(
+    const VkPipelineViewportShadingRateImageStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pShadingRatePalettes) delete[] pShadingRatePalettes;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shadingRateImageEnable = in_struct->shadingRateImageEnable;
+    viewportCount = in_struct->viewportCount;
+    pShadingRatePalettes = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (viewportCount && in_struct->pShadingRatePalettes) {
+        pShadingRatePalettes = new safe_VkShadingRatePaletteNV[viewportCount];
+        for (uint32_t i = 0; i < viewportCount; ++i) {
+            pShadingRatePalettes[i].initialize(&in_struct->pShadingRatePalettes[i]);
+        }
+    }
+}
+
+void safe_VkPipelineViewportShadingRateImageStateCreateInfoNV::initialize(
+    const safe_VkPipelineViewportShadingRateImageStateCreateInfoNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shadingRateImageEnable = copy_src->shadingRateImageEnable;
+    viewportCount = copy_src->viewportCount;
+    pShadingRatePalettes = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (viewportCount && copy_src->pShadingRatePalettes) {
+        pShadingRatePalettes = new safe_VkShadingRatePaletteNV[viewportCount];
+        for (uint32_t i = 0; i < viewportCount; ++i) {
+            pShadingRatePalettes[i].initialize(&copy_src->pShadingRatePalettes[i]);
+        }
+    }
+}
+
+safe_VkPhysicalDeviceShadingRateImageFeaturesNV::safe_VkPhysicalDeviceShadingRateImageFeaturesNV(
+    const VkPhysicalDeviceShadingRateImageFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      shadingRateImage(in_struct->shadingRateImage),
+      shadingRateCoarseSampleOrder(in_struct->shadingRateCoarseSampleOrder) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShadingRateImageFeaturesNV::safe_VkPhysicalDeviceShadingRateImageFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV),
+      pNext(nullptr),
+      shadingRateImage(),
+      shadingRateCoarseSampleOrder() {}
+
+safe_VkPhysicalDeviceShadingRateImageFeaturesNV::safe_VkPhysicalDeviceShadingRateImageFeaturesNV(
+    const safe_VkPhysicalDeviceShadingRateImageFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    shadingRateImage = copy_src.shadingRateImage;
+    shadingRateCoarseSampleOrder = copy_src.shadingRateCoarseSampleOrder;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShadingRateImageFeaturesNV& safe_VkPhysicalDeviceShadingRateImageFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceShadingRateImageFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shadingRateImage = copy_src.shadingRateImage;
+    shadingRateCoarseSampleOrder = copy_src.shadingRateCoarseSampleOrder;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShadingRateImageFeaturesNV::~safe_VkPhysicalDeviceShadingRateImageFeaturesNV() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceShadingRateImageFeaturesNV::initialize(const VkPhysicalDeviceShadingRateImageFeaturesNV* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shadingRateImage = in_struct->shadingRateImage;
+    shadingRateCoarseSampleOrder = in_struct->shadingRateCoarseSampleOrder;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShadingRateImageFeaturesNV::initialize(const safe_VkPhysicalDeviceShadingRateImageFeaturesNV* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shadingRateImage = copy_src->shadingRateImage;
+    shadingRateCoarseSampleOrder = copy_src->shadingRateCoarseSampleOrder;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceShadingRateImagePropertiesNV::safe_VkPhysicalDeviceShadingRateImagePropertiesNV(
+    const VkPhysicalDeviceShadingRateImagePropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      shadingRateTexelSize(in_struct->shadingRateTexelSize),
+      shadingRatePaletteSize(in_struct->shadingRatePaletteSize),
+      shadingRateMaxCoarseSamples(in_struct->shadingRateMaxCoarseSamples) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShadingRateImagePropertiesNV::safe_VkPhysicalDeviceShadingRateImagePropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV),
+      pNext(nullptr),
+      shadingRateTexelSize(),
+      shadingRatePaletteSize(),
+      shadingRateMaxCoarseSamples() {}
+
+safe_VkPhysicalDeviceShadingRateImagePropertiesNV::safe_VkPhysicalDeviceShadingRateImagePropertiesNV(
+    const safe_VkPhysicalDeviceShadingRateImagePropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    shadingRateTexelSize = copy_src.shadingRateTexelSize;
+    shadingRatePaletteSize = copy_src.shadingRatePaletteSize;
+    shadingRateMaxCoarseSamples = copy_src.shadingRateMaxCoarseSamples;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShadingRateImagePropertiesNV& safe_VkPhysicalDeviceShadingRateImagePropertiesNV::operator=(
+    const safe_VkPhysicalDeviceShadingRateImagePropertiesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shadingRateTexelSize = copy_src.shadingRateTexelSize;
+    shadingRatePaletteSize = copy_src.shadingRatePaletteSize;
+    shadingRateMaxCoarseSamples = copy_src.shadingRateMaxCoarseSamples;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShadingRateImagePropertiesNV::~safe_VkPhysicalDeviceShadingRateImagePropertiesNV() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceShadingRateImagePropertiesNV::initialize(const VkPhysicalDeviceShadingRateImagePropertiesNV* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shadingRateTexelSize = in_struct->shadingRateTexelSize;
+    shadingRatePaletteSize = in_struct->shadingRatePaletteSize;
+    shadingRateMaxCoarseSamples = in_struct->shadingRateMaxCoarseSamples;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShadingRateImagePropertiesNV::initialize(
+    const safe_VkPhysicalDeviceShadingRateImagePropertiesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shadingRateTexelSize = copy_src->shadingRateTexelSize;
+    shadingRatePaletteSize = copy_src->shadingRatePaletteSize;
+    shadingRateMaxCoarseSamples = copy_src->shadingRateMaxCoarseSamples;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkCoarseSampleOrderCustomNV::safe_VkCoarseSampleOrderCustomNV(const VkCoarseSampleOrderCustomNV* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state)
+    : shadingRate(in_struct->shadingRate),
+      sampleCount(in_struct->sampleCount),
+      sampleLocationCount(in_struct->sampleLocationCount),
+      pSampleLocations(nullptr) {
+    if (in_struct->pSampleLocations) {
+        pSampleLocations = new VkCoarseSampleLocationNV[in_struct->sampleLocationCount];
+        memcpy((void*)pSampleLocations, (void*)in_struct->pSampleLocations,
+               sizeof(VkCoarseSampleLocationNV) * in_struct->sampleLocationCount);
+    }
+}
+
+safe_VkCoarseSampleOrderCustomNV::safe_VkCoarseSampleOrderCustomNV()
+    : shadingRate(), sampleCount(), sampleLocationCount(), pSampleLocations(nullptr) {}
+
+safe_VkCoarseSampleOrderCustomNV::safe_VkCoarseSampleOrderCustomNV(const safe_VkCoarseSampleOrderCustomNV& copy_src) {
+    shadingRate = copy_src.shadingRate;
+    sampleCount = copy_src.sampleCount;
+    sampleLocationCount = copy_src.sampleLocationCount;
+    pSampleLocations = nullptr;
+
+    if (copy_src.pSampleLocations) {
+        pSampleLocations = new VkCoarseSampleLocationNV[copy_src.sampleLocationCount];
+        memcpy((void*)pSampleLocations, (void*)copy_src.pSampleLocations,
+               sizeof(VkCoarseSampleLocationNV) * copy_src.sampleLocationCount);
+    }
+}
+
+safe_VkCoarseSampleOrderCustomNV& safe_VkCoarseSampleOrderCustomNV::operator=(const safe_VkCoarseSampleOrderCustomNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pSampleLocations) delete[] pSampleLocations;
+
+    shadingRate = copy_src.shadingRate;
+    sampleCount = copy_src.sampleCount;
+    sampleLocationCount = copy_src.sampleLocationCount;
+    pSampleLocations = nullptr;
+
+    if (copy_src.pSampleLocations) {
+        pSampleLocations = new VkCoarseSampleLocationNV[copy_src.sampleLocationCount];
+        memcpy((void*)pSampleLocations, (void*)copy_src.pSampleLocations,
+               sizeof(VkCoarseSampleLocationNV) * copy_src.sampleLocationCount);
+    }
+
+    return *this;
+}
+
+safe_VkCoarseSampleOrderCustomNV::~safe_VkCoarseSampleOrderCustomNV() {
+    if (pSampleLocations) delete[] pSampleLocations;
+}
+
+void safe_VkCoarseSampleOrderCustomNV::initialize(const VkCoarseSampleOrderCustomNV* in_struct,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pSampleLocations) delete[] pSampleLocations;
+    shadingRate = in_struct->shadingRate;
+    sampleCount = in_struct->sampleCount;
+    sampleLocationCount = in_struct->sampleLocationCount;
+    pSampleLocations = nullptr;
+
+    if (in_struct->pSampleLocations) {
+        pSampleLocations = new VkCoarseSampleLocationNV[in_struct->sampleLocationCount];
+        memcpy((void*)pSampleLocations, (void*)in_struct->pSampleLocations,
+               sizeof(VkCoarseSampleLocationNV) * in_struct->sampleLocationCount);
+    }
+}
+
+void safe_VkCoarseSampleOrderCustomNV::initialize(const safe_VkCoarseSampleOrderCustomNV* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    shadingRate = copy_src->shadingRate;
+    sampleCount = copy_src->sampleCount;
+    sampleLocationCount = copy_src->sampleLocationCount;
+    pSampleLocations = nullptr;
+
+    if (copy_src->pSampleLocations) {
+        pSampleLocations = new VkCoarseSampleLocationNV[copy_src->sampleLocationCount];
+        memcpy((void*)pSampleLocations, (void*)copy_src->pSampleLocations,
+               sizeof(VkCoarseSampleLocationNV) * copy_src->sampleLocationCount);
+    }
+}
+
+safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV::safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
+    const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      sampleOrderType(in_struct->sampleOrderType),
+      customSampleOrderCount(in_struct->customSampleOrderCount),
+      pCustomSampleOrders(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (customSampleOrderCount && in_struct->pCustomSampleOrders) {
+        pCustomSampleOrders = new safe_VkCoarseSampleOrderCustomNV[customSampleOrderCount];
+        for (uint32_t i = 0; i < customSampleOrderCount; ++i) {
+            pCustomSampleOrders[i].initialize(&in_struct->pCustomSampleOrders[i]);
+        }
+    }
+}
+
+safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV::safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV),
+      pNext(nullptr),
+      sampleOrderType(),
+      customSampleOrderCount(),
+      pCustomSampleOrders(nullptr) {}
+
+safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV::safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
+    const safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    sampleOrderType = copy_src.sampleOrderType;
+    customSampleOrderCount = copy_src.customSampleOrderCount;
+    pCustomSampleOrders = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (customSampleOrderCount && copy_src.pCustomSampleOrders) {
+        pCustomSampleOrders = new safe_VkCoarseSampleOrderCustomNV[customSampleOrderCount];
+        for (uint32_t i = 0; i < customSampleOrderCount; ++i) {
+            pCustomSampleOrders[i].initialize(&copy_src.pCustomSampleOrders[i]);
+        }
+    }
+}
+
+safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV::operator=(
+    const safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pCustomSampleOrders) delete[] pCustomSampleOrders;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    sampleOrderType = copy_src.sampleOrderType;
+    customSampleOrderCount = copy_src.customSampleOrderCount;
+    pCustomSampleOrders = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (customSampleOrderCount && copy_src.pCustomSampleOrders) {
+        pCustomSampleOrders = new safe_VkCoarseSampleOrderCustomNV[customSampleOrderCount];
+        for (uint32_t i = 0; i < customSampleOrderCount; ++i) {
+            pCustomSampleOrders[i].initialize(&copy_src.pCustomSampleOrders[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV::~safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV() {
+    if (pCustomSampleOrders) delete[] pCustomSampleOrders;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV::initialize(
+    const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pCustomSampleOrders) delete[] pCustomSampleOrders;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    sampleOrderType = in_struct->sampleOrderType;
+    customSampleOrderCount = in_struct->customSampleOrderCount;
+    pCustomSampleOrders = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (customSampleOrderCount && in_struct->pCustomSampleOrders) {
+        pCustomSampleOrders = new safe_VkCoarseSampleOrderCustomNV[customSampleOrderCount];
+        for (uint32_t i = 0; i < customSampleOrderCount; ++i) {
+            pCustomSampleOrders[i].initialize(&in_struct->pCustomSampleOrders[i]);
+        }
+    }
+}
+
+void safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV::initialize(
+    const safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    sampleOrderType = copy_src->sampleOrderType;
+    customSampleOrderCount = copy_src->customSampleOrderCount;
+    pCustomSampleOrders = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (customSampleOrderCount && copy_src->pCustomSampleOrders) {
+        pCustomSampleOrders = new safe_VkCoarseSampleOrderCustomNV[customSampleOrderCount];
+        for (uint32_t i = 0; i < customSampleOrderCount; ++i) {
+            pCustomSampleOrders[i].initialize(&copy_src->pCustomSampleOrders[i]);
+        }
+    }
+}
+
+safe_VkRayTracingShaderGroupCreateInfoNV::safe_VkRayTracingShaderGroupCreateInfoNV(
+    const VkRayTracingShaderGroupCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      type(in_struct->type),
+      generalShader(in_struct->generalShader),
+      closestHitShader(in_struct->closestHitShader),
+      anyHitShader(in_struct->anyHitShader),
+      intersectionShader(in_struct->intersectionShader) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkRayTracingShaderGroupCreateInfoNV::safe_VkRayTracingShaderGroupCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV),
+      pNext(nullptr),
+      type(),
+      generalShader(),
+      closestHitShader(),
+      anyHitShader(),
+      intersectionShader() {}
+
+safe_VkRayTracingShaderGroupCreateInfoNV::safe_VkRayTracingShaderGroupCreateInfoNV(
+    const safe_VkRayTracingShaderGroupCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    type = copy_src.type;
+    generalShader = copy_src.generalShader;
+    closestHitShader = copy_src.closestHitShader;
+    anyHitShader = copy_src.anyHitShader;
+    intersectionShader = copy_src.intersectionShader;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkRayTracingShaderGroupCreateInfoNV& safe_VkRayTracingShaderGroupCreateInfoNV::operator=(
+    const safe_VkRayTracingShaderGroupCreateInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    type = copy_src.type;
+    generalShader = copy_src.generalShader;
+    closestHitShader = copy_src.closestHitShader;
+    anyHitShader = copy_src.anyHitShader;
+    intersectionShader = copy_src.intersectionShader;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkRayTracingShaderGroupCreateInfoNV::~safe_VkRayTracingShaderGroupCreateInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkRayTracingShaderGroupCreateInfoNV::initialize(const VkRayTracingShaderGroupCreateInfoNV* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    type = in_struct->type;
+    generalShader = in_struct->generalShader;
+    closestHitShader = in_struct->closestHitShader;
+    anyHitShader = in_struct->anyHitShader;
+    intersectionShader = in_struct->intersectionShader;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkRayTracingShaderGroupCreateInfoNV::initialize(const safe_VkRayTracingShaderGroupCreateInfoNV* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    type = copy_src->type;
+    generalShader = copy_src->generalShader;
+    closestHitShader = copy_src->closestHitShader;
+    anyHitShader = copy_src->anyHitShader;
+    intersectionShader = copy_src->intersectionShader;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkRayTracingPipelineCreateInfoNV::safe_VkRayTracingPipelineCreateInfoNV(const VkRayTracingPipelineCreateInfoNV* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      stageCount(in_struct->stageCount),
+      pStages(nullptr),
+      groupCount(in_struct->groupCount),
+      pGroups(nullptr),
+      maxRecursionDepth(in_struct->maxRecursionDepth),
+      layout(in_struct->layout),
+      basePipelineHandle(in_struct->basePipelineHandle),
+      basePipelineIndex(in_struct->basePipelineIndex) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (stageCount && in_struct->pStages) {
+        pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&in_struct->pStages[i]);
+        }
+    }
+    if (groupCount && in_struct->pGroups) {
+        pGroups = new safe_VkRayTracingShaderGroupCreateInfoNV[groupCount];
+        for (uint32_t i = 0; i < groupCount; ++i) {
+            pGroups[i].initialize(&in_struct->pGroups[i]);
+        }
+    }
+}
+
+safe_VkRayTracingPipelineCreateInfoNV::safe_VkRayTracingPipelineCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV),
+      pNext(nullptr),
+      flags(),
+      stageCount(),
+      pStages(nullptr),
+      groupCount(),
+      pGroups(nullptr),
+      maxRecursionDepth(),
+      layout(),
+      basePipelineHandle(),
+      basePipelineIndex() {}
+
+safe_VkRayTracingPipelineCreateInfoNV::safe_VkRayTracingPipelineCreateInfoNV(
+    const safe_VkRayTracingPipelineCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    stageCount = copy_src.stageCount;
+    pStages = nullptr;
+    groupCount = copy_src.groupCount;
+    pGroups = nullptr;
+    maxRecursionDepth = copy_src.maxRecursionDepth;
+    layout = copy_src.layout;
+    basePipelineHandle = copy_src.basePipelineHandle;
+    basePipelineIndex = copy_src.basePipelineIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (stageCount && copy_src.pStages) {
+        pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&copy_src.pStages[i]);
+        }
+    }
+    if (groupCount && copy_src.pGroups) {
+        pGroups = new safe_VkRayTracingShaderGroupCreateInfoNV[groupCount];
+        for (uint32_t i = 0; i < groupCount; ++i) {
+            pGroups[i].initialize(&copy_src.pGroups[i]);
+        }
+    }
+}
+
+safe_VkRayTracingPipelineCreateInfoNV& safe_VkRayTracingPipelineCreateInfoNV::operator=(
+    const safe_VkRayTracingPipelineCreateInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pStages) delete[] pStages;
+    if (pGroups) delete[] pGroups;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    stageCount = copy_src.stageCount;
+    pStages = nullptr;
+    groupCount = copy_src.groupCount;
+    pGroups = nullptr;
+    maxRecursionDepth = copy_src.maxRecursionDepth;
+    layout = copy_src.layout;
+    basePipelineHandle = copy_src.basePipelineHandle;
+    basePipelineIndex = copy_src.basePipelineIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (stageCount && copy_src.pStages) {
+        pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&copy_src.pStages[i]);
+        }
+    }
+    if (groupCount && copy_src.pGroups) {
+        pGroups = new safe_VkRayTracingShaderGroupCreateInfoNV[groupCount];
+        for (uint32_t i = 0; i < groupCount; ++i) {
+            pGroups[i].initialize(&copy_src.pGroups[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkRayTracingPipelineCreateInfoNV::~safe_VkRayTracingPipelineCreateInfoNV() {
+    if (pStages) delete[] pStages;
+    if (pGroups) delete[] pGroups;
+    FreePnextChain(pNext);
+}
+
+void safe_VkRayTracingPipelineCreateInfoNV::initialize(const VkRayTracingPipelineCreateInfoNV* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pStages) delete[] pStages;
+    if (pGroups) delete[] pGroups;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    stageCount = in_struct->stageCount;
+    pStages = nullptr;
+    groupCount = in_struct->groupCount;
+    pGroups = nullptr;
+    maxRecursionDepth = in_struct->maxRecursionDepth;
+    layout = in_struct->layout;
+    basePipelineHandle = in_struct->basePipelineHandle;
+    basePipelineIndex = in_struct->basePipelineIndex;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (stageCount && in_struct->pStages) {
+        pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&in_struct->pStages[i]);
+        }
+    }
+    if (groupCount && in_struct->pGroups) {
+        pGroups = new safe_VkRayTracingShaderGroupCreateInfoNV[groupCount];
+        for (uint32_t i = 0; i < groupCount; ++i) {
+            pGroups[i].initialize(&in_struct->pGroups[i]);
+        }
+    }
+}
+
+void safe_VkRayTracingPipelineCreateInfoNV::initialize(const safe_VkRayTracingPipelineCreateInfoNV* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    stageCount = copy_src->stageCount;
+    pStages = nullptr;
+    groupCount = copy_src->groupCount;
+    pGroups = nullptr;
+    maxRecursionDepth = copy_src->maxRecursionDepth;
+    layout = copy_src->layout;
+    basePipelineHandle = copy_src->basePipelineHandle;
+    basePipelineIndex = copy_src->basePipelineIndex;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (stageCount && copy_src->pStages) {
+        pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&copy_src->pStages[i]);
+        }
+    }
+    if (groupCount && copy_src->pGroups) {
+        pGroups = new safe_VkRayTracingShaderGroupCreateInfoNV[groupCount];
+        for (uint32_t i = 0; i < groupCount; ++i) {
+            pGroups[i].initialize(&copy_src->pGroups[i]);
+        }
+    }
+}
+
+safe_VkGeometryTrianglesNV::safe_VkGeometryTrianglesNV(const VkGeometryTrianglesNV* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      vertexData(in_struct->vertexData),
+      vertexOffset(in_struct->vertexOffset),
+      vertexCount(in_struct->vertexCount),
+      vertexStride(in_struct->vertexStride),
+      vertexFormat(in_struct->vertexFormat),
+      indexData(in_struct->indexData),
+      indexOffset(in_struct->indexOffset),
+      indexCount(in_struct->indexCount),
+      indexType(in_struct->indexType),
+      transformData(in_struct->transformData),
+      transformOffset(in_struct->transformOffset) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkGeometryTrianglesNV::safe_VkGeometryTrianglesNV()
+    : sType(VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV),
+      pNext(nullptr),
+      vertexData(),
+      vertexOffset(),
+      vertexCount(),
+      vertexStride(),
+      vertexFormat(),
+      indexData(),
+      indexOffset(),
+      indexCount(),
+      indexType(),
+      transformData(),
+      transformOffset() {}
+
+safe_VkGeometryTrianglesNV::safe_VkGeometryTrianglesNV(const safe_VkGeometryTrianglesNV& copy_src) {
+    sType = copy_src.sType;
+    vertexData = copy_src.vertexData;
+    vertexOffset = copy_src.vertexOffset;
+    vertexCount = copy_src.vertexCount;
+    vertexStride = copy_src.vertexStride;
+    vertexFormat = copy_src.vertexFormat;
+    indexData = copy_src.indexData;
+    indexOffset = copy_src.indexOffset;
+    indexCount = copy_src.indexCount;
+    indexType = copy_src.indexType;
+    transformData = copy_src.transformData;
+    transformOffset = copy_src.transformOffset;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkGeometryTrianglesNV& safe_VkGeometryTrianglesNV::operator=(const safe_VkGeometryTrianglesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    vertexData = copy_src.vertexData;
+    vertexOffset = copy_src.vertexOffset;
+    vertexCount = copy_src.vertexCount;
+    vertexStride = copy_src.vertexStride;
+    vertexFormat = copy_src.vertexFormat;
+    indexData = copy_src.indexData;
+    indexOffset = copy_src.indexOffset;
+    indexCount = copy_src.indexCount;
+    indexType = copy_src.indexType;
+    transformData = copy_src.transformData;
+    transformOffset = copy_src.transformOffset;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkGeometryTrianglesNV::~safe_VkGeometryTrianglesNV() { FreePnextChain(pNext); }
+
+void safe_VkGeometryTrianglesNV::initialize(const VkGeometryTrianglesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    vertexData = in_struct->vertexData;
+    vertexOffset = in_struct->vertexOffset;
+    vertexCount = in_struct->vertexCount;
+    vertexStride = in_struct->vertexStride;
+    vertexFormat = in_struct->vertexFormat;
+    indexData = in_struct->indexData;
+    indexOffset = in_struct->indexOffset;
+    indexCount = in_struct->indexCount;
+    indexType = in_struct->indexType;
+    transformData = in_struct->transformData;
+    transformOffset = in_struct->transformOffset;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkGeometryTrianglesNV::initialize(const safe_VkGeometryTrianglesNV* copy_src,
+                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    vertexData = copy_src->vertexData;
+    vertexOffset = copy_src->vertexOffset;
+    vertexCount = copy_src->vertexCount;
+    vertexStride = copy_src->vertexStride;
+    vertexFormat = copy_src->vertexFormat;
+    indexData = copy_src->indexData;
+    indexOffset = copy_src->indexOffset;
+    indexCount = copy_src->indexCount;
+    indexType = copy_src->indexType;
+    transformData = copy_src->transformData;
+    transformOffset = copy_src->transformOffset;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkGeometryAABBNV::safe_VkGeometryAABBNV(const VkGeometryAABBNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                             bool copy_pnext)
+    : sType(in_struct->sType),
+      aabbData(in_struct->aabbData),
+      numAABBs(in_struct->numAABBs),
+      stride(in_struct->stride),
+      offset(in_struct->offset) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkGeometryAABBNV::safe_VkGeometryAABBNV()
+    : sType(VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV), pNext(nullptr), aabbData(), numAABBs(), stride(), offset() {}
+
+safe_VkGeometryAABBNV::safe_VkGeometryAABBNV(const safe_VkGeometryAABBNV& copy_src) {
+    sType = copy_src.sType;
+    aabbData = copy_src.aabbData;
+    numAABBs = copy_src.numAABBs;
+    stride = copy_src.stride;
+    offset = copy_src.offset;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkGeometryAABBNV& safe_VkGeometryAABBNV::operator=(const safe_VkGeometryAABBNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    aabbData = copy_src.aabbData;
+    numAABBs = copy_src.numAABBs;
+    stride = copy_src.stride;
+    offset = copy_src.offset;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkGeometryAABBNV::~safe_VkGeometryAABBNV() { FreePnextChain(pNext); }
+
+void safe_VkGeometryAABBNV::initialize(const VkGeometryAABBNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    aabbData = in_struct->aabbData;
+    numAABBs = in_struct->numAABBs;
+    stride = in_struct->stride;
+    offset = in_struct->offset;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkGeometryAABBNV::initialize(const safe_VkGeometryAABBNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    aabbData = copy_src->aabbData;
+    numAABBs = copy_src->numAABBs;
+    stride = copy_src->stride;
+    offset = copy_src->offset;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkGeometryNV::safe_VkGeometryNV(const VkGeometryNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), geometryType(in_struct->geometryType), geometry(in_struct->geometry), flags(in_struct->flags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkGeometryNV::safe_VkGeometryNV()
+    : sType(VK_STRUCTURE_TYPE_GEOMETRY_NV), pNext(nullptr), geometryType(), geometry(), flags() {}
+
+safe_VkGeometryNV::safe_VkGeometryNV(const safe_VkGeometryNV& copy_src) {
+    sType = copy_src.sType;
+    geometryType = copy_src.geometryType;
+    geometry = copy_src.geometry;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkGeometryNV& safe_VkGeometryNV::operator=(const safe_VkGeometryNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    geometryType = copy_src.geometryType;
+    geometry = copy_src.geometry;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkGeometryNV::~safe_VkGeometryNV() { FreePnextChain(pNext); }
+
+void safe_VkGeometryNV::initialize(const VkGeometryNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    geometryType = in_struct->geometryType;
+    geometry = in_struct->geometry;
+    flags = in_struct->flags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkGeometryNV::initialize(const safe_VkGeometryNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    geometryType = copy_src->geometryType;
+    geometry = copy_src->geometry;
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkAccelerationStructureInfoNV::safe_VkAccelerationStructureInfoNV(const VkAccelerationStructureInfoNV* in_struct,
+                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      type(in_struct->type),
+      flags(in_struct->flags),
+      instanceCount(in_struct->instanceCount),
+      geometryCount(in_struct->geometryCount),
+      pGeometries(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (geometryCount && in_struct->pGeometries) {
+        pGeometries = new safe_VkGeometryNV[geometryCount];
+        for (uint32_t i = 0; i < geometryCount; ++i) {
+            pGeometries[i].initialize(&in_struct->pGeometries[i]);
+        }
+    }
+}
+
+safe_VkAccelerationStructureInfoNV::safe_VkAccelerationStructureInfoNV()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV),
+      pNext(nullptr),
+      type(),
+      flags(),
+      instanceCount(),
+      geometryCount(),
+      pGeometries(nullptr) {}
+
+safe_VkAccelerationStructureInfoNV::safe_VkAccelerationStructureInfoNV(const safe_VkAccelerationStructureInfoNV& copy_src) {
+    sType = copy_src.sType;
+    type = copy_src.type;
+    flags = copy_src.flags;
+    instanceCount = copy_src.instanceCount;
+    geometryCount = copy_src.geometryCount;
+    pGeometries = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (geometryCount && copy_src.pGeometries) {
+        pGeometries = new safe_VkGeometryNV[geometryCount];
+        for (uint32_t i = 0; i < geometryCount; ++i) {
+            pGeometries[i].initialize(&copy_src.pGeometries[i]);
+        }
+    }
+}
+
+safe_VkAccelerationStructureInfoNV& safe_VkAccelerationStructureInfoNV::operator=(
+    const safe_VkAccelerationStructureInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pGeometries) delete[] pGeometries;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    type = copy_src.type;
+    flags = copy_src.flags;
+    instanceCount = copy_src.instanceCount;
+    geometryCount = copy_src.geometryCount;
+    pGeometries = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (geometryCount && copy_src.pGeometries) {
+        pGeometries = new safe_VkGeometryNV[geometryCount];
+        for (uint32_t i = 0; i < geometryCount; ++i) {
+            pGeometries[i].initialize(&copy_src.pGeometries[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkAccelerationStructureInfoNV::~safe_VkAccelerationStructureInfoNV() {
+    if (pGeometries) delete[] pGeometries;
+    FreePnextChain(pNext);
+}
+
+void safe_VkAccelerationStructureInfoNV::initialize(const VkAccelerationStructureInfoNV* in_struct,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pGeometries) delete[] pGeometries;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    type = in_struct->type;
+    flags = in_struct->flags;
+    instanceCount = in_struct->instanceCount;
+    geometryCount = in_struct->geometryCount;
+    pGeometries = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (geometryCount && in_struct->pGeometries) {
+        pGeometries = new safe_VkGeometryNV[geometryCount];
+        for (uint32_t i = 0; i < geometryCount; ++i) {
+            pGeometries[i].initialize(&in_struct->pGeometries[i]);
+        }
+    }
+}
+
+void safe_VkAccelerationStructureInfoNV::initialize(const safe_VkAccelerationStructureInfoNV* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    type = copy_src->type;
+    flags = copy_src->flags;
+    instanceCount = copy_src->instanceCount;
+    geometryCount = copy_src->geometryCount;
+    pGeometries = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (geometryCount && copy_src->pGeometries) {
+        pGeometries = new safe_VkGeometryNV[geometryCount];
+        for (uint32_t i = 0; i < geometryCount; ++i) {
+            pGeometries[i].initialize(&copy_src->pGeometries[i]);
+        }
+    }
+}
+
+safe_VkAccelerationStructureCreateInfoNV::safe_VkAccelerationStructureCreateInfoNV(
+    const VkAccelerationStructureCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), compactedSize(in_struct->compactedSize), info(&in_struct->info) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkAccelerationStructureCreateInfoNV::safe_VkAccelerationStructureCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV), pNext(nullptr), compactedSize() {}
+
+safe_VkAccelerationStructureCreateInfoNV::safe_VkAccelerationStructureCreateInfoNV(
+    const safe_VkAccelerationStructureCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    compactedSize = copy_src.compactedSize;
+    info.initialize(&copy_src.info);
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkAccelerationStructureCreateInfoNV& safe_VkAccelerationStructureCreateInfoNV::operator=(
+    const safe_VkAccelerationStructureCreateInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    compactedSize = copy_src.compactedSize;
+    info.initialize(&copy_src.info);
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkAccelerationStructureCreateInfoNV::~safe_VkAccelerationStructureCreateInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkAccelerationStructureCreateInfoNV::initialize(const VkAccelerationStructureCreateInfoNV* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    compactedSize = in_struct->compactedSize;
+    info.initialize(&in_struct->info);
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkAccelerationStructureCreateInfoNV::initialize(const safe_VkAccelerationStructureCreateInfoNV* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    compactedSize = copy_src->compactedSize;
+    info.initialize(&copy_src->info);
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkBindAccelerationStructureMemoryInfoNV::safe_VkBindAccelerationStructureMemoryInfoNV(
+    const VkBindAccelerationStructureMemoryInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      accelerationStructure(in_struct->accelerationStructure),
+      memory(in_struct->memory),
+      memoryOffset(in_struct->memoryOffset),
+      deviceIndexCount(in_struct->deviceIndexCount),
+      pDeviceIndices(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pDeviceIndices) {
+        pDeviceIndices = new uint32_t[in_struct->deviceIndexCount];
+        memcpy((void*)pDeviceIndices, (void*)in_struct->pDeviceIndices, sizeof(uint32_t) * in_struct->deviceIndexCount);
+    }
+}
+
+safe_VkBindAccelerationStructureMemoryInfoNV::safe_VkBindAccelerationStructureMemoryInfoNV()
+    : sType(VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV),
+      pNext(nullptr),
+      accelerationStructure(),
+      memory(),
+      memoryOffset(),
+      deviceIndexCount(),
+      pDeviceIndices(nullptr) {}
+
+safe_VkBindAccelerationStructureMemoryInfoNV::safe_VkBindAccelerationStructureMemoryInfoNV(
+    const safe_VkBindAccelerationStructureMemoryInfoNV& copy_src) {
+    sType = copy_src.sType;
+    accelerationStructure = copy_src.accelerationStructure;
+    memory = copy_src.memory;
+    memoryOffset = copy_src.memoryOffset;
+    deviceIndexCount = copy_src.deviceIndexCount;
+    pDeviceIndices = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDeviceIndices) {
+        pDeviceIndices = new uint32_t[copy_src.deviceIndexCount];
+        memcpy((void*)pDeviceIndices, (void*)copy_src.pDeviceIndices, sizeof(uint32_t) * copy_src.deviceIndexCount);
+    }
+}
+
+safe_VkBindAccelerationStructureMemoryInfoNV& safe_VkBindAccelerationStructureMemoryInfoNV::operator=(
+    const safe_VkBindAccelerationStructureMemoryInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pDeviceIndices) delete[] pDeviceIndices;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    accelerationStructure = copy_src.accelerationStructure;
+    memory = copy_src.memory;
+    memoryOffset = copy_src.memoryOffset;
+    deviceIndexCount = copy_src.deviceIndexCount;
+    pDeviceIndices = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDeviceIndices) {
+        pDeviceIndices = new uint32_t[copy_src.deviceIndexCount];
+        memcpy((void*)pDeviceIndices, (void*)copy_src.pDeviceIndices, sizeof(uint32_t) * copy_src.deviceIndexCount);
+    }
+
+    return *this;
+}
+
+safe_VkBindAccelerationStructureMemoryInfoNV::~safe_VkBindAccelerationStructureMemoryInfoNV() {
+    if (pDeviceIndices) delete[] pDeviceIndices;
+    FreePnextChain(pNext);
+}
+
+void safe_VkBindAccelerationStructureMemoryInfoNV::initialize(const VkBindAccelerationStructureMemoryInfoNV* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pDeviceIndices) delete[] pDeviceIndices;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    accelerationStructure = in_struct->accelerationStructure;
+    memory = in_struct->memory;
+    memoryOffset = in_struct->memoryOffset;
+    deviceIndexCount = in_struct->deviceIndexCount;
+    pDeviceIndices = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pDeviceIndices) {
+        pDeviceIndices = new uint32_t[in_struct->deviceIndexCount];
+        memcpy((void*)pDeviceIndices, (void*)in_struct->pDeviceIndices, sizeof(uint32_t) * in_struct->deviceIndexCount);
+    }
+}
+
+void safe_VkBindAccelerationStructureMemoryInfoNV::initialize(const safe_VkBindAccelerationStructureMemoryInfoNV* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    accelerationStructure = copy_src->accelerationStructure;
+    memory = copy_src->memory;
+    memoryOffset = copy_src->memoryOffset;
+    deviceIndexCount = copy_src->deviceIndexCount;
+    pDeviceIndices = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pDeviceIndices) {
+        pDeviceIndices = new uint32_t[copy_src->deviceIndexCount];
+        memcpy((void*)pDeviceIndices, (void*)copy_src->pDeviceIndices, sizeof(uint32_t) * copy_src->deviceIndexCount);
+    }
+}
+
+safe_VkWriteDescriptorSetAccelerationStructureNV::safe_VkWriteDescriptorSetAccelerationStructureNV(
+    const VkWriteDescriptorSetAccelerationStructureNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), accelerationStructureCount(in_struct->accelerationStructureCount), pAccelerationStructures(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (accelerationStructureCount && in_struct->pAccelerationStructures) {
+        pAccelerationStructures = new VkAccelerationStructureNV[accelerationStructureCount];
+        for (uint32_t i = 0; i < accelerationStructureCount; ++i) {
+            pAccelerationStructures[i] = in_struct->pAccelerationStructures[i];
+        }
+    }
+}
+
+safe_VkWriteDescriptorSetAccelerationStructureNV::safe_VkWriteDescriptorSetAccelerationStructureNV()
+    : sType(VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV),
+      pNext(nullptr),
+      accelerationStructureCount(),
+      pAccelerationStructures(nullptr) {}
+
+safe_VkWriteDescriptorSetAccelerationStructureNV::safe_VkWriteDescriptorSetAccelerationStructureNV(
+    const safe_VkWriteDescriptorSetAccelerationStructureNV& copy_src) {
+    sType = copy_src.sType;
+    accelerationStructureCount = copy_src.accelerationStructureCount;
+    pAccelerationStructures = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (accelerationStructureCount && copy_src.pAccelerationStructures) {
+        pAccelerationStructures = new VkAccelerationStructureNV[accelerationStructureCount];
+        for (uint32_t i = 0; i < accelerationStructureCount; ++i) {
+            pAccelerationStructures[i] = copy_src.pAccelerationStructures[i];
+        }
+    }
+}
+
+safe_VkWriteDescriptorSetAccelerationStructureNV& safe_VkWriteDescriptorSetAccelerationStructureNV::operator=(
+    const safe_VkWriteDescriptorSetAccelerationStructureNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pAccelerationStructures) delete[] pAccelerationStructures;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    accelerationStructureCount = copy_src.accelerationStructureCount;
+    pAccelerationStructures = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (accelerationStructureCount && copy_src.pAccelerationStructures) {
+        pAccelerationStructures = new VkAccelerationStructureNV[accelerationStructureCount];
+        for (uint32_t i = 0; i < accelerationStructureCount; ++i) {
+            pAccelerationStructures[i] = copy_src.pAccelerationStructures[i];
+        }
+    }
+
+    return *this;
+}
+
+safe_VkWriteDescriptorSetAccelerationStructureNV::~safe_VkWriteDescriptorSetAccelerationStructureNV() {
+    if (pAccelerationStructures) delete[] pAccelerationStructures;
+    FreePnextChain(pNext);
+}
+
+void safe_VkWriteDescriptorSetAccelerationStructureNV::initialize(const VkWriteDescriptorSetAccelerationStructureNV* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pAccelerationStructures) delete[] pAccelerationStructures;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    accelerationStructureCount = in_struct->accelerationStructureCount;
+    pAccelerationStructures = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (accelerationStructureCount && in_struct->pAccelerationStructures) {
+        pAccelerationStructures = new VkAccelerationStructureNV[accelerationStructureCount];
+        for (uint32_t i = 0; i < accelerationStructureCount; ++i) {
+            pAccelerationStructures[i] = in_struct->pAccelerationStructures[i];
+        }
+    }
+}
+
+void safe_VkWriteDescriptorSetAccelerationStructureNV::initialize(const safe_VkWriteDescriptorSetAccelerationStructureNV* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    accelerationStructureCount = copy_src->accelerationStructureCount;
+    pAccelerationStructures = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (accelerationStructureCount && copy_src->pAccelerationStructures) {
+        pAccelerationStructures = new VkAccelerationStructureNV[accelerationStructureCount];
+        for (uint32_t i = 0; i < accelerationStructureCount; ++i) {
+            pAccelerationStructures[i] = copy_src->pAccelerationStructures[i];
+        }
+    }
+}
+
+safe_VkAccelerationStructureMemoryRequirementsInfoNV::safe_VkAccelerationStructureMemoryRequirementsInfoNV(
+    const VkAccelerationStructureMemoryRequirementsInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), type(in_struct->type), accelerationStructure(in_struct->accelerationStructure) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkAccelerationStructureMemoryRequirementsInfoNV::safe_VkAccelerationStructureMemoryRequirementsInfoNV()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV),
+      pNext(nullptr),
+      type(),
+      accelerationStructure() {}
+
+safe_VkAccelerationStructureMemoryRequirementsInfoNV::safe_VkAccelerationStructureMemoryRequirementsInfoNV(
+    const safe_VkAccelerationStructureMemoryRequirementsInfoNV& copy_src) {
+    sType = copy_src.sType;
+    type = copy_src.type;
+    accelerationStructure = copy_src.accelerationStructure;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkAccelerationStructureMemoryRequirementsInfoNV& safe_VkAccelerationStructureMemoryRequirementsInfoNV::operator=(
+    const safe_VkAccelerationStructureMemoryRequirementsInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    type = copy_src.type;
+    accelerationStructure = copy_src.accelerationStructure;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkAccelerationStructureMemoryRequirementsInfoNV::~safe_VkAccelerationStructureMemoryRequirementsInfoNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkAccelerationStructureMemoryRequirementsInfoNV::initialize(
+    const VkAccelerationStructureMemoryRequirementsInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    type = in_struct->type;
+    accelerationStructure = in_struct->accelerationStructure;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkAccelerationStructureMemoryRequirementsInfoNV::initialize(
+    const safe_VkAccelerationStructureMemoryRequirementsInfoNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    type = copy_src->type;
+    accelerationStructure = copy_src->accelerationStructure;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceRayTracingPropertiesNV::safe_VkPhysicalDeviceRayTracingPropertiesNV(
+    const VkPhysicalDeviceRayTracingPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      shaderGroupHandleSize(in_struct->shaderGroupHandleSize),
+      maxRecursionDepth(in_struct->maxRecursionDepth),
+      maxShaderGroupStride(in_struct->maxShaderGroupStride),
+      shaderGroupBaseAlignment(in_struct->shaderGroupBaseAlignment),
+      maxGeometryCount(in_struct->maxGeometryCount),
+      maxInstanceCount(in_struct->maxInstanceCount),
+      maxTriangleCount(in_struct->maxTriangleCount),
+      maxDescriptorSetAccelerationStructures(in_struct->maxDescriptorSetAccelerationStructures) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceRayTracingPropertiesNV::safe_VkPhysicalDeviceRayTracingPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV),
+      pNext(nullptr),
+      shaderGroupHandleSize(),
+      maxRecursionDepth(),
+      maxShaderGroupStride(),
+      shaderGroupBaseAlignment(),
+      maxGeometryCount(),
+      maxInstanceCount(),
+      maxTriangleCount(),
+      maxDescriptorSetAccelerationStructures() {}
+
+safe_VkPhysicalDeviceRayTracingPropertiesNV::safe_VkPhysicalDeviceRayTracingPropertiesNV(
+    const safe_VkPhysicalDeviceRayTracingPropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    shaderGroupHandleSize = copy_src.shaderGroupHandleSize;
+    maxRecursionDepth = copy_src.maxRecursionDepth;
+    maxShaderGroupStride = copy_src.maxShaderGroupStride;
+    shaderGroupBaseAlignment = copy_src.shaderGroupBaseAlignment;
+    maxGeometryCount = copy_src.maxGeometryCount;
+    maxInstanceCount = copy_src.maxInstanceCount;
+    maxTriangleCount = copy_src.maxTriangleCount;
+    maxDescriptorSetAccelerationStructures = copy_src.maxDescriptorSetAccelerationStructures;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceRayTracingPropertiesNV& safe_VkPhysicalDeviceRayTracingPropertiesNV::operator=(
+    const safe_VkPhysicalDeviceRayTracingPropertiesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderGroupHandleSize = copy_src.shaderGroupHandleSize;
+    maxRecursionDepth = copy_src.maxRecursionDepth;
+    maxShaderGroupStride = copy_src.maxShaderGroupStride;
+    shaderGroupBaseAlignment = copy_src.shaderGroupBaseAlignment;
+    maxGeometryCount = copy_src.maxGeometryCount;
+    maxInstanceCount = copy_src.maxInstanceCount;
+    maxTriangleCount = copy_src.maxTriangleCount;
+    maxDescriptorSetAccelerationStructures = copy_src.maxDescriptorSetAccelerationStructures;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceRayTracingPropertiesNV::~safe_VkPhysicalDeviceRayTracingPropertiesNV() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceRayTracingPropertiesNV::initialize(const VkPhysicalDeviceRayTracingPropertiesNV* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderGroupHandleSize = in_struct->shaderGroupHandleSize;
+    maxRecursionDepth = in_struct->maxRecursionDepth;
+    maxShaderGroupStride = in_struct->maxShaderGroupStride;
+    shaderGroupBaseAlignment = in_struct->shaderGroupBaseAlignment;
+    maxGeometryCount = in_struct->maxGeometryCount;
+    maxInstanceCount = in_struct->maxInstanceCount;
+    maxTriangleCount = in_struct->maxTriangleCount;
+    maxDescriptorSetAccelerationStructures = in_struct->maxDescriptorSetAccelerationStructures;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceRayTracingPropertiesNV::initialize(const safe_VkPhysicalDeviceRayTracingPropertiesNV* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderGroupHandleSize = copy_src->shaderGroupHandleSize;
+    maxRecursionDepth = copy_src->maxRecursionDepth;
+    maxShaderGroupStride = copy_src->maxShaderGroupStride;
+    shaderGroupBaseAlignment = copy_src->shaderGroupBaseAlignment;
+    maxGeometryCount = copy_src->maxGeometryCount;
+    maxInstanceCount = copy_src->maxInstanceCount;
+    maxTriangleCount = copy_src->maxTriangleCount;
+    maxDescriptorSetAccelerationStructures = copy_src->maxDescriptorSetAccelerationStructures;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
+    const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), representativeFragmentTest(in_struct->representativeFragmentTest) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV),
+      pNext(nullptr),
+      representativeFragmentTest() {}
+
+safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
+    const safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    representativeFragmentTest = copy_src.representativeFragmentTest;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    representativeFragmentTest = copy_src.representativeFragmentTest;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::~safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::initialize(
+    const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    representativeFragmentTest = in_struct->representativeFragmentTest;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::initialize(
+    const safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    representativeFragmentTest = copy_src->representativeFragmentTest;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV::safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
+    const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), representativeFragmentTestEnable(in_struct->representativeFragmentTestEnable) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV::safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV),
+      pNext(nullptr),
+      representativeFragmentTestEnable() {}
+
+safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV::safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
+    const safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    representativeFragmentTestEnable = copy_src.representativeFragmentTestEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV& safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV::operator=(
+    const safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    representativeFragmentTestEnable = copy_src.representativeFragmentTestEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV::~safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV::initialize(
+    const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    representativeFragmentTestEnable = in_struct->representativeFragmentTestEnable;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV::initialize(
+    const safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    representativeFragmentTestEnable = copy_src->representativeFragmentTestEnable;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineCompilerControlCreateInfoAMD::safe_VkPipelineCompilerControlCreateInfoAMD(
+    const VkPipelineCompilerControlCreateInfoAMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), compilerControlFlags(in_struct->compilerControlFlags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPipelineCompilerControlCreateInfoAMD::safe_VkPipelineCompilerControlCreateInfoAMD()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD), pNext(nullptr), compilerControlFlags() {}
+
+safe_VkPipelineCompilerControlCreateInfoAMD::safe_VkPipelineCompilerControlCreateInfoAMD(
+    const safe_VkPipelineCompilerControlCreateInfoAMD& copy_src) {
+    sType = copy_src.sType;
+    compilerControlFlags = copy_src.compilerControlFlags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPipelineCompilerControlCreateInfoAMD& safe_VkPipelineCompilerControlCreateInfoAMD::operator=(
+    const safe_VkPipelineCompilerControlCreateInfoAMD& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    compilerControlFlags = copy_src.compilerControlFlags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineCompilerControlCreateInfoAMD::~safe_VkPipelineCompilerControlCreateInfoAMD() { FreePnextChain(pNext); }
+
+void safe_VkPipelineCompilerControlCreateInfoAMD::initialize(const VkPipelineCompilerControlCreateInfoAMD* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    compilerControlFlags = in_struct->compilerControlFlags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPipelineCompilerControlCreateInfoAMD::initialize(const safe_VkPipelineCompilerControlCreateInfoAMD* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    compilerControlFlags = copy_src->compilerControlFlags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceShaderCorePropertiesAMD::safe_VkPhysicalDeviceShaderCorePropertiesAMD(
+    const VkPhysicalDeviceShaderCorePropertiesAMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      shaderEngineCount(in_struct->shaderEngineCount),
+      shaderArraysPerEngineCount(in_struct->shaderArraysPerEngineCount),
+      computeUnitsPerShaderArray(in_struct->computeUnitsPerShaderArray),
+      simdPerComputeUnit(in_struct->simdPerComputeUnit),
+      wavefrontsPerSimd(in_struct->wavefrontsPerSimd),
+      wavefrontSize(in_struct->wavefrontSize),
+      sgprsPerSimd(in_struct->sgprsPerSimd),
+      minSgprAllocation(in_struct->minSgprAllocation),
+      maxSgprAllocation(in_struct->maxSgprAllocation),
+      sgprAllocationGranularity(in_struct->sgprAllocationGranularity),
+      vgprsPerSimd(in_struct->vgprsPerSimd),
+      minVgprAllocation(in_struct->minVgprAllocation),
+      maxVgprAllocation(in_struct->maxVgprAllocation),
+      vgprAllocationGranularity(in_struct->vgprAllocationGranularity) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderCorePropertiesAMD::safe_VkPhysicalDeviceShaderCorePropertiesAMD()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD),
+      pNext(nullptr),
+      shaderEngineCount(),
+      shaderArraysPerEngineCount(),
+      computeUnitsPerShaderArray(),
+      simdPerComputeUnit(),
+      wavefrontsPerSimd(),
+      wavefrontSize(),
+      sgprsPerSimd(),
+      minSgprAllocation(),
+      maxSgprAllocation(),
+      sgprAllocationGranularity(),
+      vgprsPerSimd(),
+      minVgprAllocation(),
+      maxVgprAllocation(),
+      vgprAllocationGranularity() {}
+
+safe_VkPhysicalDeviceShaderCorePropertiesAMD::safe_VkPhysicalDeviceShaderCorePropertiesAMD(
+    const safe_VkPhysicalDeviceShaderCorePropertiesAMD& copy_src) {
+    sType = copy_src.sType;
+    shaderEngineCount = copy_src.shaderEngineCount;
+    shaderArraysPerEngineCount = copy_src.shaderArraysPerEngineCount;
+    computeUnitsPerShaderArray = copy_src.computeUnitsPerShaderArray;
+    simdPerComputeUnit = copy_src.simdPerComputeUnit;
+    wavefrontsPerSimd = copy_src.wavefrontsPerSimd;
+    wavefrontSize = copy_src.wavefrontSize;
+    sgprsPerSimd = copy_src.sgprsPerSimd;
+    minSgprAllocation = copy_src.minSgprAllocation;
+    maxSgprAllocation = copy_src.maxSgprAllocation;
+    sgprAllocationGranularity = copy_src.sgprAllocationGranularity;
+    vgprsPerSimd = copy_src.vgprsPerSimd;
+    minVgprAllocation = copy_src.minVgprAllocation;
+    maxVgprAllocation = copy_src.maxVgprAllocation;
+    vgprAllocationGranularity = copy_src.vgprAllocationGranularity;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderCorePropertiesAMD& safe_VkPhysicalDeviceShaderCorePropertiesAMD::operator=(
+    const safe_VkPhysicalDeviceShaderCorePropertiesAMD& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderEngineCount = copy_src.shaderEngineCount;
+    shaderArraysPerEngineCount = copy_src.shaderArraysPerEngineCount;
+    computeUnitsPerShaderArray = copy_src.computeUnitsPerShaderArray;
+    simdPerComputeUnit = copy_src.simdPerComputeUnit;
+    wavefrontsPerSimd = copy_src.wavefrontsPerSimd;
+    wavefrontSize = copy_src.wavefrontSize;
+    sgprsPerSimd = copy_src.sgprsPerSimd;
+    minSgprAllocation = copy_src.minSgprAllocation;
+    maxSgprAllocation = copy_src.maxSgprAllocation;
+    sgprAllocationGranularity = copy_src.sgprAllocationGranularity;
+    vgprsPerSimd = copy_src.vgprsPerSimd;
+    minVgprAllocation = copy_src.minVgprAllocation;
+    maxVgprAllocation = copy_src.maxVgprAllocation;
+    vgprAllocationGranularity = copy_src.vgprAllocationGranularity;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderCorePropertiesAMD::~safe_VkPhysicalDeviceShaderCorePropertiesAMD() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceShaderCorePropertiesAMD::initialize(const VkPhysicalDeviceShaderCorePropertiesAMD* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderEngineCount = in_struct->shaderEngineCount;
+    shaderArraysPerEngineCount = in_struct->shaderArraysPerEngineCount;
+    computeUnitsPerShaderArray = in_struct->computeUnitsPerShaderArray;
+    simdPerComputeUnit = in_struct->simdPerComputeUnit;
+    wavefrontsPerSimd = in_struct->wavefrontsPerSimd;
+    wavefrontSize = in_struct->wavefrontSize;
+    sgprsPerSimd = in_struct->sgprsPerSimd;
+    minSgprAllocation = in_struct->minSgprAllocation;
+    maxSgprAllocation = in_struct->maxSgprAllocation;
+    sgprAllocationGranularity = in_struct->sgprAllocationGranularity;
+    vgprsPerSimd = in_struct->vgprsPerSimd;
+    minVgprAllocation = in_struct->minVgprAllocation;
+    maxVgprAllocation = in_struct->maxVgprAllocation;
+    vgprAllocationGranularity = in_struct->vgprAllocationGranularity;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderCorePropertiesAMD::initialize(const safe_VkPhysicalDeviceShaderCorePropertiesAMD* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderEngineCount = copy_src->shaderEngineCount;
+    shaderArraysPerEngineCount = copy_src->shaderArraysPerEngineCount;
+    computeUnitsPerShaderArray = copy_src->computeUnitsPerShaderArray;
+    simdPerComputeUnit = copy_src->simdPerComputeUnit;
+    wavefrontsPerSimd = copy_src->wavefrontsPerSimd;
+    wavefrontSize = copy_src->wavefrontSize;
+    sgprsPerSimd = copy_src->sgprsPerSimd;
+    minSgprAllocation = copy_src->minSgprAllocation;
+    maxSgprAllocation = copy_src->maxSgprAllocation;
+    sgprAllocationGranularity = copy_src->sgprAllocationGranularity;
+    vgprsPerSimd = copy_src->vgprsPerSimd;
+    minVgprAllocation = copy_src->minVgprAllocation;
+    maxVgprAllocation = copy_src->maxVgprAllocation;
+    vgprAllocationGranularity = copy_src->vgprAllocationGranularity;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDeviceMemoryOverallocationCreateInfoAMD::safe_VkDeviceMemoryOverallocationCreateInfoAMD(
+    const VkDeviceMemoryOverallocationCreateInfoAMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), overallocationBehavior(in_struct->overallocationBehavior) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDeviceMemoryOverallocationCreateInfoAMD::safe_VkDeviceMemoryOverallocationCreateInfoAMD()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD), pNext(nullptr), overallocationBehavior() {}
+
+safe_VkDeviceMemoryOverallocationCreateInfoAMD::safe_VkDeviceMemoryOverallocationCreateInfoAMD(
+    const safe_VkDeviceMemoryOverallocationCreateInfoAMD& copy_src) {
+    sType = copy_src.sType;
+    overallocationBehavior = copy_src.overallocationBehavior;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDeviceMemoryOverallocationCreateInfoAMD& safe_VkDeviceMemoryOverallocationCreateInfoAMD::operator=(
+    const safe_VkDeviceMemoryOverallocationCreateInfoAMD& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    overallocationBehavior = copy_src.overallocationBehavior;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDeviceMemoryOverallocationCreateInfoAMD::~safe_VkDeviceMemoryOverallocationCreateInfoAMD() { FreePnextChain(pNext); }
+
+void safe_VkDeviceMemoryOverallocationCreateInfoAMD::initialize(const VkDeviceMemoryOverallocationCreateInfoAMD* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    overallocationBehavior = in_struct->overallocationBehavior;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDeviceMemoryOverallocationCreateInfoAMD::initialize(const safe_VkDeviceMemoryOverallocationCreateInfoAMD* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    overallocationBehavior = copy_src->overallocationBehavior;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+#ifdef VK_USE_PLATFORM_GGP
+
+safe_VkPresentFrameTokenGGP::safe_VkPresentFrameTokenGGP(const VkPresentFrameTokenGGP* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), frameToken(in_struct->frameToken) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPresentFrameTokenGGP::safe_VkPresentFrameTokenGGP()
+    : sType(VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP), pNext(nullptr), frameToken() {}
+
+safe_VkPresentFrameTokenGGP::safe_VkPresentFrameTokenGGP(const safe_VkPresentFrameTokenGGP& copy_src) {
+    sType = copy_src.sType;
+    frameToken = copy_src.frameToken;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPresentFrameTokenGGP& safe_VkPresentFrameTokenGGP::operator=(const safe_VkPresentFrameTokenGGP& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    frameToken = copy_src.frameToken;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPresentFrameTokenGGP::~safe_VkPresentFrameTokenGGP() { FreePnextChain(pNext); }
+
+void safe_VkPresentFrameTokenGGP::initialize(const VkPresentFrameTokenGGP* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    frameToken = in_struct->frameToken;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPresentFrameTokenGGP::initialize(const safe_VkPresentFrameTokenGGP* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    frameToken = copy_src->frameToken;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+#endif  // VK_USE_PLATFORM_GGP
+
+safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
+    const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      computeDerivativeGroupQuads(in_struct->computeDerivativeGroupQuads),
+      computeDerivativeGroupLinear(in_struct->computeDerivativeGroupLinear) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV),
+      pNext(nullptr),
+      computeDerivativeGroupQuads(),
+      computeDerivativeGroupLinear() {}
+
+safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
+    const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    computeDerivativeGroupQuads = copy_src.computeDerivativeGroupQuads;
+    computeDerivativeGroupLinear = copy_src.computeDerivativeGroupLinear;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    computeDerivativeGroupQuads = copy_src.computeDerivativeGroupQuads;
+    computeDerivativeGroupLinear = copy_src.computeDerivativeGroupLinear;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::~safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::initialize(
+    const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    computeDerivativeGroupQuads = in_struct->computeDerivativeGroupQuads;
+    computeDerivativeGroupLinear = in_struct->computeDerivativeGroupLinear;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::initialize(
+    const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    computeDerivativeGroupQuads = copy_src->computeDerivativeGroupQuads;
+    computeDerivativeGroupLinear = copy_src->computeDerivativeGroupLinear;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceMeshShaderFeaturesNV::safe_VkPhysicalDeviceMeshShaderFeaturesNV(
+    const VkPhysicalDeviceMeshShaderFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), taskShader(in_struct->taskShader), meshShader(in_struct->meshShader) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMeshShaderFeaturesNV::safe_VkPhysicalDeviceMeshShaderFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV), pNext(nullptr), taskShader(), meshShader() {}
+
+safe_VkPhysicalDeviceMeshShaderFeaturesNV::safe_VkPhysicalDeviceMeshShaderFeaturesNV(
+    const safe_VkPhysicalDeviceMeshShaderFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    taskShader = copy_src.taskShader;
+    meshShader = copy_src.meshShader;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMeshShaderFeaturesNV& safe_VkPhysicalDeviceMeshShaderFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceMeshShaderFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    taskShader = copy_src.taskShader;
+    meshShader = copy_src.meshShader;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMeshShaderFeaturesNV::~safe_VkPhysicalDeviceMeshShaderFeaturesNV() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceMeshShaderFeaturesNV::initialize(const VkPhysicalDeviceMeshShaderFeaturesNV* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    taskShader = in_struct->taskShader;
+    meshShader = in_struct->meshShader;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMeshShaderFeaturesNV::initialize(const safe_VkPhysicalDeviceMeshShaderFeaturesNV* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    taskShader = copy_src->taskShader;
+    meshShader = copy_src->meshShader;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceMeshShaderPropertiesNV::safe_VkPhysicalDeviceMeshShaderPropertiesNV(
+    const VkPhysicalDeviceMeshShaderPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      maxDrawMeshTasksCount(in_struct->maxDrawMeshTasksCount),
+      maxTaskWorkGroupInvocations(in_struct->maxTaskWorkGroupInvocations),
+      maxTaskTotalMemorySize(in_struct->maxTaskTotalMemorySize),
+      maxTaskOutputCount(in_struct->maxTaskOutputCount),
+      maxMeshWorkGroupInvocations(in_struct->maxMeshWorkGroupInvocations),
+      maxMeshTotalMemorySize(in_struct->maxMeshTotalMemorySize),
+      maxMeshOutputVertices(in_struct->maxMeshOutputVertices),
+      maxMeshOutputPrimitives(in_struct->maxMeshOutputPrimitives),
+      maxMeshMultiviewViewCount(in_struct->maxMeshMultiviewViewCount),
+      meshOutputPerVertexGranularity(in_struct->meshOutputPerVertexGranularity),
+      meshOutputPerPrimitiveGranularity(in_struct->meshOutputPerPrimitiveGranularity) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxTaskWorkGroupSize[i] = in_struct->maxTaskWorkGroupSize[i];
+    }
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxMeshWorkGroupSize[i] = in_struct->maxMeshWorkGroupSize[i];
+    }
+}
+
+safe_VkPhysicalDeviceMeshShaderPropertiesNV::safe_VkPhysicalDeviceMeshShaderPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV),
+      pNext(nullptr),
+      maxDrawMeshTasksCount(),
+      maxTaskWorkGroupInvocations(),
+      maxTaskTotalMemorySize(),
+      maxTaskOutputCount(),
+      maxMeshWorkGroupInvocations(),
+      maxMeshTotalMemorySize(),
+      maxMeshOutputVertices(),
+      maxMeshOutputPrimitives(),
+      maxMeshMultiviewViewCount(),
+      meshOutputPerVertexGranularity(),
+      meshOutputPerPrimitiveGranularity() {}
+
+safe_VkPhysicalDeviceMeshShaderPropertiesNV::safe_VkPhysicalDeviceMeshShaderPropertiesNV(
+    const safe_VkPhysicalDeviceMeshShaderPropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    maxDrawMeshTasksCount = copy_src.maxDrawMeshTasksCount;
+    maxTaskWorkGroupInvocations = copy_src.maxTaskWorkGroupInvocations;
+    maxTaskTotalMemorySize = copy_src.maxTaskTotalMemorySize;
+    maxTaskOutputCount = copy_src.maxTaskOutputCount;
+    maxMeshWorkGroupInvocations = copy_src.maxMeshWorkGroupInvocations;
+    maxMeshTotalMemorySize = copy_src.maxMeshTotalMemorySize;
+    maxMeshOutputVertices = copy_src.maxMeshOutputVertices;
+    maxMeshOutputPrimitives = copy_src.maxMeshOutputPrimitives;
+    maxMeshMultiviewViewCount = copy_src.maxMeshMultiviewViewCount;
+    meshOutputPerVertexGranularity = copy_src.meshOutputPerVertexGranularity;
+    meshOutputPerPrimitiveGranularity = copy_src.meshOutputPerPrimitiveGranularity;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxTaskWorkGroupSize[i] = copy_src.maxTaskWorkGroupSize[i];
+    }
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxMeshWorkGroupSize[i] = copy_src.maxMeshWorkGroupSize[i];
+    }
+}
+
+safe_VkPhysicalDeviceMeshShaderPropertiesNV& safe_VkPhysicalDeviceMeshShaderPropertiesNV::operator=(
+    const safe_VkPhysicalDeviceMeshShaderPropertiesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxDrawMeshTasksCount = copy_src.maxDrawMeshTasksCount;
+    maxTaskWorkGroupInvocations = copy_src.maxTaskWorkGroupInvocations;
+    maxTaskTotalMemorySize = copy_src.maxTaskTotalMemorySize;
+    maxTaskOutputCount = copy_src.maxTaskOutputCount;
+    maxMeshWorkGroupInvocations = copy_src.maxMeshWorkGroupInvocations;
+    maxMeshTotalMemorySize = copy_src.maxMeshTotalMemorySize;
+    maxMeshOutputVertices = copy_src.maxMeshOutputVertices;
+    maxMeshOutputPrimitives = copy_src.maxMeshOutputPrimitives;
+    maxMeshMultiviewViewCount = copy_src.maxMeshMultiviewViewCount;
+    meshOutputPerVertexGranularity = copy_src.meshOutputPerVertexGranularity;
+    meshOutputPerPrimitiveGranularity = copy_src.meshOutputPerPrimitiveGranularity;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxTaskWorkGroupSize[i] = copy_src.maxTaskWorkGroupSize[i];
+    }
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxMeshWorkGroupSize[i] = copy_src.maxMeshWorkGroupSize[i];
+    }
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMeshShaderPropertiesNV::~safe_VkPhysicalDeviceMeshShaderPropertiesNV() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceMeshShaderPropertiesNV::initialize(const VkPhysicalDeviceMeshShaderPropertiesNV* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxDrawMeshTasksCount = in_struct->maxDrawMeshTasksCount;
+    maxTaskWorkGroupInvocations = in_struct->maxTaskWorkGroupInvocations;
+    maxTaskTotalMemorySize = in_struct->maxTaskTotalMemorySize;
+    maxTaskOutputCount = in_struct->maxTaskOutputCount;
+    maxMeshWorkGroupInvocations = in_struct->maxMeshWorkGroupInvocations;
+    maxMeshTotalMemorySize = in_struct->maxMeshTotalMemorySize;
+    maxMeshOutputVertices = in_struct->maxMeshOutputVertices;
+    maxMeshOutputPrimitives = in_struct->maxMeshOutputPrimitives;
+    maxMeshMultiviewViewCount = in_struct->maxMeshMultiviewViewCount;
+    meshOutputPerVertexGranularity = in_struct->meshOutputPerVertexGranularity;
+    meshOutputPerPrimitiveGranularity = in_struct->meshOutputPerPrimitiveGranularity;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxTaskWorkGroupSize[i] = in_struct->maxTaskWorkGroupSize[i];
+    }
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxMeshWorkGroupSize[i] = in_struct->maxMeshWorkGroupSize[i];
+    }
+}
+
+void safe_VkPhysicalDeviceMeshShaderPropertiesNV::initialize(const safe_VkPhysicalDeviceMeshShaderPropertiesNV* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxDrawMeshTasksCount = copy_src->maxDrawMeshTasksCount;
+    maxTaskWorkGroupInvocations = copy_src->maxTaskWorkGroupInvocations;
+    maxTaskTotalMemorySize = copy_src->maxTaskTotalMemorySize;
+    maxTaskOutputCount = copy_src->maxTaskOutputCount;
+    maxMeshWorkGroupInvocations = copy_src->maxMeshWorkGroupInvocations;
+    maxMeshTotalMemorySize = copy_src->maxMeshTotalMemorySize;
+    maxMeshOutputVertices = copy_src->maxMeshOutputVertices;
+    maxMeshOutputPrimitives = copy_src->maxMeshOutputPrimitives;
+    maxMeshMultiviewViewCount = copy_src->maxMeshMultiviewViewCount;
+    meshOutputPerVertexGranularity = copy_src->meshOutputPerVertexGranularity;
+    meshOutputPerPrimitiveGranularity = copy_src->meshOutputPerPrimitiveGranularity;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxTaskWorkGroupSize[i] = copy_src->maxTaskWorkGroupSize[i];
+    }
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxMeshWorkGroupSize[i] = copy_src->maxMeshWorkGroupSize[i];
+    }
+}
+
+safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV::safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
+    const VkPhysicalDeviceShaderImageFootprintFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), imageFootprint(in_struct->imageFootprint) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV::safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV), pNext(nullptr), imageFootprint() {}
+
+safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV::safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
+    const safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    imageFootprint = copy_src.imageFootprint;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV& safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    imageFootprint = copy_src.imageFootprint;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV::~safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV::initialize(
+    const VkPhysicalDeviceShaderImageFootprintFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    imageFootprint = in_struct->imageFootprint;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV::initialize(
+    const safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imageFootprint = copy_src->imageFootprint;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV::safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
+    const VkPipelineViewportExclusiveScissorStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), exclusiveScissorCount(in_struct->exclusiveScissorCount), pExclusiveScissors(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pExclusiveScissors) {
+        pExclusiveScissors = new VkRect2D[in_struct->exclusiveScissorCount];
+        memcpy((void*)pExclusiveScissors, (void*)in_struct->pExclusiveScissors,
+               sizeof(VkRect2D) * in_struct->exclusiveScissorCount);
+    }
+}
+
+safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV::safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV),
+      pNext(nullptr),
+      exclusiveScissorCount(),
+      pExclusiveScissors(nullptr) {}
+
+safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV::safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
+    const safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    exclusiveScissorCount = copy_src.exclusiveScissorCount;
+    pExclusiveScissors = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pExclusiveScissors) {
+        pExclusiveScissors = new VkRect2D[copy_src.exclusiveScissorCount];
+        memcpy((void*)pExclusiveScissors, (void*)copy_src.pExclusiveScissors, sizeof(VkRect2D) * copy_src.exclusiveScissorCount);
+    }
+}
+
+safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV& safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV::operator=(
+    const safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pExclusiveScissors) delete[] pExclusiveScissors;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    exclusiveScissorCount = copy_src.exclusiveScissorCount;
+    pExclusiveScissors = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pExclusiveScissors) {
+        pExclusiveScissors = new VkRect2D[copy_src.exclusiveScissorCount];
+        memcpy((void*)pExclusiveScissors, (void*)copy_src.pExclusiveScissors, sizeof(VkRect2D) * copy_src.exclusiveScissorCount);
+    }
+
+    return *this;
+}
+
+safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV::~safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV() {
+    if (pExclusiveScissors) delete[] pExclusiveScissors;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV::initialize(
+    const VkPipelineViewportExclusiveScissorStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pExclusiveScissors) delete[] pExclusiveScissors;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    exclusiveScissorCount = in_struct->exclusiveScissorCount;
+    pExclusiveScissors = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pExclusiveScissors) {
+        pExclusiveScissors = new VkRect2D[in_struct->exclusiveScissorCount];
+        memcpy((void*)pExclusiveScissors, (void*)in_struct->pExclusiveScissors,
+               sizeof(VkRect2D) * in_struct->exclusiveScissorCount);
+    }
+}
+
+void safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV::initialize(
+    const safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    exclusiveScissorCount = copy_src->exclusiveScissorCount;
+    pExclusiveScissors = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pExclusiveScissors) {
+        pExclusiveScissors = new VkRect2D[copy_src->exclusiveScissorCount];
+        memcpy((void*)pExclusiveScissors, (void*)copy_src->pExclusiveScissors, sizeof(VkRect2D) * copy_src->exclusiveScissorCount);
+    }
+}
+
+safe_VkPhysicalDeviceExclusiveScissorFeaturesNV::safe_VkPhysicalDeviceExclusiveScissorFeaturesNV(
+    const VkPhysicalDeviceExclusiveScissorFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), exclusiveScissor(in_struct->exclusiveScissor) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceExclusiveScissorFeaturesNV::safe_VkPhysicalDeviceExclusiveScissorFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV), pNext(nullptr), exclusiveScissor() {}
+
+safe_VkPhysicalDeviceExclusiveScissorFeaturesNV::safe_VkPhysicalDeviceExclusiveScissorFeaturesNV(
+    const safe_VkPhysicalDeviceExclusiveScissorFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    exclusiveScissor = copy_src.exclusiveScissor;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceExclusiveScissorFeaturesNV& safe_VkPhysicalDeviceExclusiveScissorFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceExclusiveScissorFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    exclusiveScissor = copy_src.exclusiveScissor;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceExclusiveScissorFeaturesNV::~safe_VkPhysicalDeviceExclusiveScissorFeaturesNV() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceExclusiveScissorFeaturesNV::initialize(const VkPhysicalDeviceExclusiveScissorFeaturesNV* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    exclusiveScissor = in_struct->exclusiveScissor;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceExclusiveScissorFeaturesNV::initialize(const safe_VkPhysicalDeviceExclusiveScissorFeaturesNV* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    exclusiveScissor = copy_src->exclusiveScissor;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkQueueFamilyCheckpointPropertiesNV::safe_VkQueueFamilyCheckpointPropertiesNV(
+    const VkQueueFamilyCheckpointPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), checkpointExecutionStageMask(in_struct->checkpointExecutionStageMask) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkQueueFamilyCheckpointPropertiesNV::safe_VkQueueFamilyCheckpointPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV), pNext(nullptr), checkpointExecutionStageMask() {}
+
+safe_VkQueueFamilyCheckpointPropertiesNV::safe_VkQueueFamilyCheckpointPropertiesNV(
+    const safe_VkQueueFamilyCheckpointPropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    checkpointExecutionStageMask = copy_src.checkpointExecutionStageMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkQueueFamilyCheckpointPropertiesNV& safe_VkQueueFamilyCheckpointPropertiesNV::operator=(
+    const safe_VkQueueFamilyCheckpointPropertiesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    checkpointExecutionStageMask = copy_src.checkpointExecutionStageMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkQueueFamilyCheckpointPropertiesNV::~safe_VkQueueFamilyCheckpointPropertiesNV() { FreePnextChain(pNext); }
+
+void safe_VkQueueFamilyCheckpointPropertiesNV::initialize(const VkQueueFamilyCheckpointPropertiesNV* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    checkpointExecutionStageMask = in_struct->checkpointExecutionStageMask;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkQueueFamilyCheckpointPropertiesNV::initialize(const safe_VkQueueFamilyCheckpointPropertiesNV* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    checkpointExecutionStageMask = copy_src->checkpointExecutionStageMask;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkCheckpointDataNV::safe_VkCheckpointDataNV(const VkCheckpointDataNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                                 bool copy_pnext)
+    : sType(in_struct->sType), stage(in_struct->stage), pCheckpointMarker(in_struct->pCheckpointMarker) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkCheckpointDataNV::safe_VkCheckpointDataNV()
+    : sType(VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV), pNext(nullptr), stage(), pCheckpointMarker(nullptr) {}
+
+safe_VkCheckpointDataNV::safe_VkCheckpointDataNV(const safe_VkCheckpointDataNV& copy_src) {
+    sType = copy_src.sType;
+    stage = copy_src.stage;
+    pCheckpointMarker = copy_src.pCheckpointMarker;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkCheckpointDataNV& safe_VkCheckpointDataNV::operator=(const safe_VkCheckpointDataNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    stage = copy_src.stage;
+    pCheckpointMarker = copy_src.pCheckpointMarker;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkCheckpointDataNV::~safe_VkCheckpointDataNV() { FreePnextChain(pNext); }
+
+void safe_VkCheckpointDataNV::initialize(const VkCheckpointDataNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    stage = in_struct->stage;
+    pCheckpointMarker = in_struct->pCheckpointMarker;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkCheckpointDataNV::initialize(const safe_VkCheckpointDataNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stage = copy_src->stage;
+    pCheckpointMarker = copy_src->pCheckpointMarker;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
+    const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), shaderIntegerFunctions2(in_struct->shaderIntegerFunctions2) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL),
+      pNext(nullptr),
+      shaderIntegerFunctions2() {}
+
+safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
+    const safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& copy_src) {
+    sType = copy_src.sType;
+    shaderIntegerFunctions2 = copy_src.shaderIntegerFunctions2;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::operator=(
+    const safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderIntegerFunctions2 = copy_src.shaderIntegerFunctions2;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::~safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::initialize(
+    const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderIntegerFunctions2 = in_struct->shaderIntegerFunctions2;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::initialize(
+    const safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderIntegerFunctions2 = copy_src->shaderIntegerFunctions2;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPerformanceValueDataINTEL::safe_VkPerformanceValueDataINTEL(const VkPerformanceValueDataINTEL* in_struct, PNextCopyState*) {
+    initialize(in_struct);
+}
+
+safe_VkPerformanceValueDataINTEL::safe_VkPerformanceValueDataINTEL() : valueString(nullptr) {}
+
+safe_VkPerformanceValueDataINTEL::safe_VkPerformanceValueDataINTEL(const safe_VkPerformanceValueDataINTEL& copy_src) {
+    value32 = copy_src.value32;
+    value64 = copy_src.value64;
+    valueFloat = copy_src.valueFloat;
+    valueBool = copy_src.valueBool;
+    valueString = SafeStringCopy(copy_src.valueString);
+}
+
+safe_VkPerformanceValueDataINTEL& safe_VkPerformanceValueDataINTEL::operator=(const safe_VkPerformanceValueDataINTEL& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (valueString) delete[] valueString;
+
+    value32 = copy_src.value32;
+    value64 = copy_src.value64;
+    valueFloat = copy_src.valueFloat;
+    valueBool = copy_src.valueBool;
+    valueString = SafeStringCopy(copy_src.valueString);
+
+    return *this;
+}
+
+safe_VkPerformanceValueDataINTEL::~safe_VkPerformanceValueDataINTEL() {
+    if (valueString) delete[] valueString;
+}
+
+void safe_VkPerformanceValueDataINTEL::initialize(const VkPerformanceValueDataINTEL* in_struct,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    if (valueString) delete[] valueString;
+    value32 = in_struct->value32;
+    value64 = in_struct->value64;
+    valueFloat = in_struct->valueFloat;
+    valueBool = in_struct->valueBool;
+    valueString = SafeStringCopy(in_struct->valueString);
+}
+
+void safe_VkPerformanceValueDataINTEL::initialize(const safe_VkPerformanceValueDataINTEL* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    value32 = copy_src->value32;
+    value64 = copy_src->value64;
+    valueFloat = copy_src->valueFloat;
+    valueBool = copy_src->valueBool;
+    valueString = SafeStringCopy(copy_src->valueString);
+}
+
+safe_VkInitializePerformanceApiInfoINTEL::safe_VkInitializePerformanceApiInfoINTEL(
+    const VkInitializePerformanceApiInfoINTEL* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), pUserData(in_struct->pUserData) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkInitializePerformanceApiInfoINTEL::safe_VkInitializePerformanceApiInfoINTEL()
+    : sType(VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL), pNext(nullptr), pUserData(nullptr) {}
+
+safe_VkInitializePerformanceApiInfoINTEL::safe_VkInitializePerformanceApiInfoINTEL(
+    const safe_VkInitializePerformanceApiInfoINTEL& copy_src) {
+    sType = copy_src.sType;
+    pUserData = copy_src.pUserData;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkInitializePerformanceApiInfoINTEL& safe_VkInitializePerformanceApiInfoINTEL::operator=(
+    const safe_VkInitializePerformanceApiInfoINTEL& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pUserData = copy_src.pUserData;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkInitializePerformanceApiInfoINTEL::~safe_VkInitializePerformanceApiInfoINTEL() { FreePnextChain(pNext); }
+
+void safe_VkInitializePerformanceApiInfoINTEL::initialize(const VkInitializePerformanceApiInfoINTEL* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pUserData = in_struct->pUserData;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkInitializePerformanceApiInfoINTEL::initialize(const safe_VkInitializePerformanceApiInfoINTEL* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pUserData = copy_src->pUserData;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkQueryPoolPerformanceQueryCreateInfoINTEL::safe_VkQueryPoolPerformanceQueryCreateInfoINTEL(
+    const VkQueryPoolPerformanceQueryCreateInfoINTEL* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), performanceCountersSampling(in_struct->performanceCountersSampling) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkQueryPoolPerformanceQueryCreateInfoINTEL::safe_VkQueryPoolPerformanceQueryCreateInfoINTEL()
+    : sType(VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL), pNext(nullptr), performanceCountersSampling() {}
+
+safe_VkQueryPoolPerformanceQueryCreateInfoINTEL::safe_VkQueryPoolPerformanceQueryCreateInfoINTEL(
+    const safe_VkQueryPoolPerformanceQueryCreateInfoINTEL& copy_src) {
+    sType = copy_src.sType;
+    performanceCountersSampling = copy_src.performanceCountersSampling;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkQueryPoolPerformanceQueryCreateInfoINTEL& safe_VkQueryPoolPerformanceQueryCreateInfoINTEL::operator=(
+    const safe_VkQueryPoolPerformanceQueryCreateInfoINTEL& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    performanceCountersSampling = copy_src.performanceCountersSampling;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkQueryPoolPerformanceQueryCreateInfoINTEL::~safe_VkQueryPoolPerformanceQueryCreateInfoINTEL() { FreePnextChain(pNext); }
+
+void safe_VkQueryPoolPerformanceQueryCreateInfoINTEL::initialize(const VkQueryPoolPerformanceQueryCreateInfoINTEL* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    performanceCountersSampling = in_struct->performanceCountersSampling;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkQueryPoolPerformanceQueryCreateInfoINTEL::initialize(const safe_VkQueryPoolPerformanceQueryCreateInfoINTEL* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    performanceCountersSampling = copy_src->performanceCountersSampling;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPerformanceMarkerInfoINTEL::safe_VkPerformanceMarkerInfoINTEL(const VkPerformanceMarkerInfoINTEL* in_struct,
+                                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), marker(in_struct->marker) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPerformanceMarkerInfoINTEL::safe_VkPerformanceMarkerInfoINTEL()
+    : sType(VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL), pNext(nullptr), marker() {}
+
+safe_VkPerformanceMarkerInfoINTEL::safe_VkPerformanceMarkerInfoINTEL(const safe_VkPerformanceMarkerInfoINTEL& copy_src) {
+    sType = copy_src.sType;
+    marker = copy_src.marker;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPerformanceMarkerInfoINTEL& safe_VkPerformanceMarkerInfoINTEL::operator=(const safe_VkPerformanceMarkerInfoINTEL& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    marker = copy_src.marker;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPerformanceMarkerInfoINTEL::~safe_VkPerformanceMarkerInfoINTEL() { FreePnextChain(pNext); }
+
+void safe_VkPerformanceMarkerInfoINTEL::initialize(const VkPerformanceMarkerInfoINTEL* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    marker = in_struct->marker;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPerformanceMarkerInfoINTEL::initialize(const safe_VkPerformanceMarkerInfoINTEL* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    marker = copy_src->marker;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPerformanceStreamMarkerInfoINTEL::safe_VkPerformanceStreamMarkerInfoINTEL(
+    const VkPerformanceStreamMarkerInfoINTEL* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), marker(in_struct->marker) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPerformanceStreamMarkerInfoINTEL::safe_VkPerformanceStreamMarkerInfoINTEL()
+    : sType(VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL), pNext(nullptr), marker() {}
+
+safe_VkPerformanceStreamMarkerInfoINTEL::safe_VkPerformanceStreamMarkerInfoINTEL(
+    const safe_VkPerformanceStreamMarkerInfoINTEL& copy_src) {
+    sType = copy_src.sType;
+    marker = copy_src.marker;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPerformanceStreamMarkerInfoINTEL& safe_VkPerformanceStreamMarkerInfoINTEL::operator=(
+    const safe_VkPerformanceStreamMarkerInfoINTEL& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    marker = copy_src.marker;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPerformanceStreamMarkerInfoINTEL::~safe_VkPerformanceStreamMarkerInfoINTEL() { FreePnextChain(pNext); }
+
+void safe_VkPerformanceStreamMarkerInfoINTEL::initialize(const VkPerformanceStreamMarkerInfoINTEL* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    marker = in_struct->marker;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPerformanceStreamMarkerInfoINTEL::initialize(const safe_VkPerformanceStreamMarkerInfoINTEL* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    marker = copy_src->marker;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPerformanceOverrideInfoINTEL::safe_VkPerformanceOverrideInfoINTEL(const VkPerformanceOverrideInfoINTEL* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType), type(in_struct->type), enable(in_struct->enable), parameter(in_struct->parameter) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPerformanceOverrideInfoINTEL::safe_VkPerformanceOverrideInfoINTEL()
+    : sType(VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL), pNext(nullptr), type(), enable(), parameter() {}
+
+safe_VkPerformanceOverrideInfoINTEL::safe_VkPerformanceOverrideInfoINTEL(const safe_VkPerformanceOverrideInfoINTEL& copy_src) {
+    sType = copy_src.sType;
+    type = copy_src.type;
+    enable = copy_src.enable;
+    parameter = copy_src.parameter;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPerformanceOverrideInfoINTEL& safe_VkPerformanceOverrideInfoINTEL::operator=(
+    const safe_VkPerformanceOverrideInfoINTEL& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    type = copy_src.type;
+    enable = copy_src.enable;
+    parameter = copy_src.parameter;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPerformanceOverrideInfoINTEL::~safe_VkPerformanceOverrideInfoINTEL() { FreePnextChain(pNext); }
+
+void safe_VkPerformanceOverrideInfoINTEL::initialize(const VkPerformanceOverrideInfoINTEL* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    type = in_struct->type;
+    enable = in_struct->enable;
+    parameter = in_struct->parameter;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPerformanceOverrideInfoINTEL::initialize(const safe_VkPerformanceOverrideInfoINTEL* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    type = copy_src->type;
+    enable = copy_src->enable;
+    parameter = copy_src->parameter;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPerformanceConfigurationAcquireInfoINTEL::safe_VkPerformanceConfigurationAcquireInfoINTEL(
+    const VkPerformanceConfigurationAcquireInfoINTEL* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), type(in_struct->type) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPerformanceConfigurationAcquireInfoINTEL::safe_VkPerformanceConfigurationAcquireInfoINTEL()
+    : sType(VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL), pNext(nullptr), type() {}
+
+safe_VkPerformanceConfigurationAcquireInfoINTEL::safe_VkPerformanceConfigurationAcquireInfoINTEL(
+    const safe_VkPerformanceConfigurationAcquireInfoINTEL& copy_src) {
+    sType = copy_src.sType;
+    type = copy_src.type;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPerformanceConfigurationAcquireInfoINTEL& safe_VkPerformanceConfigurationAcquireInfoINTEL::operator=(
+    const safe_VkPerformanceConfigurationAcquireInfoINTEL& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    type = copy_src.type;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPerformanceConfigurationAcquireInfoINTEL::~safe_VkPerformanceConfigurationAcquireInfoINTEL() { FreePnextChain(pNext); }
+
+void safe_VkPerformanceConfigurationAcquireInfoINTEL::initialize(const VkPerformanceConfigurationAcquireInfoINTEL* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    type = in_struct->type;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPerformanceConfigurationAcquireInfoINTEL::initialize(const safe_VkPerformanceConfigurationAcquireInfoINTEL* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    type = copy_src->type;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD::safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
+    const VkDisplayNativeHdrSurfaceCapabilitiesAMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), localDimmingSupport(in_struct->localDimmingSupport) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD::safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD()
+    : sType(VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD), pNext(nullptr), localDimmingSupport() {}
+
+safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD::safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
+    const safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD& copy_src) {
+    sType = copy_src.sType;
+    localDimmingSupport = copy_src.localDimmingSupport;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD& safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD::operator=(
+    const safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    localDimmingSupport = copy_src.localDimmingSupport;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD::~safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD() { FreePnextChain(pNext); }
+
+void safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD::initialize(const VkDisplayNativeHdrSurfaceCapabilitiesAMD* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    localDimmingSupport = in_struct->localDimmingSupport;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD::initialize(const safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    localDimmingSupport = copy_src->localDimmingSupport;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSwapchainDisplayNativeHdrCreateInfoAMD::safe_VkSwapchainDisplayNativeHdrCreateInfoAMD(
+    const VkSwapchainDisplayNativeHdrCreateInfoAMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), localDimmingEnable(in_struct->localDimmingEnable) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSwapchainDisplayNativeHdrCreateInfoAMD::safe_VkSwapchainDisplayNativeHdrCreateInfoAMD()
+    : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD), pNext(nullptr), localDimmingEnable() {}
+
+safe_VkSwapchainDisplayNativeHdrCreateInfoAMD::safe_VkSwapchainDisplayNativeHdrCreateInfoAMD(
+    const safe_VkSwapchainDisplayNativeHdrCreateInfoAMD& copy_src) {
+    sType = copy_src.sType;
+    localDimmingEnable = copy_src.localDimmingEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSwapchainDisplayNativeHdrCreateInfoAMD& safe_VkSwapchainDisplayNativeHdrCreateInfoAMD::operator=(
+    const safe_VkSwapchainDisplayNativeHdrCreateInfoAMD& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    localDimmingEnable = copy_src.localDimmingEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSwapchainDisplayNativeHdrCreateInfoAMD::~safe_VkSwapchainDisplayNativeHdrCreateInfoAMD() { FreePnextChain(pNext); }
+
+void safe_VkSwapchainDisplayNativeHdrCreateInfoAMD::initialize(const VkSwapchainDisplayNativeHdrCreateInfoAMD* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    localDimmingEnable = in_struct->localDimmingEnable;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSwapchainDisplayNativeHdrCreateInfoAMD::initialize(const safe_VkSwapchainDisplayNativeHdrCreateInfoAMD* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    localDimmingEnable = copy_src->localDimmingEnable;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+safe_VkImagePipeSurfaceCreateInfoFUCHSIA::safe_VkImagePipeSurfaceCreateInfoFUCHSIA(
+    const VkImagePipeSurfaceCreateInfoFUCHSIA* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags), imagePipeHandle(in_struct->imagePipeHandle) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImagePipeSurfaceCreateInfoFUCHSIA::safe_VkImagePipeSurfaceCreateInfoFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA), pNext(nullptr), flags(), imagePipeHandle() {}
+
+safe_VkImagePipeSurfaceCreateInfoFUCHSIA::safe_VkImagePipeSurfaceCreateInfoFUCHSIA(
+    const safe_VkImagePipeSurfaceCreateInfoFUCHSIA& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    imagePipeHandle = copy_src.imagePipeHandle;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImagePipeSurfaceCreateInfoFUCHSIA& safe_VkImagePipeSurfaceCreateInfoFUCHSIA::operator=(
+    const safe_VkImagePipeSurfaceCreateInfoFUCHSIA& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    imagePipeHandle = copy_src.imagePipeHandle;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImagePipeSurfaceCreateInfoFUCHSIA::~safe_VkImagePipeSurfaceCreateInfoFUCHSIA() { FreePnextChain(pNext); }
+
+void safe_VkImagePipeSurfaceCreateInfoFUCHSIA::initialize(const VkImagePipeSurfaceCreateInfoFUCHSIA* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    imagePipeHandle = in_struct->imagePipeHandle;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImagePipeSurfaceCreateInfoFUCHSIA::initialize(const safe_VkImagePipeSurfaceCreateInfoFUCHSIA* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    imagePipeHandle = copy_src->imagePipeHandle;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+#endif  // VK_USE_PLATFORM_FUCHSIA
+
+safe_VkPhysicalDeviceShaderCoreProperties2AMD::safe_VkPhysicalDeviceShaderCoreProperties2AMD(
+    const VkPhysicalDeviceShaderCoreProperties2AMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      shaderCoreFeatures(in_struct->shaderCoreFeatures),
+      activeComputeUnitCount(in_struct->activeComputeUnitCount) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderCoreProperties2AMD::safe_VkPhysicalDeviceShaderCoreProperties2AMD()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD),
+      pNext(nullptr),
+      shaderCoreFeatures(),
+      activeComputeUnitCount() {}
+
+safe_VkPhysicalDeviceShaderCoreProperties2AMD::safe_VkPhysicalDeviceShaderCoreProperties2AMD(
+    const safe_VkPhysicalDeviceShaderCoreProperties2AMD& copy_src) {
+    sType = copy_src.sType;
+    shaderCoreFeatures = copy_src.shaderCoreFeatures;
+    activeComputeUnitCount = copy_src.activeComputeUnitCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderCoreProperties2AMD& safe_VkPhysicalDeviceShaderCoreProperties2AMD::operator=(
+    const safe_VkPhysicalDeviceShaderCoreProperties2AMD& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderCoreFeatures = copy_src.shaderCoreFeatures;
+    activeComputeUnitCount = copy_src.activeComputeUnitCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderCoreProperties2AMD::~safe_VkPhysicalDeviceShaderCoreProperties2AMD() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceShaderCoreProperties2AMD::initialize(const VkPhysicalDeviceShaderCoreProperties2AMD* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderCoreFeatures = in_struct->shaderCoreFeatures;
+    activeComputeUnitCount = in_struct->activeComputeUnitCount;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderCoreProperties2AMD::initialize(const safe_VkPhysicalDeviceShaderCoreProperties2AMD* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderCoreFeatures = copy_src->shaderCoreFeatures;
+    activeComputeUnitCount = copy_src->activeComputeUnitCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD::safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
+    const VkPhysicalDeviceCoherentMemoryFeaturesAMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), deviceCoherentMemory(in_struct->deviceCoherentMemory) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD::safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD), pNext(nullptr), deviceCoherentMemory() {}
+
+safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD::safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
+    const safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD& copy_src) {
+    sType = copy_src.sType;
+    deviceCoherentMemory = copy_src.deviceCoherentMemory;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD& safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD::operator=(
+    const safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    deviceCoherentMemory = copy_src.deviceCoherentMemory;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD::~safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD::initialize(const VkPhysicalDeviceCoherentMemoryFeaturesAMD* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    deviceCoherentMemory = in_struct->deviceCoherentMemory;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD::initialize(const safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    deviceCoherentMemory = copy_src->deviceCoherentMemory;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
+    const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), dedicatedAllocationImageAliasing(in_struct->dedicatedAllocationImageAliasing) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV),
+      pNext(nullptr),
+      dedicatedAllocationImageAliasing() {}
+
+safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
+    const safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    dedicatedAllocationImageAliasing = copy_src.dedicatedAllocationImageAliasing;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV&
+safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    dedicatedAllocationImageAliasing = copy_src.dedicatedAllocationImageAliasing;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::
+    ~safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::initialize(
+    const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    dedicatedAllocationImageAliasing = in_struct->dedicatedAllocationImageAliasing;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::initialize(
+    const safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    dedicatedAllocationImageAliasing = copy_src->dedicatedAllocationImageAliasing;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkCooperativeMatrixPropertiesNV::safe_VkCooperativeMatrixPropertiesNV(const VkCooperativeMatrixPropertiesNV* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType),
+      MSize(in_struct->MSize),
+      NSize(in_struct->NSize),
+      KSize(in_struct->KSize),
+      AType(in_struct->AType),
+      BType(in_struct->BType),
+      CType(in_struct->CType),
+      DType(in_struct->DType),
+      scope(in_struct->scope) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkCooperativeMatrixPropertiesNV::safe_VkCooperativeMatrixPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV),
+      pNext(nullptr),
+      MSize(),
+      NSize(),
+      KSize(),
+      AType(),
+      BType(),
+      CType(),
+      DType(),
+      scope() {}
+
+safe_VkCooperativeMatrixPropertiesNV::safe_VkCooperativeMatrixPropertiesNV(const safe_VkCooperativeMatrixPropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    MSize = copy_src.MSize;
+    NSize = copy_src.NSize;
+    KSize = copy_src.KSize;
+    AType = copy_src.AType;
+    BType = copy_src.BType;
+    CType = copy_src.CType;
+    DType = copy_src.DType;
+    scope = copy_src.scope;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkCooperativeMatrixPropertiesNV& safe_VkCooperativeMatrixPropertiesNV::operator=(
+    const safe_VkCooperativeMatrixPropertiesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    MSize = copy_src.MSize;
+    NSize = copy_src.NSize;
+    KSize = copy_src.KSize;
+    AType = copy_src.AType;
+    BType = copy_src.BType;
+    CType = copy_src.CType;
+    DType = copy_src.DType;
+    scope = copy_src.scope;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkCooperativeMatrixPropertiesNV::~safe_VkCooperativeMatrixPropertiesNV() { FreePnextChain(pNext); }
+
+void safe_VkCooperativeMatrixPropertiesNV::initialize(const VkCooperativeMatrixPropertiesNV* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    MSize = in_struct->MSize;
+    NSize = in_struct->NSize;
+    KSize = in_struct->KSize;
+    AType = in_struct->AType;
+    BType = in_struct->BType;
+    CType = in_struct->CType;
+    DType = in_struct->DType;
+    scope = in_struct->scope;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkCooperativeMatrixPropertiesNV::initialize(const safe_VkCooperativeMatrixPropertiesNV* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    MSize = copy_src->MSize;
+    NSize = copy_src->NSize;
+    KSize = copy_src->KSize;
+    AType = copy_src->AType;
+    BType = copy_src->BType;
+    CType = copy_src->CType;
+    DType = copy_src->DType;
+    scope = copy_src->scope;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV::safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
+    const VkPhysicalDeviceCooperativeMatrixFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      cooperativeMatrix(in_struct->cooperativeMatrix),
+      cooperativeMatrixRobustBufferAccess(in_struct->cooperativeMatrixRobustBufferAccess) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV::safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV),
+      pNext(nullptr),
+      cooperativeMatrix(),
+      cooperativeMatrixRobustBufferAccess() {}
+
+safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV::safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
+    const safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    cooperativeMatrix = copy_src.cooperativeMatrix;
+    cooperativeMatrixRobustBufferAccess = copy_src.cooperativeMatrixRobustBufferAccess;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV& safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    cooperativeMatrix = copy_src.cooperativeMatrix;
+    cooperativeMatrixRobustBufferAccess = copy_src.cooperativeMatrixRobustBufferAccess;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV::~safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV::initialize(const VkPhysicalDeviceCooperativeMatrixFeaturesNV* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    cooperativeMatrix = in_struct->cooperativeMatrix;
+    cooperativeMatrixRobustBufferAccess = in_struct->cooperativeMatrixRobustBufferAccess;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV::initialize(const safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    cooperativeMatrix = copy_src->cooperativeMatrix;
+    cooperativeMatrixRobustBufferAccess = copy_src->cooperativeMatrixRobustBufferAccess;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV::safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
+    const VkPhysicalDeviceCooperativeMatrixPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), cooperativeMatrixSupportedStages(in_struct->cooperativeMatrixSupportedStages) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV::safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV),
+      pNext(nullptr),
+      cooperativeMatrixSupportedStages() {}
+
+safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV::safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
+    const safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    cooperativeMatrixSupportedStages = copy_src.cooperativeMatrixSupportedStages;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV& safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV::operator=(
+    const safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    cooperativeMatrixSupportedStages = copy_src.cooperativeMatrixSupportedStages;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV::~safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV::initialize(const VkPhysicalDeviceCooperativeMatrixPropertiesNV* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    cooperativeMatrixSupportedStages = in_struct->cooperativeMatrixSupportedStages;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV::initialize(
+    const safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    cooperativeMatrixSupportedStages = copy_src->cooperativeMatrixSupportedStages;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV::safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
+    const VkPhysicalDeviceCoverageReductionModeFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), coverageReductionMode(in_struct->coverageReductionMode) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV::safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV), pNext(nullptr), coverageReductionMode() {}
+
+safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV::safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
+    const safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    coverageReductionMode = copy_src.coverageReductionMode;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV& safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    coverageReductionMode = copy_src.coverageReductionMode;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV::~safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV::initialize(
+    const VkPhysicalDeviceCoverageReductionModeFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    coverageReductionMode = in_struct->coverageReductionMode;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV::initialize(
+    const safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    coverageReductionMode = copy_src->coverageReductionMode;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineCoverageReductionStateCreateInfoNV::safe_VkPipelineCoverageReductionStateCreateInfoNV(
+    const VkPipelineCoverageReductionStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags), coverageReductionMode(in_struct->coverageReductionMode) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPipelineCoverageReductionStateCreateInfoNV::safe_VkPipelineCoverageReductionStateCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV), pNext(nullptr), flags(), coverageReductionMode() {}
+
+safe_VkPipelineCoverageReductionStateCreateInfoNV::safe_VkPipelineCoverageReductionStateCreateInfoNV(
+    const safe_VkPipelineCoverageReductionStateCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    coverageReductionMode = copy_src.coverageReductionMode;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPipelineCoverageReductionStateCreateInfoNV& safe_VkPipelineCoverageReductionStateCreateInfoNV::operator=(
+    const safe_VkPipelineCoverageReductionStateCreateInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    coverageReductionMode = copy_src.coverageReductionMode;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineCoverageReductionStateCreateInfoNV::~safe_VkPipelineCoverageReductionStateCreateInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkPipelineCoverageReductionStateCreateInfoNV::initialize(const VkPipelineCoverageReductionStateCreateInfoNV* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    coverageReductionMode = in_struct->coverageReductionMode;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPipelineCoverageReductionStateCreateInfoNV::initialize(
+    const safe_VkPipelineCoverageReductionStateCreateInfoNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    coverageReductionMode = copy_src->coverageReductionMode;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkFramebufferMixedSamplesCombinationNV::safe_VkFramebufferMixedSamplesCombinationNV(
+    const VkFramebufferMixedSamplesCombinationNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      coverageReductionMode(in_struct->coverageReductionMode),
+      rasterizationSamples(in_struct->rasterizationSamples),
+      depthStencilSamples(in_struct->depthStencilSamples),
+      colorSamples(in_struct->colorSamples) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkFramebufferMixedSamplesCombinationNV::safe_VkFramebufferMixedSamplesCombinationNV()
+    : sType(VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV),
+      pNext(nullptr),
+      coverageReductionMode(),
+      rasterizationSamples(),
+      depthStencilSamples(),
+      colorSamples() {}
+
+safe_VkFramebufferMixedSamplesCombinationNV::safe_VkFramebufferMixedSamplesCombinationNV(
+    const safe_VkFramebufferMixedSamplesCombinationNV& copy_src) {
+    sType = copy_src.sType;
+    coverageReductionMode = copy_src.coverageReductionMode;
+    rasterizationSamples = copy_src.rasterizationSamples;
+    depthStencilSamples = copy_src.depthStencilSamples;
+    colorSamples = copy_src.colorSamples;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkFramebufferMixedSamplesCombinationNV& safe_VkFramebufferMixedSamplesCombinationNV::operator=(
+    const safe_VkFramebufferMixedSamplesCombinationNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    coverageReductionMode = copy_src.coverageReductionMode;
+    rasterizationSamples = copy_src.rasterizationSamples;
+    depthStencilSamples = copy_src.depthStencilSamples;
+    colorSamples = copy_src.colorSamples;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkFramebufferMixedSamplesCombinationNV::~safe_VkFramebufferMixedSamplesCombinationNV() { FreePnextChain(pNext); }
+
+void safe_VkFramebufferMixedSamplesCombinationNV::initialize(const VkFramebufferMixedSamplesCombinationNV* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    coverageReductionMode = in_struct->coverageReductionMode;
+    rasterizationSamples = in_struct->rasterizationSamples;
+    depthStencilSamples = in_struct->depthStencilSamples;
+    colorSamples = in_struct->colorSamples;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkFramebufferMixedSamplesCombinationNV::initialize(const safe_VkFramebufferMixedSamplesCombinationNV* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    coverageReductionMode = copy_src->coverageReductionMode;
+    rasterizationSamples = copy_src->rasterizationSamples;
+    depthStencilSamples = copy_src->depthStencilSamples;
+    colorSamples = copy_src->colorSamples;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
+    const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      maxGraphicsShaderGroupCount(in_struct->maxGraphicsShaderGroupCount),
+      maxIndirectSequenceCount(in_struct->maxIndirectSequenceCount),
+      maxIndirectCommandsTokenCount(in_struct->maxIndirectCommandsTokenCount),
+      maxIndirectCommandsStreamCount(in_struct->maxIndirectCommandsStreamCount),
+      maxIndirectCommandsTokenOffset(in_struct->maxIndirectCommandsTokenOffset),
+      maxIndirectCommandsStreamStride(in_struct->maxIndirectCommandsStreamStride),
+      minSequencesCountBufferOffsetAlignment(in_struct->minSequencesCountBufferOffsetAlignment),
+      minSequencesIndexBufferOffsetAlignment(in_struct->minSequencesIndexBufferOffsetAlignment),
+      minIndirectCommandsBufferOffsetAlignment(in_struct->minIndirectCommandsBufferOffsetAlignment) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV),
+      pNext(nullptr),
+      maxGraphicsShaderGroupCount(),
+      maxIndirectSequenceCount(),
+      maxIndirectCommandsTokenCount(),
+      maxIndirectCommandsStreamCount(),
+      maxIndirectCommandsTokenOffset(),
+      maxIndirectCommandsStreamStride(),
+      minSequencesCountBufferOffsetAlignment(),
+      minSequencesIndexBufferOffsetAlignment(),
+      minIndirectCommandsBufferOffsetAlignment() {}
+
+safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
+    const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    maxGraphicsShaderGroupCount = copy_src.maxGraphicsShaderGroupCount;
+    maxIndirectSequenceCount = copy_src.maxIndirectSequenceCount;
+    maxIndirectCommandsTokenCount = copy_src.maxIndirectCommandsTokenCount;
+    maxIndirectCommandsStreamCount = copy_src.maxIndirectCommandsStreamCount;
+    maxIndirectCommandsTokenOffset = copy_src.maxIndirectCommandsTokenOffset;
+    maxIndirectCommandsStreamStride = copy_src.maxIndirectCommandsStreamStride;
+    minSequencesCountBufferOffsetAlignment = copy_src.minSequencesCountBufferOffsetAlignment;
+    minSequencesIndexBufferOffsetAlignment = copy_src.minSequencesIndexBufferOffsetAlignment;
+    minIndirectCommandsBufferOffsetAlignment = copy_src.minIndirectCommandsBufferOffsetAlignment;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV& safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::operator=(
+    const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxGraphicsShaderGroupCount = copy_src.maxGraphicsShaderGroupCount;
+    maxIndirectSequenceCount = copy_src.maxIndirectSequenceCount;
+    maxIndirectCommandsTokenCount = copy_src.maxIndirectCommandsTokenCount;
+    maxIndirectCommandsStreamCount = copy_src.maxIndirectCommandsStreamCount;
+    maxIndirectCommandsTokenOffset = copy_src.maxIndirectCommandsTokenOffset;
+    maxIndirectCommandsStreamStride = copy_src.maxIndirectCommandsStreamStride;
+    minSequencesCountBufferOffsetAlignment = copy_src.minSequencesCountBufferOffsetAlignment;
+    minSequencesIndexBufferOffsetAlignment = copy_src.minSequencesIndexBufferOffsetAlignment;
+    minIndirectCommandsBufferOffsetAlignment = copy_src.minIndirectCommandsBufferOffsetAlignment;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::~safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::initialize(
+    const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxGraphicsShaderGroupCount = in_struct->maxGraphicsShaderGroupCount;
+    maxIndirectSequenceCount = in_struct->maxIndirectSequenceCount;
+    maxIndirectCommandsTokenCount = in_struct->maxIndirectCommandsTokenCount;
+    maxIndirectCommandsStreamCount = in_struct->maxIndirectCommandsStreamCount;
+    maxIndirectCommandsTokenOffset = in_struct->maxIndirectCommandsTokenOffset;
+    maxIndirectCommandsStreamStride = in_struct->maxIndirectCommandsStreamStride;
+    minSequencesCountBufferOffsetAlignment = in_struct->minSequencesCountBufferOffsetAlignment;
+    minSequencesIndexBufferOffsetAlignment = in_struct->minSequencesIndexBufferOffsetAlignment;
+    minIndirectCommandsBufferOffsetAlignment = in_struct->minIndirectCommandsBufferOffsetAlignment;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::initialize(
+    const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxGraphicsShaderGroupCount = copy_src->maxGraphicsShaderGroupCount;
+    maxIndirectSequenceCount = copy_src->maxIndirectSequenceCount;
+    maxIndirectCommandsTokenCount = copy_src->maxIndirectCommandsTokenCount;
+    maxIndirectCommandsStreamCount = copy_src->maxIndirectCommandsStreamCount;
+    maxIndirectCommandsTokenOffset = copy_src->maxIndirectCommandsTokenOffset;
+    maxIndirectCommandsStreamStride = copy_src->maxIndirectCommandsStreamStride;
+    minSequencesCountBufferOffsetAlignment = copy_src->minSequencesCountBufferOffsetAlignment;
+    minSequencesIndexBufferOffsetAlignment = copy_src->minSequencesIndexBufferOffsetAlignment;
+    minIndirectCommandsBufferOffsetAlignment = copy_src->minIndirectCommandsBufferOffsetAlignment;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
+    const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), deviceGeneratedCommands(in_struct->deviceGeneratedCommands) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV), pNext(nullptr), deviceGeneratedCommands() {}
+
+safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
+    const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    deviceGeneratedCommands = copy_src.deviceGeneratedCommands;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV& safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    deviceGeneratedCommands = copy_src.deviceGeneratedCommands;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::~safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::initialize(
+    const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    deviceGeneratedCommands = in_struct->deviceGeneratedCommands;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::initialize(
+    const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    deviceGeneratedCommands = copy_src->deviceGeneratedCommands;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkGraphicsShaderGroupCreateInfoNV::safe_VkGraphicsShaderGroupCreateInfoNV(const VkGraphicsShaderGroupCreateInfoNV* in_struct,
+                                                                               [[maybe_unused]] PNextCopyState* copy_state,
+                                                                               bool copy_pnext)
+    : sType(in_struct->sType),
+      stageCount(in_struct->stageCount),
+      pStages(nullptr),
+      pVertexInputState(nullptr),
+      pTessellationState(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (stageCount && in_struct->pStages) {
+        pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&in_struct->pStages[i]);
+        }
+    }
+    if (in_struct->pVertexInputState)
+        pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(in_struct->pVertexInputState);
+    if (in_struct->pTessellationState)
+        pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(in_struct->pTessellationState);
+}
+
+safe_VkGraphicsShaderGroupCreateInfoNV::safe_VkGraphicsShaderGroupCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV),
+      pNext(nullptr),
+      stageCount(),
+      pStages(nullptr),
+      pVertexInputState(nullptr),
+      pTessellationState(nullptr) {}
+
+safe_VkGraphicsShaderGroupCreateInfoNV::safe_VkGraphicsShaderGroupCreateInfoNV(
+    const safe_VkGraphicsShaderGroupCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    stageCount = copy_src.stageCount;
+    pStages = nullptr;
+    pVertexInputState = nullptr;
+    pTessellationState = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (stageCount && copy_src.pStages) {
+        pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&copy_src.pStages[i]);
+        }
+    }
+    if (copy_src.pVertexInputState) pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(*copy_src.pVertexInputState);
+    if (copy_src.pTessellationState)
+        pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(*copy_src.pTessellationState);
+}
+
+safe_VkGraphicsShaderGroupCreateInfoNV& safe_VkGraphicsShaderGroupCreateInfoNV::operator=(
+    const safe_VkGraphicsShaderGroupCreateInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pStages) delete[] pStages;
+    if (pVertexInputState) delete pVertexInputState;
+    if (pTessellationState) delete pTessellationState;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    stageCount = copy_src.stageCount;
+    pStages = nullptr;
+    pVertexInputState = nullptr;
+    pTessellationState = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (stageCount && copy_src.pStages) {
+        pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&copy_src.pStages[i]);
+        }
+    }
+    if (copy_src.pVertexInputState) pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(*copy_src.pVertexInputState);
+    if (copy_src.pTessellationState)
+        pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(*copy_src.pTessellationState);
+
+    return *this;
+}
+
+safe_VkGraphicsShaderGroupCreateInfoNV::~safe_VkGraphicsShaderGroupCreateInfoNV() {
+    if (pStages) delete[] pStages;
+    if (pVertexInputState) delete pVertexInputState;
+    if (pTessellationState) delete pTessellationState;
+    FreePnextChain(pNext);
+}
+
+void safe_VkGraphicsShaderGroupCreateInfoNV::initialize(const VkGraphicsShaderGroupCreateInfoNV* in_struct,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pStages) delete[] pStages;
+    if (pVertexInputState) delete pVertexInputState;
+    if (pTessellationState) delete pTessellationState;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    stageCount = in_struct->stageCount;
+    pStages = nullptr;
+    pVertexInputState = nullptr;
+    pTessellationState = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (stageCount && in_struct->pStages) {
+        pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&in_struct->pStages[i]);
+        }
+    }
+    if (in_struct->pVertexInputState)
+        pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(in_struct->pVertexInputState);
+    if (in_struct->pTessellationState)
+        pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(in_struct->pTessellationState);
+}
+
+void safe_VkGraphicsShaderGroupCreateInfoNV::initialize(const safe_VkGraphicsShaderGroupCreateInfoNV* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stageCount = copy_src->stageCount;
+    pStages = nullptr;
+    pVertexInputState = nullptr;
+    pTessellationState = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (stageCount && copy_src->pStages) {
+        pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
+        for (uint32_t i = 0; i < stageCount; ++i) {
+            pStages[i].initialize(&copy_src->pStages[i]);
+        }
+    }
+    if (copy_src->pVertexInputState)
+        pVertexInputState = new safe_VkPipelineVertexInputStateCreateInfo(*copy_src->pVertexInputState);
+    if (copy_src->pTessellationState)
+        pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(*copy_src->pTessellationState);
+}
+
+safe_VkGraphicsPipelineShaderGroupsCreateInfoNV::safe_VkGraphicsPipelineShaderGroupsCreateInfoNV(
+    const VkGraphicsPipelineShaderGroupsCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      groupCount(in_struct->groupCount),
+      pGroups(nullptr),
+      pipelineCount(in_struct->pipelineCount),
+      pPipelines(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (groupCount && in_struct->pGroups) {
+        pGroups = new safe_VkGraphicsShaderGroupCreateInfoNV[groupCount];
+        for (uint32_t i = 0; i < groupCount; ++i) {
+            pGroups[i].initialize(&in_struct->pGroups[i]);
+        }
+    }
+    if (pipelineCount && in_struct->pPipelines) {
+        pPipelines = new VkPipeline[pipelineCount];
+        for (uint32_t i = 0; i < pipelineCount; ++i) {
+            pPipelines[i] = in_struct->pPipelines[i];
+        }
+    }
+}
+
+safe_VkGraphicsPipelineShaderGroupsCreateInfoNV::safe_VkGraphicsPipelineShaderGroupsCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV),
+      pNext(nullptr),
+      groupCount(),
+      pGroups(nullptr),
+      pipelineCount(),
+      pPipelines(nullptr) {}
+
+safe_VkGraphicsPipelineShaderGroupsCreateInfoNV::safe_VkGraphicsPipelineShaderGroupsCreateInfoNV(
+    const safe_VkGraphicsPipelineShaderGroupsCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    groupCount = copy_src.groupCount;
+    pGroups = nullptr;
+    pipelineCount = copy_src.pipelineCount;
+    pPipelines = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (groupCount && copy_src.pGroups) {
+        pGroups = new safe_VkGraphicsShaderGroupCreateInfoNV[groupCount];
+        for (uint32_t i = 0; i < groupCount; ++i) {
+            pGroups[i].initialize(&copy_src.pGroups[i]);
+        }
+    }
+    if (pipelineCount && copy_src.pPipelines) {
+        pPipelines = new VkPipeline[pipelineCount];
+        for (uint32_t i = 0; i < pipelineCount; ++i) {
+            pPipelines[i] = copy_src.pPipelines[i];
+        }
+    }
+}
+
+safe_VkGraphicsPipelineShaderGroupsCreateInfoNV& safe_VkGraphicsPipelineShaderGroupsCreateInfoNV::operator=(
+    const safe_VkGraphicsPipelineShaderGroupsCreateInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pGroups) delete[] pGroups;
+    if (pPipelines) delete[] pPipelines;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    groupCount = copy_src.groupCount;
+    pGroups = nullptr;
+    pipelineCount = copy_src.pipelineCount;
+    pPipelines = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (groupCount && copy_src.pGroups) {
+        pGroups = new safe_VkGraphicsShaderGroupCreateInfoNV[groupCount];
+        for (uint32_t i = 0; i < groupCount; ++i) {
+            pGroups[i].initialize(&copy_src.pGroups[i]);
+        }
+    }
+    if (pipelineCount && copy_src.pPipelines) {
+        pPipelines = new VkPipeline[pipelineCount];
+        for (uint32_t i = 0; i < pipelineCount; ++i) {
+            pPipelines[i] = copy_src.pPipelines[i];
+        }
+    }
+
+    return *this;
+}
+
+safe_VkGraphicsPipelineShaderGroupsCreateInfoNV::~safe_VkGraphicsPipelineShaderGroupsCreateInfoNV() {
+    if (pGroups) delete[] pGroups;
+    if (pPipelines) delete[] pPipelines;
+    FreePnextChain(pNext);
+}
+
+void safe_VkGraphicsPipelineShaderGroupsCreateInfoNV::initialize(const VkGraphicsPipelineShaderGroupsCreateInfoNV* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pGroups) delete[] pGroups;
+    if (pPipelines) delete[] pPipelines;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    groupCount = in_struct->groupCount;
+    pGroups = nullptr;
+    pipelineCount = in_struct->pipelineCount;
+    pPipelines = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (groupCount && in_struct->pGroups) {
+        pGroups = new safe_VkGraphicsShaderGroupCreateInfoNV[groupCount];
+        for (uint32_t i = 0; i < groupCount; ++i) {
+            pGroups[i].initialize(&in_struct->pGroups[i]);
+        }
+    }
+    if (pipelineCount && in_struct->pPipelines) {
+        pPipelines = new VkPipeline[pipelineCount];
+        for (uint32_t i = 0; i < pipelineCount; ++i) {
+            pPipelines[i] = in_struct->pPipelines[i];
+        }
+    }
+}
+
+void safe_VkGraphicsPipelineShaderGroupsCreateInfoNV::initialize(const safe_VkGraphicsPipelineShaderGroupsCreateInfoNV* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    groupCount = copy_src->groupCount;
+    pGroups = nullptr;
+    pipelineCount = copy_src->pipelineCount;
+    pPipelines = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (groupCount && copy_src->pGroups) {
+        pGroups = new safe_VkGraphicsShaderGroupCreateInfoNV[groupCount];
+        for (uint32_t i = 0; i < groupCount; ++i) {
+            pGroups[i].initialize(&copy_src->pGroups[i]);
+        }
+    }
+    if (pipelineCount && copy_src->pPipelines) {
+        pPipelines = new VkPipeline[pipelineCount];
+        for (uint32_t i = 0; i < pipelineCount; ++i) {
+            pPipelines[i] = copy_src->pPipelines[i];
+        }
+    }
+}
+
+safe_VkIndirectCommandsLayoutTokenNV::safe_VkIndirectCommandsLayoutTokenNV(const VkIndirectCommandsLayoutTokenNV* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType),
+      tokenType(in_struct->tokenType),
+      stream(in_struct->stream),
+      offset(in_struct->offset),
+      vertexBindingUnit(in_struct->vertexBindingUnit),
+      vertexDynamicStride(in_struct->vertexDynamicStride),
+      pushconstantPipelineLayout(in_struct->pushconstantPipelineLayout),
+      pushconstantShaderStageFlags(in_struct->pushconstantShaderStageFlags),
+      pushconstantOffset(in_struct->pushconstantOffset),
+      pushconstantSize(in_struct->pushconstantSize),
+      indirectStateFlags(in_struct->indirectStateFlags),
+      indexTypeCount(in_struct->indexTypeCount),
+      pIndexTypes(nullptr),
+      pIndexTypeValues(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pIndexTypes) {
+        pIndexTypes = new VkIndexType[in_struct->indexTypeCount];
+        memcpy((void*)pIndexTypes, (void*)in_struct->pIndexTypes, sizeof(VkIndexType) * in_struct->indexTypeCount);
+    }
+
+    if (in_struct->pIndexTypeValues) {
+        pIndexTypeValues = new uint32_t[in_struct->indexTypeCount];
+        memcpy((void*)pIndexTypeValues, (void*)in_struct->pIndexTypeValues, sizeof(uint32_t) * in_struct->indexTypeCount);
+    }
+}
+
+safe_VkIndirectCommandsLayoutTokenNV::safe_VkIndirectCommandsLayoutTokenNV()
+    : sType(VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV),
+      pNext(nullptr),
+      tokenType(),
+      stream(),
+      offset(),
+      vertexBindingUnit(),
+      vertexDynamicStride(),
+      pushconstantPipelineLayout(),
+      pushconstantShaderStageFlags(),
+      pushconstantOffset(),
+      pushconstantSize(),
+      indirectStateFlags(),
+      indexTypeCount(),
+      pIndexTypes(nullptr),
+      pIndexTypeValues(nullptr) {}
+
+safe_VkIndirectCommandsLayoutTokenNV::safe_VkIndirectCommandsLayoutTokenNV(const safe_VkIndirectCommandsLayoutTokenNV& copy_src) {
+    sType = copy_src.sType;
+    tokenType = copy_src.tokenType;
+    stream = copy_src.stream;
+    offset = copy_src.offset;
+    vertexBindingUnit = copy_src.vertexBindingUnit;
+    vertexDynamicStride = copy_src.vertexDynamicStride;
+    pushconstantPipelineLayout = copy_src.pushconstantPipelineLayout;
+    pushconstantShaderStageFlags = copy_src.pushconstantShaderStageFlags;
+    pushconstantOffset = copy_src.pushconstantOffset;
+    pushconstantSize = copy_src.pushconstantSize;
+    indirectStateFlags = copy_src.indirectStateFlags;
+    indexTypeCount = copy_src.indexTypeCount;
+    pIndexTypes = nullptr;
+    pIndexTypeValues = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pIndexTypes) {
+        pIndexTypes = new VkIndexType[copy_src.indexTypeCount];
+        memcpy((void*)pIndexTypes, (void*)copy_src.pIndexTypes, sizeof(VkIndexType) * copy_src.indexTypeCount);
+    }
+
+    if (copy_src.pIndexTypeValues) {
+        pIndexTypeValues = new uint32_t[copy_src.indexTypeCount];
+        memcpy((void*)pIndexTypeValues, (void*)copy_src.pIndexTypeValues, sizeof(uint32_t) * copy_src.indexTypeCount);
+    }
+}
+
+safe_VkIndirectCommandsLayoutTokenNV& safe_VkIndirectCommandsLayoutTokenNV::operator=(
+    const safe_VkIndirectCommandsLayoutTokenNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pIndexTypes) delete[] pIndexTypes;
+    if (pIndexTypeValues) delete[] pIndexTypeValues;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    tokenType = copy_src.tokenType;
+    stream = copy_src.stream;
+    offset = copy_src.offset;
+    vertexBindingUnit = copy_src.vertexBindingUnit;
+    vertexDynamicStride = copy_src.vertexDynamicStride;
+    pushconstantPipelineLayout = copy_src.pushconstantPipelineLayout;
+    pushconstantShaderStageFlags = copy_src.pushconstantShaderStageFlags;
+    pushconstantOffset = copy_src.pushconstantOffset;
+    pushconstantSize = copy_src.pushconstantSize;
+    indirectStateFlags = copy_src.indirectStateFlags;
+    indexTypeCount = copy_src.indexTypeCount;
+    pIndexTypes = nullptr;
+    pIndexTypeValues = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pIndexTypes) {
+        pIndexTypes = new VkIndexType[copy_src.indexTypeCount];
+        memcpy((void*)pIndexTypes, (void*)copy_src.pIndexTypes, sizeof(VkIndexType) * copy_src.indexTypeCount);
+    }
+
+    if (copy_src.pIndexTypeValues) {
+        pIndexTypeValues = new uint32_t[copy_src.indexTypeCount];
+        memcpy((void*)pIndexTypeValues, (void*)copy_src.pIndexTypeValues, sizeof(uint32_t) * copy_src.indexTypeCount);
+    }
+
+    return *this;
+}
+
+safe_VkIndirectCommandsLayoutTokenNV::~safe_VkIndirectCommandsLayoutTokenNV() {
+    if (pIndexTypes) delete[] pIndexTypes;
+    if (pIndexTypeValues) delete[] pIndexTypeValues;
+    FreePnextChain(pNext);
+}
+
+void safe_VkIndirectCommandsLayoutTokenNV::initialize(const VkIndirectCommandsLayoutTokenNV* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pIndexTypes) delete[] pIndexTypes;
+    if (pIndexTypeValues) delete[] pIndexTypeValues;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    tokenType = in_struct->tokenType;
+    stream = in_struct->stream;
+    offset = in_struct->offset;
+    vertexBindingUnit = in_struct->vertexBindingUnit;
+    vertexDynamicStride = in_struct->vertexDynamicStride;
+    pushconstantPipelineLayout = in_struct->pushconstantPipelineLayout;
+    pushconstantShaderStageFlags = in_struct->pushconstantShaderStageFlags;
+    pushconstantOffset = in_struct->pushconstantOffset;
+    pushconstantSize = in_struct->pushconstantSize;
+    indirectStateFlags = in_struct->indirectStateFlags;
+    indexTypeCount = in_struct->indexTypeCount;
+    pIndexTypes = nullptr;
+    pIndexTypeValues = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pIndexTypes) {
+        pIndexTypes = new VkIndexType[in_struct->indexTypeCount];
+        memcpy((void*)pIndexTypes, (void*)in_struct->pIndexTypes, sizeof(VkIndexType) * in_struct->indexTypeCount);
+    }
+
+    if (in_struct->pIndexTypeValues) {
+        pIndexTypeValues = new uint32_t[in_struct->indexTypeCount];
+        memcpy((void*)pIndexTypeValues, (void*)in_struct->pIndexTypeValues, sizeof(uint32_t) * in_struct->indexTypeCount);
+    }
+}
+
+void safe_VkIndirectCommandsLayoutTokenNV::initialize(const safe_VkIndirectCommandsLayoutTokenNV* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    tokenType = copy_src->tokenType;
+    stream = copy_src->stream;
+    offset = copy_src->offset;
+    vertexBindingUnit = copy_src->vertexBindingUnit;
+    vertexDynamicStride = copy_src->vertexDynamicStride;
+    pushconstantPipelineLayout = copy_src->pushconstantPipelineLayout;
+    pushconstantShaderStageFlags = copy_src->pushconstantShaderStageFlags;
+    pushconstantOffset = copy_src->pushconstantOffset;
+    pushconstantSize = copy_src->pushconstantSize;
+    indirectStateFlags = copy_src->indirectStateFlags;
+    indexTypeCount = copy_src->indexTypeCount;
+    pIndexTypes = nullptr;
+    pIndexTypeValues = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pIndexTypes) {
+        pIndexTypes = new VkIndexType[copy_src->indexTypeCount];
+        memcpy((void*)pIndexTypes, (void*)copy_src->pIndexTypes, sizeof(VkIndexType) * copy_src->indexTypeCount);
+    }
+
+    if (copy_src->pIndexTypeValues) {
+        pIndexTypeValues = new uint32_t[copy_src->indexTypeCount];
+        memcpy((void*)pIndexTypeValues, (void*)copy_src->pIndexTypeValues, sizeof(uint32_t) * copy_src->indexTypeCount);
+    }
+}
+
+safe_VkIndirectCommandsLayoutCreateInfoNV::safe_VkIndirectCommandsLayoutCreateInfoNV(
+    const VkIndirectCommandsLayoutCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      pipelineBindPoint(in_struct->pipelineBindPoint),
+      tokenCount(in_struct->tokenCount),
+      pTokens(nullptr),
+      streamCount(in_struct->streamCount),
+      pStreamStrides(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (tokenCount && in_struct->pTokens) {
+        pTokens = new safe_VkIndirectCommandsLayoutTokenNV[tokenCount];
+        for (uint32_t i = 0; i < tokenCount; ++i) {
+            pTokens[i].initialize(&in_struct->pTokens[i]);
+        }
+    }
+
+    if (in_struct->pStreamStrides) {
+        pStreamStrides = new uint32_t[in_struct->streamCount];
+        memcpy((void*)pStreamStrides, (void*)in_struct->pStreamStrides, sizeof(uint32_t) * in_struct->streamCount);
+    }
+}
+
+safe_VkIndirectCommandsLayoutCreateInfoNV::safe_VkIndirectCommandsLayoutCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV),
+      pNext(nullptr),
+      flags(),
+      pipelineBindPoint(),
+      tokenCount(),
+      pTokens(nullptr),
+      streamCount(),
+      pStreamStrides(nullptr) {}
+
+safe_VkIndirectCommandsLayoutCreateInfoNV::safe_VkIndirectCommandsLayoutCreateInfoNV(
+    const safe_VkIndirectCommandsLayoutCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pipelineBindPoint = copy_src.pipelineBindPoint;
+    tokenCount = copy_src.tokenCount;
+    pTokens = nullptr;
+    streamCount = copy_src.streamCount;
+    pStreamStrides = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (tokenCount && copy_src.pTokens) {
+        pTokens = new safe_VkIndirectCommandsLayoutTokenNV[tokenCount];
+        for (uint32_t i = 0; i < tokenCount; ++i) {
+            pTokens[i].initialize(&copy_src.pTokens[i]);
+        }
+    }
+
+    if (copy_src.pStreamStrides) {
+        pStreamStrides = new uint32_t[copy_src.streamCount];
+        memcpy((void*)pStreamStrides, (void*)copy_src.pStreamStrides, sizeof(uint32_t) * copy_src.streamCount);
+    }
+}
+
+safe_VkIndirectCommandsLayoutCreateInfoNV& safe_VkIndirectCommandsLayoutCreateInfoNV::operator=(
+    const safe_VkIndirectCommandsLayoutCreateInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pTokens) delete[] pTokens;
+    if (pStreamStrides) delete[] pStreamStrides;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pipelineBindPoint = copy_src.pipelineBindPoint;
+    tokenCount = copy_src.tokenCount;
+    pTokens = nullptr;
+    streamCount = copy_src.streamCount;
+    pStreamStrides = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (tokenCount && copy_src.pTokens) {
+        pTokens = new safe_VkIndirectCommandsLayoutTokenNV[tokenCount];
+        for (uint32_t i = 0; i < tokenCount; ++i) {
+            pTokens[i].initialize(&copy_src.pTokens[i]);
+        }
+    }
+
+    if (copy_src.pStreamStrides) {
+        pStreamStrides = new uint32_t[copy_src.streamCount];
+        memcpy((void*)pStreamStrides, (void*)copy_src.pStreamStrides, sizeof(uint32_t) * copy_src.streamCount);
+    }
+
+    return *this;
+}
+
+safe_VkIndirectCommandsLayoutCreateInfoNV::~safe_VkIndirectCommandsLayoutCreateInfoNV() {
+    if (pTokens) delete[] pTokens;
+    if (pStreamStrides) delete[] pStreamStrides;
+    FreePnextChain(pNext);
+}
+
+void safe_VkIndirectCommandsLayoutCreateInfoNV::initialize(const VkIndirectCommandsLayoutCreateInfoNV* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pTokens) delete[] pTokens;
+    if (pStreamStrides) delete[] pStreamStrides;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    pipelineBindPoint = in_struct->pipelineBindPoint;
+    tokenCount = in_struct->tokenCount;
+    pTokens = nullptr;
+    streamCount = in_struct->streamCount;
+    pStreamStrides = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (tokenCount && in_struct->pTokens) {
+        pTokens = new safe_VkIndirectCommandsLayoutTokenNV[tokenCount];
+        for (uint32_t i = 0; i < tokenCount; ++i) {
+            pTokens[i].initialize(&in_struct->pTokens[i]);
+        }
+    }
+
+    if (in_struct->pStreamStrides) {
+        pStreamStrides = new uint32_t[in_struct->streamCount];
+        memcpy((void*)pStreamStrides, (void*)in_struct->pStreamStrides, sizeof(uint32_t) * in_struct->streamCount);
+    }
+}
+
+void safe_VkIndirectCommandsLayoutCreateInfoNV::initialize(const safe_VkIndirectCommandsLayoutCreateInfoNV* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pipelineBindPoint = copy_src->pipelineBindPoint;
+    tokenCount = copy_src->tokenCount;
+    pTokens = nullptr;
+    streamCount = copy_src->streamCount;
+    pStreamStrides = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (tokenCount && copy_src->pTokens) {
+        pTokens = new safe_VkIndirectCommandsLayoutTokenNV[tokenCount];
+        for (uint32_t i = 0; i < tokenCount; ++i) {
+            pTokens[i].initialize(&copy_src->pTokens[i]);
+        }
+    }
+
+    if (copy_src->pStreamStrides) {
+        pStreamStrides = new uint32_t[copy_src->streamCount];
+        memcpy((void*)pStreamStrides, (void*)copy_src->pStreamStrides, sizeof(uint32_t) * copy_src->streamCount);
+    }
+}
+
+safe_VkGeneratedCommandsInfoNV::safe_VkGeneratedCommandsInfoNV(const VkGeneratedCommandsInfoNV* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      pipelineBindPoint(in_struct->pipelineBindPoint),
+      pipeline(in_struct->pipeline),
+      indirectCommandsLayout(in_struct->indirectCommandsLayout),
+      streamCount(in_struct->streamCount),
+      pStreams(nullptr),
+      sequencesCount(in_struct->sequencesCount),
+      preprocessBuffer(in_struct->preprocessBuffer),
+      preprocessOffset(in_struct->preprocessOffset),
+      preprocessSize(in_struct->preprocessSize),
+      sequencesCountBuffer(in_struct->sequencesCountBuffer),
+      sequencesCountOffset(in_struct->sequencesCountOffset),
+      sequencesIndexBuffer(in_struct->sequencesIndexBuffer),
+      sequencesIndexOffset(in_struct->sequencesIndexOffset) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (streamCount && in_struct->pStreams) {
+        pStreams = new VkIndirectCommandsStreamNV[streamCount];
+        for (uint32_t i = 0; i < streamCount; ++i) {
+            pStreams[i] = in_struct->pStreams[i];
+        }
+    }
+}
+
+safe_VkGeneratedCommandsInfoNV::safe_VkGeneratedCommandsInfoNV()
+    : sType(VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV),
+      pNext(nullptr),
+      pipelineBindPoint(),
+      pipeline(),
+      indirectCommandsLayout(),
+      streamCount(),
+      pStreams(nullptr),
+      sequencesCount(),
+      preprocessBuffer(),
+      preprocessOffset(),
+      preprocessSize(),
+      sequencesCountBuffer(),
+      sequencesCountOffset(),
+      sequencesIndexBuffer(),
+      sequencesIndexOffset() {}
+
+safe_VkGeneratedCommandsInfoNV::safe_VkGeneratedCommandsInfoNV(const safe_VkGeneratedCommandsInfoNV& copy_src) {
+    sType = copy_src.sType;
+    pipelineBindPoint = copy_src.pipelineBindPoint;
+    pipeline = copy_src.pipeline;
+    indirectCommandsLayout = copy_src.indirectCommandsLayout;
+    streamCount = copy_src.streamCount;
+    pStreams = nullptr;
+    sequencesCount = copy_src.sequencesCount;
+    preprocessBuffer = copy_src.preprocessBuffer;
+    preprocessOffset = copy_src.preprocessOffset;
+    preprocessSize = copy_src.preprocessSize;
+    sequencesCountBuffer = copy_src.sequencesCountBuffer;
+    sequencesCountOffset = copy_src.sequencesCountOffset;
+    sequencesIndexBuffer = copy_src.sequencesIndexBuffer;
+    sequencesIndexOffset = copy_src.sequencesIndexOffset;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (streamCount && copy_src.pStreams) {
+        pStreams = new VkIndirectCommandsStreamNV[streamCount];
+        for (uint32_t i = 0; i < streamCount; ++i) {
+            pStreams[i] = copy_src.pStreams[i];
+        }
+    }
+}
+
+safe_VkGeneratedCommandsInfoNV& safe_VkGeneratedCommandsInfoNV::operator=(const safe_VkGeneratedCommandsInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pStreams) delete[] pStreams;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pipelineBindPoint = copy_src.pipelineBindPoint;
+    pipeline = copy_src.pipeline;
+    indirectCommandsLayout = copy_src.indirectCommandsLayout;
+    streamCount = copy_src.streamCount;
+    pStreams = nullptr;
+    sequencesCount = copy_src.sequencesCount;
+    preprocessBuffer = copy_src.preprocessBuffer;
+    preprocessOffset = copy_src.preprocessOffset;
+    preprocessSize = copy_src.preprocessSize;
+    sequencesCountBuffer = copy_src.sequencesCountBuffer;
+    sequencesCountOffset = copy_src.sequencesCountOffset;
+    sequencesIndexBuffer = copy_src.sequencesIndexBuffer;
+    sequencesIndexOffset = copy_src.sequencesIndexOffset;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (streamCount && copy_src.pStreams) {
+        pStreams = new VkIndirectCommandsStreamNV[streamCount];
+        for (uint32_t i = 0; i < streamCount; ++i) {
+            pStreams[i] = copy_src.pStreams[i];
+        }
+    }
+
+    return *this;
+}
+
+safe_VkGeneratedCommandsInfoNV::~safe_VkGeneratedCommandsInfoNV() {
+    if (pStreams) delete[] pStreams;
+    FreePnextChain(pNext);
+}
+
+void safe_VkGeneratedCommandsInfoNV::initialize(const VkGeneratedCommandsInfoNV* in_struct,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pStreams) delete[] pStreams;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pipelineBindPoint = in_struct->pipelineBindPoint;
+    pipeline = in_struct->pipeline;
+    indirectCommandsLayout = in_struct->indirectCommandsLayout;
+    streamCount = in_struct->streamCount;
+    pStreams = nullptr;
+    sequencesCount = in_struct->sequencesCount;
+    preprocessBuffer = in_struct->preprocessBuffer;
+    preprocessOffset = in_struct->preprocessOffset;
+    preprocessSize = in_struct->preprocessSize;
+    sequencesCountBuffer = in_struct->sequencesCountBuffer;
+    sequencesCountOffset = in_struct->sequencesCountOffset;
+    sequencesIndexBuffer = in_struct->sequencesIndexBuffer;
+    sequencesIndexOffset = in_struct->sequencesIndexOffset;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (streamCount && in_struct->pStreams) {
+        pStreams = new VkIndirectCommandsStreamNV[streamCount];
+        for (uint32_t i = 0; i < streamCount; ++i) {
+            pStreams[i] = in_struct->pStreams[i];
+        }
+    }
+}
+
+void safe_VkGeneratedCommandsInfoNV::initialize(const safe_VkGeneratedCommandsInfoNV* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pipelineBindPoint = copy_src->pipelineBindPoint;
+    pipeline = copy_src->pipeline;
+    indirectCommandsLayout = copy_src->indirectCommandsLayout;
+    streamCount = copy_src->streamCount;
+    pStreams = nullptr;
+    sequencesCount = copy_src->sequencesCount;
+    preprocessBuffer = copy_src->preprocessBuffer;
+    preprocessOffset = copy_src->preprocessOffset;
+    preprocessSize = copy_src->preprocessSize;
+    sequencesCountBuffer = copy_src->sequencesCountBuffer;
+    sequencesCountOffset = copy_src->sequencesCountOffset;
+    sequencesIndexBuffer = copy_src->sequencesIndexBuffer;
+    sequencesIndexOffset = copy_src->sequencesIndexOffset;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (streamCount && copy_src->pStreams) {
+        pStreams = new VkIndirectCommandsStreamNV[streamCount];
+        for (uint32_t i = 0; i < streamCount; ++i) {
+            pStreams[i] = copy_src->pStreams[i];
+        }
+    }
+}
+
+safe_VkGeneratedCommandsMemoryRequirementsInfoNV::safe_VkGeneratedCommandsMemoryRequirementsInfoNV(
+    const VkGeneratedCommandsMemoryRequirementsInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      pipelineBindPoint(in_struct->pipelineBindPoint),
+      pipeline(in_struct->pipeline),
+      indirectCommandsLayout(in_struct->indirectCommandsLayout),
+      maxSequencesCount(in_struct->maxSequencesCount) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkGeneratedCommandsMemoryRequirementsInfoNV::safe_VkGeneratedCommandsMemoryRequirementsInfoNV()
+    : sType(VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV),
+      pNext(nullptr),
+      pipelineBindPoint(),
+      pipeline(),
+      indirectCommandsLayout(),
+      maxSequencesCount() {}
+
+safe_VkGeneratedCommandsMemoryRequirementsInfoNV::safe_VkGeneratedCommandsMemoryRequirementsInfoNV(
+    const safe_VkGeneratedCommandsMemoryRequirementsInfoNV& copy_src) {
+    sType = copy_src.sType;
+    pipelineBindPoint = copy_src.pipelineBindPoint;
+    pipeline = copy_src.pipeline;
+    indirectCommandsLayout = copy_src.indirectCommandsLayout;
+    maxSequencesCount = copy_src.maxSequencesCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkGeneratedCommandsMemoryRequirementsInfoNV& safe_VkGeneratedCommandsMemoryRequirementsInfoNV::operator=(
+    const safe_VkGeneratedCommandsMemoryRequirementsInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pipelineBindPoint = copy_src.pipelineBindPoint;
+    pipeline = copy_src.pipeline;
+    indirectCommandsLayout = copy_src.indirectCommandsLayout;
+    maxSequencesCount = copy_src.maxSequencesCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkGeneratedCommandsMemoryRequirementsInfoNV::~safe_VkGeneratedCommandsMemoryRequirementsInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkGeneratedCommandsMemoryRequirementsInfoNV::initialize(const VkGeneratedCommandsMemoryRequirementsInfoNV* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pipelineBindPoint = in_struct->pipelineBindPoint;
+    pipeline = in_struct->pipeline;
+    indirectCommandsLayout = in_struct->indirectCommandsLayout;
+    maxSequencesCount = in_struct->maxSequencesCount;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkGeneratedCommandsMemoryRequirementsInfoNV::initialize(const safe_VkGeneratedCommandsMemoryRequirementsInfoNV* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pipelineBindPoint = copy_src->pipelineBindPoint;
+    pipeline = copy_src->pipeline;
+    indirectCommandsLayout = copy_src->indirectCommandsLayout;
+    maxSequencesCount = copy_src->maxSequencesCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV::safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
+    const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), inheritedViewportScissor2D(in_struct->inheritedViewportScissor2D) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV::safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV),
+      pNext(nullptr),
+      inheritedViewportScissor2D() {}
+
+safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV::safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
+    const safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    inheritedViewportScissor2D = copy_src.inheritedViewportScissor2D;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV& safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    inheritedViewportScissor2D = copy_src.inheritedViewportScissor2D;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV::~safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV::initialize(
+    const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    inheritedViewportScissor2D = in_struct->inheritedViewportScissor2D;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV::initialize(
+    const safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    inheritedViewportScissor2D = copy_src->inheritedViewportScissor2D;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkCommandBufferInheritanceViewportScissorInfoNV::safe_VkCommandBufferInheritanceViewportScissorInfoNV(
+    const VkCommandBufferInheritanceViewportScissorInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      viewportScissor2D(in_struct->viewportScissor2D),
+      viewportDepthCount(in_struct->viewportDepthCount),
+      pViewportDepths(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pViewportDepths) {
+        pViewportDepths = new VkViewport(*in_struct->pViewportDepths);
+    }
+}
+
+safe_VkCommandBufferInheritanceViewportScissorInfoNV::safe_VkCommandBufferInheritanceViewportScissorInfoNV()
+    : sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV),
+      pNext(nullptr),
+      viewportScissor2D(),
+      viewportDepthCount(),
+      pViewportDepths(nullptr) {}
+
+safe_VkCommandBufferInheritanceViewportScissorInfoNV::safe_VkCommandBufferInheritanceViewportScissorInfoNV(
+    const safe_VkCommandBufferInheritanceViewportScissorInfoNV& copy_src) {
+    sType = copy_src.sType;
+    viewportScissor2D = copy_src.viewportScissor2D;
+    viewportDepthCount = copy_src.viewportDepthCount;
+    pViewportDepths = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pViewportDepths) {
+        pViewportDepths = new VkViewport(*copy_src.pViewportDepths);
+    }
+}
+
+safe_VkCommandBufferInheritanceViewportScissorInfoNV& safe_VkCommandBufferInheritanceViewportScissorInfoNV::operator=(
+    const safe_VkCommandBufferInheritanceViewportScissorInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pViewportDepths) delete pViewportDepths;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    viewportScissor2D = copy_src.viewportScissor2D;
+    viewportDepthCount = copy_src.viewportDepthCount;
+    pViewportDepths = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pViewportDepths) {
+        pViewportDepths = new VkViewport(*copy_src.pViewportDepths);
+    }
+
+    return *this;
+}
+
+safe_VkCommandBufferInheritanceViewportScissorInfoNV::~safe_VkCommandBufferInheritanceViewportScissorInfoNV() {
+    if (pViewportDepths) delete pViewportDepths;
+    FreePnextChain(pNext);
+}
+
+void safe_VkCommandBufferInheritanceViewportScissorInfoNV::initialize(
+    const VkCommandBufferInheritanceViewportScissorInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pViewportDepths) delete pViewportDepths;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    viewportScissor2D = in_struct->viewportScissor2D;
+    viewportDepthCount = in_struct->viewportDepthCount;
+    pViewportDepths = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pViewportDepths) {
+        pViewportDepths = new VkViewport(*in_struct->pViewportDepths);
+    }
+}
+
+void safe_VkCommandBufferInheritanceViewportScissorInfoNV::initialize(
+    const safe_VkCommandBufferInheritanceViewportScissorInfoNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    viewportScissor2D = copy_src->viewportScissor2D;
+    viewportDepthCount = copy_src->viewportDepthCount;
+    pViewportDepths = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pViewportDepths) {
+        pViewportDepths = new VkViewport(*copy_src->pViewportDepths);
+    }
+}
+
+safe_VkRenderPassTransformBeginInfoQCOM::safe_VkRenderPassTransformBeginInfoQCOM(
+    const VkRenderPassTransformBeginInfoQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), transform(in_struct->transform) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkRenderPassTransformBeginInfoQCOM::safe_VkRenderPassTransformBeginInfoQCOM()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM), pNext(nullptr), transform() {}
+
+safe_VkRenderPassTransformBeginInfoQCOM::safe_VkRenderPassTransformBeginInfoQCOM(
+    const safe_VkRenderPassTransformBeginInfoQCOM& copy_src) {
+    sType = copy_src.sType;
+    transform = copy_src.transform;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkRenderPassTransformBeginInfoQCOM& safe_VkRenderPassTransformBeginInfoQCOM::operator=(
+    const safe_VkRenderPassTransformBeginInfoQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    transform = copy_src.transform;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkRenderPassTransformBeginInfoQCOM::~safe_VkRenderPassTransformBeginInfoQCOM() { FreePnextChain(pNext); }
+
+void safe_VkRenderPassTransformBeginInfoQCOM::initialize(const VkRenderPassTransformBeginInfoQCOM* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    transform = in_struct->transform;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkRenderPassTransformBeginInfoQCOM::initialize(const safe_VkRenderPassTransformBeginInfoQCOM* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    transform = copy_src->transform;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM::safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
+    const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), transform(in_struct->transform), renderArea(in_struct->renderArea) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM::safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM()
+    : sType(VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM),
+      pNext(nullptr),
+      transform(),
+      renderArea() {}
+
+safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM::safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
+    const safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM& copy_src) {
+    sType = copy_src.sType;
+    transform = copy_src.transform;
+    renderArea = copy_src.renderArea;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM& safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM::operator=(
+    const safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    transform = copy_src.transform;
+    renderArea = copy_src.renderArea;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM::~safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM::initialize(
+    const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    transform = in_struct->transform;
+    renderArea = in_struct->renderArea;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM::initialize(
+    const safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    transform = copy_src->transform;
+    renderArea = copy_src->renderArea;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDevicePresentBarrierFeaturesNV::safe_VkPhysicalDevicePresentBarrierFeaturesNV(
+    const VkPhysicalDevicePresentBarrierFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), presentBarrier(in_struct->presentBarrier) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePresentBarrierFeaturesNV::safe_VkPhysicalDevicePresentBarrierFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV), pNext(nullptr), presentBarrier() {}
+
+safe_VkPhysicalDevicePresentBarrierFeaturesNV::safe_VkPhysicalDevicePresentBarrierFeaturesNV(
+    const safe_VkPhysicalDevicePresentBarrierFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    presentBarrier = copy_src.presentBarrier;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePresentBarrierFeaturesNV& safe_VkPhysicalDevicePresentBarrierFeaturesNV::operator=(
+    const safe_VkPhysicalDevicePresentBarrierFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    presentBarrier = copy_src.presentBarrier;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePresentBarrierFeaturesNV::~safe_VkPhysicalDevicePresentBarrierFeaturesNV() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDevicePresentBarrierFeaturesNV::initialize(const VkPhysicalDevicePresentBarrierFeaturesNV* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    presentBarrier = in_struct->presentBarrier;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePresentBarrierFeaturesNV::initialize(const safe_VkPhysicalDevicePresentBarrierFeaturesNV* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    presentBarrier = copy_src->presentBarrier;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSurfaceCapabilitiesPresentBarrierNV::safe_VkSurfaceCapabilitiesPresentBarrierNV(
+    const VkSurfaceCapabilitiesPresentBarrierNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), presentBarrierSupported(in_struct->presentBarrierSupported) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSurfaceCapabilitiesPresentBarrierNV::safe_VkSurfaceCapabilitiesPresentBarrierNV()
+    : sType(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV), pNext(nullptr), presentBarrierSupported() {}
+
+safe_VkSurfaceCapabilitiesPresentBarrierNV::safe_VkSurfaceCapabilitiesPresentBarrierNV(
+    const safe_VkSurfaceCapabilitiesPresentBarrierNV& copy_src) {
+    sType = copy_src.sType;
+    presentBarrierSupported = copy_src.presentBarrierSupported;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSurfaceCapabilitiesPresentBarrierNV& safe_VkSurfaceCapabilitiesPresentBarrierNV::operator=(
+    const safe_VkSurfaceCapabilitiesPresentBarrierNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    presentBarrierSupported = copy_src.presentBarrierSupported;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSurfaceCapabilitiesPresentBarrierNV::~safe_VkSurfaceCapabilitiesPresentBarrierNV() { FreePnextChain(pNext); }
+
+void safe_VkSurfaceCapabilitiesPresentBarrierNV::initialize(const VkSurfaceCapabilitiesPresentBarrierNV* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    presentBarrierSupported = in_struct->presentBarrierSupported;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSurfaceCapabilitiesPresentBarrierNV::initialize(const safe_VkSurfaceCapabilitiesPresentBarrierNV* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    presentBarrierSupported = copy_src->presentBarrierSupported;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSwapchainPresentBarrierCreateInfoNV::safe_VkSwapchainPresentBarrierCreateInfoNV(
+    const VkSwapchainPresentBarrierCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), presentBarrierEnable(in_struct->presentBarrierEnable) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSwapchainPresentBarrierCreateInfoNV::safe_VkSwapchainPresentBarrierCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV), pNext(nullptr), presentBarrierEnable() {}
+
+safe_VkSwapchainPresentBarrierCreateInfoNV::safe_VkSwapchainPresentBarrierCreateInfoNV(
+    const safe_VkSwapchainPresentBarrierCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    presentBarrierEnable = copy_src.presentBarrierEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSwapchainPresentBarrierCreateInfoNV& safe_VkSwapchainPresentBarrierCreateInfoNV::operator=(
+    const safe_VkSwapchainPresentBarrierCreateInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    presentBarrierEnable = copy_src.presentBarrierEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSwapchainPresentBarrierCreateInfoNV::~safe_VkSwapchainPresentBarrierCreateInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkSwapchainPresentBarrierCreateInfoNV::initialize(const VkSwapchainPresentBarrierCreateInfoNV* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    presentBarrierEnable = in_struct->presentBarrierEnable;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSwapchainPresentBarrierCreateInfoNV::initialize(const safe_VkSwapchainPresentBarrierCreateInfoNV* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    presentBarrierEnable = copy_src->presentBarrierEnable;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV::safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
+    const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), diagnosticsConfig(in_struct->diagnosticsConfig) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV::safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV), pNext(nullptr), diagnosticsConfig() {}
+
+safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV::safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
+    const safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    diagnosticsConfig = copy_src.diagnosticsConfig;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV& safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    diagnosticsConfig = copy_src.diagnosticsConfig;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV::~safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV::initialize(const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    diagnosticsConfig = in_struct->diagnosticsConfig;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV::initialize(const safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    diagnosticsConfig = copy_src->diagnosticsConfig;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDeviceDiagnosticsConfigCreateInfoNV::safe_VkDeviceDiagnosticsConfigCreateInfoNV(
+    const VkDeviceDiagnosticsConfigCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDeviceDiagnosticsConfigCreateInfoNV::safe_VkDeviceDiagnosticsConfigCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV), pNext(nullptr), flags() {}
+
+safe_VkDeviceDiagnosticsConfigCreateInfoNV::safe_VkDeviceDiagnosticsConfigCreateInfoNV(
+    const safe_VkDeviceDiagnosticsConfigCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDeviceDiagnosticsConfigCreateInfoNV& safe_VkDeviceDiagnosticsConfigCreateInfoNV::operator=(
+    const safe_VkDeviceDiagnosticsConfigCreateInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDeviceDiagnosticsConfigCreateInfoNV::~safe_VkDeviceDiagnosticsConfigCreateInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkDeviceDiagnosticsConfigCreateInfoNV::initialize(const VkDeviceDiagnosticsConfigCreateInfoNV* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDeviceDiagnosticsConfigCreateInfoNV::initialize(const safe_VkDeviceDiagnosticsConfigCreateInfoNV* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkCudaModuleCreateInfoNV::safe_VkCudaModuleCreateInfoNV(const VkCudaModuleCreateInfoNV* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), dataSize(in_struct->dataSize), pData(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pData != nullptr) {
+        auto temp = new std::byte[in_struct->dataSize];
+        std::memcpy(temp, in_struct->pData, in_struct->dataSize);
+        pData = temp;
+    }
+}
+
+safe_VkCudaModuleCreateInfoNV::safe_VkCudaModuleCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV), pNext(nullptr), dataSize(), pData(nullptr) {}
+
+safe_VkCudaModuleCreateInfoNV::safe_VkCudaModuleCreateInfoNV(const safe_VkCudaModuleCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    dataSize = copy_src.dataSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pData != nullptr) {
+        auto temp = new std::byte[copy_src.dataSize];
+        std::memcpy(temp, copy_src.pData, copy_src.dataSize);
+        pData = temp;
+    }
+}
+
+safe_VkCudaModuleCreateInfoNV& safe_VkCudaModuleCreateInfoNV::operator=(const safe_VkCudaModuleCreateInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pData != nullptr) {
+        auto temp = reinterpret_cast<const std::byte*>(pData);
+        delete[] temp;
+    }
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    dataSize = copy_src.dataSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pData != nullptr) {
+        auto temp = new std::byte[copy_src.dataSize];
+        std::memcpy(temp, copy_src.pData, copy_src.dataSize);
+        pData = temp;
+    }
+
+    return *this;
+}
+
+safe_VkCudaModuleCreateInfoNV::~safe_VkCudaModuleCreateInfoNV() {
+    if (pData != nullptr) {
+        auto temp = reinterpret_cast<const std::byte*>(pData);
+        delete[] temp;
+    }
+    FreePnextChain(pNext);
+}
+
+void safe_VkCudaModuleCreateInfoNV::initialize(const VkCudaModuleCreateInfoNV* in_struct,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pData != nullptr) {
+        auto temp = reinterpret_cast<const std::byte*>(pData);
+        delete[] temp;
+    }
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    dataSize = in_struct->dataSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pData != nullptr) {
+        auto temp = new std::byte[in_struct->dataSize];
+        std::memcpy(temp, in_struct->pData, in_struct->dataSize);
+        pData = temp;
+    }
+}
+
+void safe_VkCudaModuleCreateInfoNV::initialize(const safe_VkCudaModuleCreateInfoNV* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    dataSize = copy_src->dataSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pData != nullptr) {
+        auto temp = new std::byte[copy_src->dataSize];
+        std::memcpy(temp, copy_src->pData, copy_src->dataSize);
+        pData = temp;
+    }
+}
+
+safe_VkCudaFunctionCreateInfoNV::safe_VkCudaFunctionCreateInfoNV(const VkCudaFunctionCreateInfoNV* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), module(in_struct->module) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    pName = SafeStringCopy(in_struct->pName);
+}
+
+safe_VkCudaFunctionCreateInfoNV::safe_VkCudaFunctionCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV), pNext(nullptr), module(), pName(nullptr) {}
+
+safe_VkCudaFunctionCreateInfoNV::safe_VkCudaFunctionCreateInfoNV(const safe_VkCudaFunctionCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    module = copy_src.module;
+    pNext = SafePnextCopy(copy_src.pNext);
+    pName = SafeStringCopy(copy_src.pName);
+}
+
+safe_VkCudaFunctionCreateInfoNV& safe_VkCudaFunctionCreateInfoNV::operator=(const safe_VkCudaFunctionCreateInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pName) delete[] pName;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    module = copy_src.module;
+    pNext = SafePnextCopy(copy_src.pNext);
+    pName = SafeStringCopy(copy_src.pName);
+
+    return *this;
+}
+
+safe_VkCudaFunctionCreateInfoNV::~safe_VkCudaFunctionCreateInfoNV() {
+    if (pName) delete[] pName;
+    FreePnextChain(pNext);
+}
+
+void safe_VkCudaFunctionCreateInfoNV::initialize(const VkCudaFunctionCreateInfoNV* in_struct,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pName) delete[] pName;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    module = in_struct->module;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    pName = SafeStringCopy(in_struct->pName);
+}
+
+void safe_VkCudaFunctionCreateInfoNV::initialize(const safe_VkCudaFunctionCreateInfoNV* copy_src,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    module = copy_src->module;
+    pNext = SafePnextCopy(copy_src->pNext);
+    pName = SafeStringCopy(copy_src->pName);
+}
+
+safe_VkCudaLaunchInfoNV::safe_VkCudaLaunchInfoNV(const VkCudaLaunchInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                                 bool copy_pnext)
+    : sType(in_struct->sType),
+      function(in_struct->function),
+      gridDimX(in_struct->gridDimX),
+      gridDimY(in_struct->gridDimY),
+      gridDimZ(in_struct->gridDimZ),
+      blockDimX(in_struct->blockDimX),
+      blockDimY(in_struct->blockDimY),
+      blockDimZ(in_struct->blockDimZ),
+      sharedMemBytes(in_struct->sharedMemBytes),
+      paramCount(in_struct->paramCount),
+      pParams(in_struct->pParams),
+      extraCount(in_struct->extraCount),
+      pExtras(in_struct->pExtras) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkCudaLaunchInfoNV::safe_VkCudaLaunchInfoNV()
+    : sType(VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV),
+      pNext(nullptr),
+      function(),
+      gridDimX(),
+      gridDimY(),
+      gridDimZ(),
+      blockDimX(),
+      blockDimY(),
+      blockDimZ(),
+      sharedMemBytes(),
+      paramCount(),
+      pParams(nullptr),
+      extraCount(),
+      pExtras(nullptr) {}
+
+safe_VkCudaLaunchInfoNV::safe_VkCudaLaunchInfoNV(const safe_VkCudaLaunchInfoNV& copy_src) {
+    sType = copy_src.sType;
+    function = copy_src.function;
+    gridDimX = copy_src.gridDimX;
+    gridDimY = copy_src.gridDimY;
+    gridDimZ = copy_src.gridDimZ;
+    blockDimX = copy_src.blockDimX;
+    blockDimY = copy_src.blockDimY;
+    blockDimZ = copy_src.blockDimZ;
+    sharedMemBytes = copy_src.sharedMemBytes;
+    paramCount = copy_src.paramCount;
+    pParams = copy_src.pParams;
+    extraCount = copy_src.extraCount;
+    pExtras = copy_src.pExtras;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkCudaLaunchInfoNV& safe_VkCudaLaunchInfoNV::operator=(const safe_VkCudaLaunchInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    function = copy_src.function;
+    gridDimX = copy_src.gridDimX;
+    gridDimY = copy_src.gridDimY;
+    gridDimZ = copy_src.gridDimZ;
+    blockDimX = copy_src.blockDimX;
+    blockDimY = copy_src.blockDimY;
+    blockDimZ = copy_src.blockDimZ;
+    sharedMemBytes = copy_src.sharedMemBytes;
+    paramCount = copy_src.paramCount;
+    pParams = copy_src.pParams;
+    extraCount = copy_src.extraCount;
+    pExtras = copy_src.pExtras;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkCudaLaunchInfoNV::~safe_VkCudaLaunchInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkCudaLaunchInfoNV::initialize(const VkCudaLaunchInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    function = in_struct->function;
+    gridDimX = in_struct->gridDimX;
+    gridDimY = in_struct->gridDimY;
+    gridDimZ = in_struct->gridDimZ;
+    blockDimX = in_struct->blockDimX;
+    blockDimY = in_struct->blockDimY;
+    blockDimZ = in_struct->blockDimZ;
+    sharedMemBytes = in_struct->sharedMemBytes;
+    paramCount = in_struct->paramCount;
+    pParams = in_struct->pParams;
+    extraCount = in_struct->extraCount;
+    pExtras = in_struct->pExtras;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkCudaLaunchInfoNV::initialize(const safe_VkCudaLaunchInfoNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    function = copy_src->function;
+    gridDimX = copy_src->gridDimX;
+    gridDimY = copy_src->gridDimY;
+    gridDimZ = copy_src->gridDimZ;
+    blockDimX = copy_src->blockDimX;
+    blockDimY = copy_src->blockDimY;
+    blockDimZ = copy_src->blockDimZ;
+    sharedMemBytes = copy_src->sharedMemBytes;
+    paramCount = copy_src->paramCount;
+    pParams = copy_src->pParams;
+    extraCount = copy_src->extraCount;
+    pExtras = copy_src->pExtras;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV::safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV(
+    const VkPhysicalDeviceCudaKernelLaunchFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), cudaKernelLaunchFeatures(in_struct->cudaKernelLaunchFeatures) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV::safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV), pNext(nullptr), cudaKernelLaunchFeatures() {}
+
+safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV::safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV(
+    const safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    cudaKernelLaunchFeatures = copy_src.cudaKernelLaunchFeatures;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV& safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    cudaKernelLaunchFeatures = copy_src.cudaKernelLaunchFeatures;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV::~safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV::initialize(const VkPhysicalDeviceCudaKernelLaunchFeaturesNV* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    cudaKernelLaunchFeatures = in_struct->cudaKernelLaunchFeatures;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV::initialize(const safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    cudaKernelLaunchFeatures = copy_src->cudaKernelLaunchFeatures;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV::safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV(
+    const VkPhysicalDeviceCudaKernelLaunchPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      computeCapabilityMinor(in_struct->computeCapabilityMinor),
+      computeCapabilityMajor(in_struct->computeCapabilityMajor) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV::safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV),
+      pNext(nullptr),
+      computeCapabilityMinor(),
+      computeCapabilityMajor() {}
+
+safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV::safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV(
+    const safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    computeCapabilityMinor = copy_src.computeCapabilityMinor;
+    computeCapabilityMajor = copy_src.computeCapabilityMajor;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV& safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV::operator=(
+    const safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    computeCapabilityMinor = copy_src.computeCapabilityMinor;
+    computeCapabilityMajor = copy_src.computeCapabilityMajor;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV::~safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV::initialize(const VkPhysicalDeviceCudaKernelLaunchPropertiesNV* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    computeCapabilityMinor = in_struct->computeCapabilityMinor;
+    computeCapabilityMajor = in_struct->computeCapabilityMajor;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV::initialize(
+    const safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    computeCapabilityMinor = copy_src->computeCapabilityMinor;
+    computeCapabilityMajor = copy_src->computeCapabilityMajor;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkQueryLowLatencySupportNV::safe_VkQueryLowLatencySupportNV(const VkQueryLowLatencySupportNV* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), pQueriedLowLatencyData(in_struct->pQueriedLowLatencyData) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkQueryLowLatencySupportNV::safe_VkQueryLowLatencySupportNV()
+    : sType(VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV), pNext(nullptr), pQueriedLowLatencyData(nullptr) {}
+
+safe_VkQueryLowLatencySupportNV::safe_VkQueryLowLatencySupportNV(const safe_VkQueryLowLatencySupportNV& copy_src) {
+    sType = copy_src.sType;
+    pQueriedLowLatencyData = copy_src.pQueriedLowLatencyData;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkQueryLowLatencySupportNV& safe_VkQueryLowLatencySupportNV::operator=(const safe_VkQueryLowLatencySupportNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pQueriedLowLatencyData = copy_src.pQueriedLowLatencyData;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkQueryLowLatencySupportNV::~safe_VkQueryLowLatencySupportNV() { FreePnextChain(pNext); }
+
+void safe_VkQueryLowLatencySupportNV::initialize(const VkQueryLowLatencySupportNV* in_struct,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pQueriedLowLatencyData = in_struct->pQueriedLowLatencyData;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkQueryLowLatencySupportNV::initialize(const safe_VkQueryLowLatencySupportNV* copy_src,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pQueriedLowLatencyData = copy_src->pQueriedLowLatencyData;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD::safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+    const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), shaderEarlyAndLateFragmentTests(in_struct->shaderEarlyAndLateFragmentTests) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD::safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD),
+      pNext(nullptr),
+      shaderEarlyAndLateFragmentTests() {}
+
+safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD::safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+    const safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD& copy_src) {
+    sType = copy_src.sType;
+    shaderEarlyAndLateFragmentTests = copy_src.shaderEarlyAndLateFragmentTests;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD&
+safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD::operator=(
+    const safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderEarlyAndLateFragmentTests = copy_src.shaderEarlyAndLateFragmentTests;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD::
+    ~safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD::initialize(
+    const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderEarlyAndLateFragmentTests = in_struct->shaderEarlyAndLateFragmentTests;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD::initialize(
+    const safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderEarlyAndLateFragmentTests = copy_src->shaderEarlyAndLateFragmentTests;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV::safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
+    const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      fragmentShadingRateEnums(in_struct->fragmentShadingRateEnums),
+      supersampleFragmentShadingRates(in_struct->supersampleFragmentShadingRates),
+      noInvocationFragmentShadingRates(in_struct->noInvocationFragmentShadingRates) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV::safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV),
+      pNext(nullptr),
+      fragmentShadingRateEnums(),
+      supersampleFragmentShadingRates(),
+      noInvocationFragmentShadingRates() {}
+
+safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV::safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
+    const safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    fragmentShadingRateEnums = copy_src.fragmentShadingRateEnums;
+    supersampleFragmentShadingRates = copy_src.supersampleFragmentShadingRates;
+    noInvocationFragmentShadingRates = copy_src.noInvocationFragmentShadingRates;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV& safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    fragmentShadingRateEnums = copy_src.fragmentShadingRateEnums;
+    supersampleFragmentShadingRates = copy_src.supersampleFragmentShadingRates;
+    noInvocationFragmentShadingRates = copy_src.noInvocationFragmentShadingRates;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV::~safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV::initialize(
+    const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    fragmentShadingRateEnums = in_struct->fragmentShadingRateEnums;
+    supersampleFragmentShadingRates = in_struct->supersampleFragmentShadingRates;
+    noInvocationFragmentShadingRates = in_struct->noInvocationFragmentShadingRates;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV::initialize(
+    const safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    fragmentShadingRateEnums = copy_src->fragmentShadingRateEnums;
+    supersampleFragmentShadingRates = copy_src->supersampleFragmentShadingRates;
+    noInvocationFragmentShadingRates = copy_src->noInvocationFragmentShadingRates;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV::safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
+    const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), maxFragmentShadingRateInvocationCount(in_struct->maxFragmentShadingRateInvocationCount) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV::safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV),
+      pNext(nullptr),
+      maxFragmentShadingRateInvocationCount() {}
+
+safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV::safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
+    const safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    maxFragmentShadingRateInvocationCount = copy_src.maxFragmentShadingRateInvocationCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV& safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV::operator=(
+    const safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxFragmentShadingRateInvocationCount = copy_src.maxFragmentShadingRateInvocationCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV::~safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV::initialize(
+    const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxFragmentShadingRateInvocationCount = in_struct->maxFragmentShadingRateInvocationCount;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV::initialize(
+    const safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxFragmentShadingRateInvocationCount = copy_src->maxFragmentShadingRateInvocationCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV::safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
+    const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), shadingRateType(in_struct->shadingRateType), shadingRate(in_struct->shadingRate) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    for (uint32_t i = 0; i < 2; ++i) {
+        combinerOps[i] = in_struct->combinerOps[i];
+    }
+}
+
+safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV::safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV),
+      pNext(nullptr),
+      shadingRateType(),
+      shadingRate() {}
+
+safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV::safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
+    const safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    shadingRateType = copy_src.shadingRateType;
+    shadingRate = copy_src.shadingRate;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < 2; ++i) {
+        combinerOps[i] = copy_src.combinerOps[i];
+    }
+}
+
+safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV& safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV::operator=(
+    const safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shadingRateType = copy_src.shadingRateType;
+    shadingRate = copy_src.shadingRate;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < 2; ++i) {
+        combinerOps[i] = copy_src.combinerOps[i];
+    }
+
+    return *this;
+}
+
+safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV::~safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV::initialize(
+    const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shadingRateType = in_struct->shadingRateType;
+    shadingRate = in_struct->shadingRate;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    for (uint32_t i = 0; i < 2; ++i) {
+        combinerOps[i] = in_struct->combinerOps[i];
+    }
+}
+
+void safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV::initialize(
+    const safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shadingRateType = copy_src->shadingRateType;
+    shadingRate = copy_src->shadingRate;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    for (uint32_t i = 0; i < 2; ++i) {
+        combinerOps[i] = copy_src->combinerOps[i];
+    }
+}
+
+safe_VkAccelerationStructureGeometryMotionTrianglesDataNV::safe_VkAccelerationStructureGeometryMotionTrianglesDataNV(
+    const VkAccelerationStructureGeometryMotionTrianglesDataNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), vertexData(&in_struct->vertexData) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkAccelerationStructureGeometryMotionTrianglesDataNV::safe_VkAccelerationStructureGeometryMotionTrianglesDataNV()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV), pNext(nullptr) {}
+
+safe_VkAccelerationStructureGeometryMotionTrianglesDataNV::safe_VkAccelerationStructureGeometryMotionTrianglesDataNV(
+    const safe_VkAccelerationStructureGeometryMotionTrianglesDataNV& copy_src) {
+    sType = copy_src.sType;
+    vertexData.initialize(&copy_src.vertexData);
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkAccelerationStructureGeometryMotionTrianglesDataNV& safe_VkAccelerationStructureGeometryMotionTrianglesDataNV::operator=(
+    const safe_VkAccelerationStructureGeometryMotionTrianglesDataNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    vertexData.initialize(&copy_src.vertexData);
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkAccelerationStructureGeometryMotionTrianglesDataNV::~safe_VkAccelerationStructureGeometryMotionTrianglesDataNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkAccelerationStructureGeometryMotionTrianglesDataNV::initialize(
+    const VkAccelerationStructureGeometryMotionTrianglesDataNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    vertexData.initialize(&in_struct->vertexData);
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkAccelerationStructureGeometryMotionTrianglesDataNV::initialize(
+    const safe_VkAccelerationStructureGeometryMotionTrianglesDataNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    vertexData.initialize(&copy_src->vertexData);
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkAccelerationStructureMotionInfoNV::safe_VkAccelerationStructureMotionInfoNV(
+    const VkAccelerationStructureMotionInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), maxInstances(in_struct->maxInstances), flags(in_struct->flags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkAccelerationStructureMotionInfoNV::safe_VkAccelerationStructureMotionInfoNV()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV), pNext(nullptr), maxInstances(), flags() {}
+
+safe_VkAccelerationStructureMotionInfoNV::safe_VkAccelerationStructureMotionInfoNV(
+    const safe_VkAccelerationStructureMotionInfoNV& copy_src) {
+    sType = copy_src.sType;
+    maxInstances = copy_src.maxInstances;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkAccelerationStructureMotionInfoNV& safe_VkAccelerationStructureMotionInfoNV::operator=(
+    const safe_VkAccelerationStructureMotionInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxInstances = copy_src.maxInstances;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkAccelerationStructureMotionInfoNV::~safe_VkAccelerationStructureMotionInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkAccelerationStructureMotionInfoNV::initialize(const VkAccelerationStructureMotionInfoNV* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxInstances = in_struct->maxInstances;
+    flags = in_struct->flags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkAccelerationStructureMotionInfoNV::initialize(const safe_VkAccelerationStructureMotionInfoNV* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxInstances = copy_src->maxInstances;
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV::safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
+    const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      rayTracingMotionBlur(in_struct->rayTracingMotionBlur),
+      rayTracingMotionBlurPipelineTraceRaysIndirect(in_struct->rayTracingMotionBlurPipelineTraceRaysIndirect) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV::safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV),
+      pNext(nullptr),
+      rayTracingMotionBlur(),
+      rayTracingMotionBlurPipelineTraceRaysIndirect() {}
+
+safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV::safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
+    const safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    rayTracingMotionBlur = copy_src.rayTracingMotionBlur;
+    rayTracingMotionBlurPipelineTraceRaysIndirect = copy_src.rayTracingMotionBlurPipelineTraceRaysIndirect;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV& safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    rayTracingMotionBlur = copy_src.rayTracingMotionBlur;
+    rayTracingMotionBlurPipelineTraceRaysIndirect = copy_src.rayTracingMotionBlurPipelineTraceRaysIndirect;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV::~safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV::initialize(
+    const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    rayTracingMotionBlur = in_struct->rayTracingMotionBlur;
+    rayTracingMotionBlurPipelineTraceRaysIndirect = in_struct->rayTracingMotionBlurPipelineTraceRaysIndirect;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV::initialize(
+    const safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    rayTracingMotionBlur = copy_src->rayTracingMotionBlur;
+    rayTracingMotionBlurPipelineTraceRaysIndirect = copy_src->rayTracingMotionBlurPipelineTraceRaysIndirect;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkCopyCommandTransformInfoQCOM::safe_VkCopyCommandTransformInfoQCOM(const VkCopyCommandTransformInfoQCOM* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType), transform(in_struct->transform) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkCopyCommandTransformInfoQCOM::safe_VkCopyCommandTransformInfoQCOM()
+    : sType(VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM), pNext(nullptr), transform() {}
+
+safe_VkCopyCommandTransformInfoQCOM::safe_VkCopyCommandTransformInfoQCOM(const safe_VkCopyCommandTransformInfoQCOM& copy_src) {
+    sType = copy_src.sType;
+    transform = copy_src.transform;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkCopyCommandTransformInfoQCOM& safe_VkCopyCommandTransformInfoQCOM::operator=(
+    const safe_VkCopyCommandTransformInfoQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    transform = copy_src.transform;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkCopyCommandTransformInfoQCOM::~safe_VkCopyCommandTransformInfoQCOM() { FreePnextChain(pNext); }
+
+void safe_VkCopyCommandTransformInfoQCOM::initialize(const VkCopyCommandTransformInfoQCOM* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    transform = in_struct->transform;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkCopyCommandTransformInfoQCOM::initialize(const safe_VkCopyCommandTransformInfoQCOM* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    transform = copy_src->transform;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+#ifdef VK_USE_PLATFORM_FUCHSIA
+
+safe_VkImportMemoryZirconHandleInfoFUCHSIA::safe_VkImportMemoryZirconHandleInfoFUCHSIA(
+    const VkImportMemoryZirconHandleInfoFUCHSIA* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), handleType(in_struct->handleType), handle(in_struct->handle) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImportMemoryZirconHandleInfoFUCHSIA::safe_VkImportMemoryZirconHandleInfoFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA), pNext(nullptr), handleType(), handle() {}
+
+safe_VkImportMemoryZirconHandleInfoFUCHSIA::safe_VkImportMemoryZirconHandleInfoFUCHSIA(
+    const safe_VkImportMemoryZirconHandleInfoFUCHSIA& copy_src) {
+    sType = copy_src.sType;
+    handleType = copy_src.handleType;
+    handle = copy_src.handle;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImportMemoryZirconHandleInfoFUCHSIA& safe_VkImportMemoryZirconHandleInfoFUCHSIA::operator=(
+    const safe_VkImportMemoryZirconHandleInfoFUCHSIA& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    handleType = copy_src.handleType;
+    handle = copy_src.handle;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImportMemoryZirconHandleInfoFUCHSIA::~safe_VkImportMemoryZirconHandleInfoFUCHSIA() { FreePnextChain(pNext); }
+
+void safe_VkImportMemoryZirconHandleInfoFUCHSIA::initialize(const VkImportMemoryZirconHandleInfoFUCHSIA* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    handleType = in_struct->handleType;
+    handle = in_struct->handle;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImportMemoryZirconHandleInfoFUCHSIA::initialize(const safe_VkImportMemoryZirconHandleInfoFUCHSIA* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    handleType = copy_src->handleType;
+    handle = copy_src->handle;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkMemoryZirconHandlePropertiesFUCHSIA::safe_VkMemoryZirconHandlePropertiesFUCHSIA(
+    const VkMemoryZirconHandlePropertiesFUCHSIA* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), memoryTypeBits(in_struct->memoryTypeBits) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMemoryZirconHandlePropertiesFUCHSIA::safe_VkMemoryZirconHandlePropertiesFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA), pNext(nullptr), memoryTypeBits() {}
+
+safe_VkMemoryZirconHandlePropertiesFUCHSIA::safe_VkMemoryZirconHandlePropertiesFUCHSIA(
+    const safe_VkMemoryZirconHandlePropertiesFUCHSIA& copy_src) {
+    sType = copy_src.sType;
+    memoryTypeBits = copy_src.memoryTypeBits;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMemoryZirconHandlePropertiesFUCHSIA& safe_VkMemoryZirconHandlePropertiesFUCHSIA::operator=(
+    const safe_VkMemoryZirconHandlePropertiesFUCHSIA& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    memoryTypeBits = copy_src.memoryTypeBits;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMemoryZirconHandlePropertiesFUCHSIA::~safe_VkMemoryZirconHandlePropertiesFUCHSIA() { FreePnextChain(pNext); }
+
+void safe_VkMemoryZirconHandlePropertiesFUCHSIA::initialize(const VkMemoryZirconHandlePropertiesFUCHSIA* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    memoryTypeBits = in_struct->memoryTypeBits;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMemoryZirconHandlePropertiesFUCHSIA::initialize(const safe_VkMemoryZirconHandlePropertiesFUCHSIA* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memoryTypeBits = copy_src->memoryTypeBits;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkMemoryGetZirconHandleInfoFUCHSIA::safe_VkMemoryGetZirconHandleInfoFUCHSIA(
+    const VkMemoryGetZirconHandleInfoFUCHSIA* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), memory(in_struct->memory), handleType(in_struct->handleType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMemoryGetZirconHandleInfoFUCHSIA::safe_VkMemoryGetZirconHandleInfoFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA), pNext(nullptr), memory(), handleType() {}
+
+safe_VkMemoryGetZirconHandleInfoFUCHSIA::safe_VkMemoryGetZirconHandleInfoFUCHSIA(
+    const safe_VkMemoryGetZirconHandleInfoFUCHSIA& copy_src) {
+    sType = copy_src.sType;
+    memory = copy_src.memory;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMemoryGetZirconHandleInfoFUCHSIA& safe_VkMemoryGetZirconHandleInfoFUCHSIA::operator=(
+    const safe_VkMemoryGetZirconHandleInfoFUCHSIA& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    memory = copy_src.memory;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMemoryGetZirconHandleInfoFUCHSIA::~safe_VkMemoryGetZirconHandleInfoFUCHSIA() { FreePnextChain(pNext); }
+
+void safe_VkMemoryGetZirconHandleInfoFUCHSIA::initialize(const VkMemoryGetZirconHandleInfoFUCHSIA* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    memory = in_struct->memory;
+    handleType = in_struct->handleType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMemoryGetZirconHandleInfoFUCHSIA::initialize(const safe_VkMemoryGetZirconHandleInfoFUCHSIA* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memory = copy_src->memory;
+    handleType = copy_src->handleType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkImportSemaphoreZirconHandleInfoFUCHSIA::safe_VkImportSemaphoreZirconHandleInfoFUCHSIA(
+    const VkImportSemaphoreZirconHandleInfoFUCHSIA* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      semaphore(in_struct->semaphore),
+      flags(in_struct->flags),
+      handleType(in_struct->handleType),
+      zirconHandle(in_struct->zirconHandle) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImportSemaphoreZirconHandleInfoFUCHSIA::safe_VkImportSemaphoreZirconHandleInfoFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA),
+      pNext(nullptr),
+      semaphore(),
+      flags(),
+      handleType(),
+      zirconHandle() {}
+
+safe_VkImportSemaphoreZirconHandleInfoFUCHSIA::safe_VkImportSemaphoreZirconHandleInfoFUCHSIA(
+    const safe_VkImportSemaphoreZirconHandleInfoFUCHSIA& copy_src) {
+    sType = copy_src.sType;
+    semaphore = copy_src.semaphore;
+    flags = copy_src.flags;
+    handleType = copy_src.handleType;
+    zirconHandle = copy_src.zirconHandle;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImportSemaphoreZirconHandleInfoFUCHSIA& safe_VkImportSemaphoreZirconHandleInfoFUCHSIA::operator=(
+    const safe_VkImportSemaphoreZirconHandleInfoFUCHSIA& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    semaphore = copy_src.semaphore;
+    flags = copy_src.flags;
+    handleType = copy_src.handleType;
+    zirconHandle = copy_src.zirconHandle;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImportSemaphoreZirconHandleInfoFUCHSIA::~safe_VkImportSemaphoreZirconHandleInfoFUCHSIA() { FreePnextChain(pNext); }
+
+void safe_VkImportSemaphoreZirconHandleInfoFUCHSIA::initialize(const VkImportSemaphoreZirconHandleInfoFUCHSIA* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    semaphore = in_struct->semaphore;
+    flags = in_struct->flags;
+    handleType = in_struct->handleType;
+    zirconHandle = in_struct->zirconHandle;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImportSemaphoreZirconHandleInfoFUCHSIA::initialize(const safe_VkImportSemaphoreZirconHandleInfoFUCHSIA* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    semaphore = copy_src->semaphore;
+    flags = copy_src->flags;
+    handleType = copy_src->handleType;
+    zirconHandle = copy_src->zirconHandle;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSemaphoreGetZirconHandleInfoFUCHSIA::safe_VkSemaphoreGetZirconHandleInfoFUCHSIA(
+    const VkSemaphoreGetZirconHandleInfoFUCHSIA* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), semaphore(in_struct->semaphore), handleType(in_struct->handleType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSemaphoreGetZirconHandleInfoFUCHSIA::safe_VkSemaphoreGetZirconHandleInfoFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA), pNext(nullptr), semaphore(), handleType() {}
+
+safe_VkSemaphoreGetZirconHandleInfoFUCHSIA::safe_VkSemaphoreGetZirconHandleInfoFUCHSIA(
+    const safe_VkSemaphoreGetZirconHandleInfoFUCHSIA& copy_src) {
+    sType = copy_src.sType;
+    semaphore = copy_src.semaphore;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSemaphoreGetZirconHandleInfoFUCHSIA& safe_VkSemaphoreGetZirconHandleInfoFUCHSIA::operator=(
+    const safe_VkSemaphoreGetZirconHandleInfoFUCHSIA& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    semaphore = copy_src.semaphore;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSemaphoreGetZirconHandleInfoFUCHSIA::~safe_VkSemaphoreGetZirconHandleInfoFUCHSIA() { FreePnextChain(pNext); }
+
+void safe_VkSemaphoreGetZirconHandleInfoFUCHSIA::initialize(const VkSemaphoreGetZirconHandleInfoFUCHSIA* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    semaphore = in_struct->semaphore;
+    handleType = in_struct->handleType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSemaphoreGetZirconHandleInfoFUCHSIA::initialize(const safe_VkSemaphoreGetZirconHandleInfoFUCHSIA* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    semaphore = copy_src->semaphore;
+    handleType = copy_src->handleType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkBufferCollectionCreateInfoFUCHSIA::safe_VkBufferCollectionCreateInfoFUCHSIA(
+    const VkBufferCollectionCreateInfoFUCHSIA* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), collectionToken(in_struct->collectionToken) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkBufferCollectionCreateInfoFUCHSIA::safe_VkBufferCollectionCreateInfoFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA), pNext(nullptr), collectionToken() {}
+
+safe_VkBufferCollectionCreateInfoFUCHSIA::safe_VkBufferCollectionCreateInfoFUCHSIA(
+    const safe_VkBufferCollectionCreateInfoFUCHSIA& copy_src) {
+    sType = copy_src.sType;
+    collectionToken = copy_src.collectionToken;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBufferCollectionCreateInfoFUCHSIA& safe_VkBufferCollectionCreateInfoFUCHSIA::operator=(
+    const safe_VkBufferCollectionCreateInfoFUCHSIA& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    collectionToken = copy_src.collectionToken;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkBufferCollectionCreateInfoFUCHSIA::~safe_VkBufferCollectionCreateInfoFUCHSIA() { FreePnextChain(pNext); }
+
+void safe_VkBufferCollectionCreateInfoFUCHSIA::initialize(const VkBufferCollectionCreateInfoFUCHSIA* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    collectionToken = in_struct->collectionToken;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkBufferCollectionCreateInfoFUCHSIA::initialize(const safe_VkBufferCollectionCreateInfoFUCHSIA* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    collectionToken = copy_src->collectionToken;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkImportMemoryBufferCollectionFUCHSIA::safe_VkImportMemoryBufferCollectionFUCHSIA(
+    const VkImportMemoryBufferCollectionFUCHSIA* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), collection(in_struct->collection), index(in_struct->index) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImportMemoryBufferCollectionFUCHSIA::safe_VkImportMemoryBufferCollectionFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA), pNext(nullptr), collection(), index() {}
+
+safe_VkImportMemoryBufferCollectionFUCHSIA::safe_VkImportMemoryBufferCollectionFUCHSIA(
+    const safe_VkImportMemoryBufferCollectionFUCHSIA& copy_src) {
+    sType = copy_src.sType;
+    collection = copy_src.collection;
+    index = copy_src.index;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImportMemoryBufferCollectionFUCHSIA& safe_VkImportMemoryBufferCollectionFUCHSIA::operator=(
+    const safe_VkImportMemoryBufferCollectionFUCHSIA& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    collection = copy_src.collection;
+    index = copy_src.index;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImportMemoryBufferCollectionFUCHSIA::~safe_VkImportMemoryBufferCollectionFUCHSIA() { FreePnextChain(pNext); }
+
+void safe_VkImportMemoryBufferCollectionFUCHSIA::initialize(const VkImportMemoryBufferCollectionFUCHSIA* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    collection = in_struct->collection;
+    index = in_struct->index;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImportMemoryBufferCollectionFUCHSIA::initialize(const safe_VkImportMemoryBufferCollectionFUCHSIA* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    collection = copy_src->collection;
+    index = copy_src->index;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkBufferCollectionImageCreateInfoFUCHSIA::safe_VkBufferCollectionImageCreateInfoFUCHSIA(
+    const VkBufferCollectionImageCreateInfoFUCHSIA* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), collection(in_struct->collection), index(in_struct->index) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkBufferCollectionImageCreateInfoFUCHSIA::safe_VkBufferCollectionImageCreateInfoFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA), pNext(nullptr), collection(), index() {}
+
+safe_VkBufferCollectionImageCreateInfoFUCHSIA::safe_VkBufferCollectionImageCreateInfoFUCHSIA(
+    const safe_VkBufferCollectionImageCreateInfoFUCHSIA& copy_src) {
+    sType = copy_src.sType;
+    collection = copy_src.collection;
+    index = copy_src.index;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBufferCollectionImageCreateInfoFUCHSIA& safe_VkBufferCollectionImageCreateInfoFUCHSIA::operator=(
+    const safe_VkBufferCollectionImageCreateInfoFUCHSIA& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    collection = copy_src.collection;
+    index = copy_src.index;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkBufferCollectionImageCreateInfoFUCHSIA::~safe_VkBufferCollectionImageCreateInfoFUCHSIA() { FreePnextChain(pNext); }
+
+void safe_VkBufferCollectionImageCreateInfoFUCHSIA::initialize(const VkBufferCollectionImageCreateInfoFUCHSIA* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    collection = in_struct->collection;
+    index = in_struct->index;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkBufferCollectionImageCreateInfoFUCHSIA::initialize(const safe_VkBufferCollectionImageCreateInfoFUCHSIA* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    collection = copy_src->collection;
+    index = copy_src->index;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkBufferCollectionConstraintsInfoFUCHSIA::safe_VkBufferCollectionConstraintsInfoFUCHSIA(
+    const VkBufferCollectionConstraintsInfoFUCHSIA* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      minBufferCount(in_struct->minBufferCount),
+      maxBufferCount(in_struct->maxBufferCount),
+      minBufferCountForCamping(in_struct->minBufferCountForCamping),
+      minBufferCountForDedicatedSlack(in_struct->minBufferCountForDedicatedSlack),
+      minBufferCountForSharedSlack(in_struct->minBufferCountForSharedSlack) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkBufferCollectionConstraintsInfoFUCHSIA::safe_VkBufferCollectionConstraintsInfoFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA),
+      pNext(nullptr),
+      minBufferCount(),
+      maxBufferCount(),
+      minBufferCountForCamping(),
+      minBufferCountForDedicatedSlack(),
+      minBufferCountForSharedSlack() {}
+
+safe_VkBufferCollectionConstraintsInfoFUCHSIA::safe_VkBufferCollectionConstraintsInfoFUCHSIA(
+    const safe_VkBufferCollectionConstraintsInfoFUCHSIA& copy_src) {
+    sType = copy_src.sType;
+    minBufferCount = copy_src.minBufferCount;
+    maxBufferCount = copy_src.maxBufferCount;
+    minBufferCountForCamping = copy_src.minBufferCountForCamping;
+    minBufferCountForDedicatedSlack = copy_src.minBufferCountForDedicatedSlack;
+    minBufferCountForSharedSlack = copy_src.minBufferCountForSharedSlack;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBufferCollectionConstraintsInfoFUCHSIA& safe_VkBufferCollectionConstraintsInfoFUCHSIA::operator=(
+    const safe_VkBufferCollectionConstraintsInfoFUCHSIA& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    minBufferCount = copy_src.minBufferCount;
+    maxBufferCount = copy_src.maxBufferCount;
+    minBufferCountForCamping = copy_src.minBufferCountForCamping;
+    minBufferCountForDedicatedSlack = copy_src.minBufferCountForDedicatedSlack;
+    minBufferCountForSharedSlack = copy_src.minBufferCountForSharedSlack;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkBufferCollectionConstraintsInfoFUCHSIA::~safe_VkBufferCollectionConstraintsInfoFUCHSIA() { FreePnextChain(pNext); }
+
+void safe_VkBufferCollectionConstraintsInfoFUCHSIA::initialize(const VkBufferCollectionConstraintsInfoFUCHSIA* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    minBufferCount = in_struct->minBufferCount;
+    maxBufferCount = in_struct->maxBufferCount;
+    minBufferCountForCamping = in_struct->minBufferCountForCamping;
+    minBufferCountForDedicatedSlack = in_struct->minBufferCountForDedicatedSlack;
+    minBufferCountForSharedSlack = in_struct->minBufferCountForSharedSlack;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkBufferCollectionConstraintsInfoFUCHSIA::initialize(const safe_VkBufferCollectionConstraintsInfoFUCHSIA* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    minBufferCount = copy_src->minBufferCount;
+    maxBufferCount = copy_src->maxBufferCount;
+    minBufferCountForCamping = copy_src->minBufferCountForCamping;
+    minBufferCountForDedicatedSlack = copy_src->minBufferCountForDedicatedSlack;
+    minBufferCountForSharedSlack = copy_src->minBufferCountForSharedSlack;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkBufferConstraintsInfoFUCHSIA::safe_VkBufferConstraintsInfoFUCHSIA(const VkBufferConstraintsInfoFUCHSIA* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType),
+      createInfo(&in_struct->createInfo),
+      requiredFormatFeatures(in_struct->requiredFormatFeatures),
+      bufferCollectionConstraints(&in_struct->bufferCollectionConstraints) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkBufferConstraintsInfoFUCHSIA::safe_VkBufferConstraintsInfoFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA), pNext(nullptr), requiredFormatFeatures() {}
+
+safe_VkBufferConstraintsInfoFUCHSIA::safe_VkBufferConstraintsInfoFUCHSIA(const safe_VkBufferConstraintsInfoFUCHSIA& copy_src) {
+    sType = copy_src.sType;
+    createInfo.initialize(&copy_src.createInfo);
+    requiredFormatFeatures = copy_src.requiredFormatFeatures;
+    bufferCollectionConstraints.initialize(&copy_src.bufferCollectionConstraints);
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBufferConstraintsInfoFUCHSIA& safe_VkBufferConstraintsInfoFUCHSIA::operator=(
+    const safe_VkBufferConstraintsInfoFUCHSIA& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    createInfo.initialize(&copy_src.createInfo);
+    requiredFormatFeatures = copy_src.requiredFormatFeatures;
+    bufferCollectionConstraints.initialize(&copy_src.bufferCollectionConstraints);
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkBufferConstraintsInfoFUCHSIA::~safe_VkBufferConstraintsInfoFUCHSIA() { FreePnextChain(pNext); }
+
+void safe_VkBufferConstraintsInfoFUCHSIA::initialize(const VkBufferConstraintsInfoFUCHSIA* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    createInfo.initialize(&in_struct->createInfo);
+    requiredFormatFeatures = in_struct->requiredFormatFeatures;
+    bufferCollectionConstraints.initialize(&in_struct->bufferCollectionConstraints);
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkBufferConstraintsInfoFUCHSIA::initialize(const safe_VkBufferConstraintsInfoFUCHSIA* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    createInfo.initialize(&copy_src->createInfo);
+    requiredFormatFeatures = copy_src->requiredFormatFeatures;
+    bufferCollectionConstraints.initialize(&copy_src->bufferCollectionConstraints);
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkBufferCollectionBufferCreateInfoFUCHSIA::safe_VkBufferCollectionBufferCreateInfoFUCHSIA(
+    const VkBufferCollectionBufferCreateInfoFUCHSIA* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), collection(in_struct->collection), index(in_struct->index) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkBufferCollectionBufferCreateInfoFUCHSIA::safe_VkBufferCollectionBufferCreateInfoFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA), pNext(nullptr), collection(), index() {}
+
+safe_VkBufferCollectionBufferCreateInfoFUCHSIA::safe_VkBufferCollectionBufferCreateInfoFUCHSIA(
+    const safe_VkBufferCollectionBufferCreateInfoFUCHSIA& copy_src) {
+    sType = copy_src.sType;
+    collection = copy_src.collection;
+    index = copy_src.index;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBufferCollectionBufferCreateInfoFUCHSIA& safe_VkBufferCollectionBufferCreateInfoFUCHSIA::operator=(
+    const safe_VkBufferCollectionBufferCreateInfoFUCHSIA& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    collection = copy_src.collection;
+    index = copy_src.index;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkBufferCollectionBufferCreateInfoFUCHSIA::~safe_VkBufferCollectionBufferCreateInfoFUCHSIA() { FreePnextChain(pNext); }
+
+void safe_VkBufferCollectionBufferCreateInfoFUCHSIA::initialize(const VkBufferCollectionBufferCreateInfoFUCHSIA* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    collection = in_struct->collection;
+    index = in_struct->index;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkBufferCollectionBufferCreateInfoFUCHSIA::initialize(const safe_VkBufferCollectionBufferCreateInfoFUCHSIA* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    collection = copy_src->collection;
+    index = copy_src->index;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSysmemColorSpaceFUCHSIA::safe_VkSysmemColorSpaceFUCHSIA(const VkSysmemColorSpaceFUCHSIA* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), colorSpace(in_struct->colorSpace) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSysmemColorSpaceFUCHSIA::safe_VkSysmemColorSpaceFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA), pNext(nullptr), colorSpace() {}
+
+safe_VkSysmemColorSpaceFUCHSIA::safe_VkSysmemColorSpaceFUCHSIA(const safe_VkSysmemColorSpaceFUCHSIA& copy_src) {
+    sType = copy_src.sType;
+    colorSpace = copy_src.colorSpace;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSysmemColorSpaceFUCHSIA& safe_VkSysmemColorSpaceFUCHSIA::operator=(const safe_VkSysmemColorSpaceFUCHSIA& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    colorSpace = copy_src.colorSpace;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSysmemColorSpaceFUCHSIA::~safe_VkSysmemColorSpaceFUCHSIA() { FreePnextChain(pNext); }
+
+void safe_VkSysmemColorSpaceFUCHSIA::initialize(const VkSysmemColorSpaceFUCHSIA* in_struct,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    colorSpace = in_struct->colorSpace;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSysmemColorSpaceFUCHSIA::initialize(const safe_VkSysmemColorSpaceFUCHSIA* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    colorSpace = copy_src->colorSpace;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkBufferCollectionPropertiesFUCHSIA::safe_VkBufferCollectionPropertiesFUCHSIA(
+    const VkBufferCollectionPropertiesFUCHSIA* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      memoryTypeBits(in_struct->memoryTypeBits),
+      bufferCount(in_struct->bufferCount),
+      createInfoIndex(in_struct->createInfoIndex),
+      sysmemPixelFormat(in_struct->sysmemPixelFormat),
+      formatFeatures(in_struct->formatFeatures),
+      sysmemColorSpaceIndex(&in_struct->sysmemColorSpaceIndex),
+      samplerYcbcrConversionComponents(in_struct->samplerYcbcrConversionComponents),
+      suggestedYcbcrModel(in_struct->suggestedYcbcrModel),
+      suggestedYcbcrRange(in_struct->suggestedYcbcrRange),
+      suggestedXChromaOffset(in_struct->suggestedXChromaOffset),
+      suggestedYChromaOffset(in_struct->suggestedYChromaOffset) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkBufferCollectionPropertiesFUCHSIA::safe_VkBufferCollectionPropertiesFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA),
+      pNext(nullptr),
+      memoryTypeBits(),
+      bufferCount(),
+      createInfoIndex(),
+      sysmemPixelFormat(),
+      formatFeatures(),
+      samplerYcbcrConversionComponents(),
+      suggestedYcbcrModel(),
+      suggestedYcbcrRange(),
+      suggestedXChromaOffset(),
+      suggestedYChromaOffset() {}
+
+safe_VkBufferCollectionPropertiesFUCHSIA::safe_VkBufferCollectionPropertiesFUCHSIA(
+    const safe_VkBufferCollectionPropertiesFUCHSIA& copy_src) {
+    sType = copy_src.sType;
+    memoryTypeBits = copy_src.memoryTypeBits;
+    bufferCount = copy_src.bufferCount;
+    createInfoIndex = copy_src.createInfoIndex;
+    sysmemPixelFormat = copy_src.sysmemPixelFormat;
+    formatFeatures = copy_src.formatFeatures;
+    sysmemColorSpaceIndex.initialize(&copy_src.sysmemColorSpaceIndex);
+    samplerYcbcrConversionComponents = copy_src.samplerYcbcrConversionComponents;
+    suggestedYcbcrModel = copy_src.suggestedYcbcrModel;
+    suggestedYcbcrRange = copy_src.suggestedYcbcrRange;
+    suggestedXChromaOffset = copy_src.suggestedXChromaOffset;
+    suggestedYChromaOffset = copy_src.suggestedYChromaOffset;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBufferCollectionPropertiesFUCHSIA& safe_VkBufferCollectionPropertiesFUCHSIA::operator=(
+    const safe_VkBufferCollectionPropertiesFUCHSIA& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    memoryTypeBits = copy_src.memoryTypeBits;
+    bufferCount = copy_src.bufferCount;
+    createInfoIndex = copy_src.createInfoIndex;
+    sysmemPixelFormat = copy_src.sysmemPixelFormat;
+    formatFeatures = copy_src.formatFeatures;
+    sysmemColorSpaceIndex.initialize(&copy_src.sysmemColorSpaceIndex);
+    samplerYcbcrConversionComponents = copy_src.samplerYcbcrConversionComponents;
+    suggestedYcbcrModel = copy_src.suggestedYcbcrModel;
+    suggestedYcbcrRange = copy_src.suggestedYcbcrRange;
+    suggestedXChromaOffset = copy_src.suggestedXChromaOffset;
+    suggestedYChromaOffset = copy_src.suggestedYChromaOffset;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkBufferCollectionPropertiesFUCHSIA::~safe_VkBufferCollectionPropertiesFUCHSIA() { FreePnextChain(pNext); }
+
+void safe_VkBufferCollectionPropertiesFUCHSIA::initialize(const VkBufferCollectionPropertiesFUCHSIA* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    memoryTypeBits = in_struct->memoryTypeBits;
+    bufferCount = in_struct->bufferCount;
+    createInfoIndex = in_struct->createInfoIndex;
+    sysmemPixelFormat = in_struct->sysmemPixelFormat;
+    formatFeatures = in_struct->formatFeatures;
+    sysmemColorSpaceIndex.initialize(&in_struct->sysmemColorSpaceIndex);
+    samplerYcbcrConversionComponents = in_struct->samplerYcbcrConversionComponents;
+    suggestedYcbcrModel = in_struct->suggestedYcbcrModel;
+    suggestedYcbcrRange = in_struct->suggestedYcbcrRange;
+    suggestedXChromaOffset = in_struct->suggestedXChromaOffset;
+    suggestedYChromaOffset = in_struct->suggestedYChromaOffset;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkBufferCollectionPropertiesFUCHSIA::initialize(const safe_VkBufferCollectionPropertiesFUCHSIA* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memoryTypeBits = copy_src->memoryTypeBits;
+    bufferCount = copy_src->bufferCount;
+    createInfoIndex = copy_src->createInfoIndex;
+    sysmemPixelFormat = copy_src->sysmemPixelFormat;
+    formatFeatures = copy_src->formatFeatures;
+    sysmemColorSpaceIndex.initialize(&copy_src->sysmemColorSpaceIndex);
+    samplerYcbcrConversionComponents = copy_src->samplerYcbcrConversionComponents;
+    suggestedYcbcrModel = copy_src->suggestedYcbcrModel;
+    suggestedYcbcrRange = copy_src->suggestedYcbcrRange;
+    suggestedXChromaOffset = copy_src->suggestedXChromaOffset;
+    suggestedYChromaOffset = copy_src->suggestedYChromaOffset;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkImageFormatConstraintsInfoFUCHSIA::safe_VkImageFormatConstraintsInfoFUCHSIA(
+    const VkImageFormatConstraintsInfoFUCHSIA* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      imageCreateInfo(&in_struct->imageCreateInfo),
+      requiredFormatFeatures(in_struct->requiredFormatFeatures),
+      flags(in_struct->flags),
+      sysmemPixelFormat(in_struct->sysmemPixelFormat),
+      colorSpaceCount(in_struct->colorSpaceCount),
+      pColorSpaces(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (colorSpaceCount && in_struct->pColorSpaces) {
+        pColorSpaces = new safe_VkSysmemColorSpaceFUCHSIA[colorSpaceCount];
+        for (uint32_t i = 0; i < colorSpaceCount; ++i) {
+            pColorSpaces[i].initialize(&in_struct->pColorSpaces[i]);
+        }
+    }
+}
+
+safe_VkImageFormatConstraintsInfoFUCHSIA::safe_VkImageFormatConstraintsInfoFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA),
+      pNext(nullptr),
+      requiredFormatFeatures(),
+      flags(),
+      sysmemPixelFormat(),
+      colorSpaceCount(),
+      pColorSpaces(nullptr) {}
+
+safe_VkImageFormatConstraintsInfoFUCHSIA::safe_VkImageFormatConstraintsInfoFUCHSIA(
+    const safe_VkImageFormatConstraintsInfoFUCHSIA& copy_src) {
+    sType = copy_src.sType;
+    imageCreateInfo.initialize(&copy_src.imageCreateInfo);
+    requiredFormatFeatures = copy_src.requiredFormatFeatures;
+    flags = copy_src.flags;
+    sysmemPixelFormat = copy_src.sysmemPixelFormat;
+    colorSpaceCount = copy_src.colorSpaceCount;
+    pColorSpaces = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (colorSpaceCount && copy_src.pColorSpaces) {
+        pColorSpaces = new safe_VkSysmemColorSpaceFUCHSIA[colorSpaceCount];
+        for (uint32_t i = 0; i < colorSpaceCount; ++i) {
+            pColorSpaces[i].initialize(&copy_src.pColorSpaces[i]);
+        }
+    }
+}
+
+safe_VkImageFormatConstraintsInfoFUCHSIA& safe_VkImageFormatConstraintsInfoFUCHSIA::operator=(
+    const safe_VkImageFormatConstraintsInfoFUCHSIA& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pColorSpaces) delete[] pColorSpaces;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    imageCreateInfo.initialize(&copy_src.imageCreateInfo);
+    requiredFormatFeatures = copy_src.requiredFormatFeatures;
+    flags = copy_src.flags;
+    sysmemPixelFormat = copy_src.sysmemPixelFormat;
+    colorSpaceCount = copy_src.colorSpaceCount;
+    pColorSpaces = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (colorSpaceCount && copy_src.pColorSpaces) {
+        pColorSpaces = new safe_VkSysmemColorSpaceFUCHSIA[colorSpaceCount];
+        for (uint32_t i = 0; i < colorSpaceCount; ++i) {
+            pColorSpaces[i].initialize(&copy_src.pColorSpaces[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkImageFormatConstraintsInfoFUCHSIA::~safe_VkImageFormatConstraintsInfoFUCHSIA() {
+    if (pColorSpaces) delete[] pColorSpaces;
+    FreePnextChain(pNext);
+}
+
+void safe_VkImageFormatConstraintsInfoFUCHSIA::initialize(const VkImageFormatConstraintsInfoFUCHSIA* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pColorSpaces) delete[] pColorSpaces;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    imageCreateInfo.initialize(&in_struct->imageCreateInfo);
+    requiredFormatFeatures = in_struct->requiredFormatFeatures;
+    flags = in_struct->flags;
+    sysmemPixelFormat = in_struct->sysmemPixelFormat;
+    colorSpaceCount = in_struct->colorSpaceCount;
+    pColorSpaces = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (colorSpaceCount && in_struct->pColorSpaces) {
+        pColorSpaces = new safe_VkSysmemColorSpaceFUCHSIA[colorSpaceCount];
+        for (uint32_t i = 0; i < colorSpaceCount; ++i) {
+            pColorSpaces[i].initialize(&in_struct->pColorSpaces[i]);
+        }
+    }
+}
+
+void safe_VkImageFormatConstraintsInfoFUCHSIA::initialize(const safe_VkImageFormatConstraintsInfoFUCHSIA* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imageCreateInfo.initialize(&copy_src->imageCreateInfo);
+    requiredFormatFeatures = copy_src->requiredFormatFeatures;
+    flags = copy_src->flags;
+    sysmemPixelFormat = copy_src->sysmemPixelFormat;
+    colorSpaceCount = copy_src->colorSpaceCount;
+    pColorSpaces = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (colorSpaceCount && copy_src->pColorSpaces) {
+        pColorSpaces = new safe_VkSysmemColorSpaceFUCHSIA[colorSpaceCount];
+        for (uint32_t i = 0; i < colorSpaceCount; ++i) {
+            pColorSpaces[i].initialize(&copy_src->pColorSpaces[i]);
+        }
+    }
+}
+
+safe_VkImageConstraintsInfoFUCHSIA::safe_VkImageConstraintsInfoFUCHSIA(const VkImageConstraintsInfoFUCHSIA* in_struct,
+                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      formatConstraintsCount(in_struct->formatConstraintsCount),
+      pFormatConstraints(nullptr),
+      bufferCollectionConstraints(&in_struct->bufferCollectionConstraints),
+      flags(in_struct->flags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (formatConstraintsCount && in_struct->pFormatConstraints) {
+        pFormatConstraints = new safe_VkImageFormatConstraintsInfoFUCHSIA[formatConstraintsCount];
+        for (uint32_t i = 0; i < formatConstraintsCount; ++i) {
+            pFormatConstraints[i].initialize(&in_struct->pFormatConstraints[i]);
+        }
+    }
+}
+
+safe_VkImageConstraintsInfoFUCHSIA::safe_VkImageConstraintsInfoFUCHSIA()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA),
+      pNext(nullptr),
+      formatConstraintsCount(),
+      pFormatConstraints(nullptr),
+      flags() {}
+
+safe_VkImageConstraintsInfoFUCHSIA::safe_VkImageConstraintsInfoFUCHSIA(const safe_VkImageConstraintsInfoFUCHSIA& copy_src) {
+    sType = copy_src.sType;
+    formatConstraintsCount = copy_src.formatConstraintsCount;
+    pFormatConstraints = nullptr;
+    bufferCollectionConstraints.initialize(&copy_src.bufferCollectionConstraints);
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (formatConstraintsCount && copy_src.pFormatConstraints) {
+        pFormatConstraints = new safe_VkImageFormatConstraintsInfoFUCHSIA[formatConstraintsCount];
+        for (uint32_t i = 0; i < formatConstraintsCount; ++i) {
+            pFormatConstraints[i].initialize(&copy_src.pFormatConstraints[i]);
+        }
+    }
+}
+
+safe_VkImageConstraintsInfoFUCHSIA& safe_VkImageConstraintsInfoFUCHSIA::operator=(
+    const safe_VkImageConstraintsInfoFUCHSIA& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pFormatConstraints) delete[] pFormatConstraints;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    formatConstraintsCount = copy_src.formatConstraintsCount;
+    pFormatConstraints = nullptr;
+    bufferCollectionConstraints.initialize(&copy_src.bufferCollectionConstraints);
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (formatConstraintsCount && copy_src.pFormatConstraints) {
+        pFormatConstraints = new safe_VkImageFormatConstraintsInfoFUCHSIA[formatConstraintsCount];
+        for (uint32_t i = 0; i < formatConstraintsCount; ++i) {
+            pFormatConstraints[i].initialize(&copy_src.pFormatConstraints[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkImageConstraintsInfoFUCHSIA::~safe_VkImageConstraintsInfoFUCHSIA() {
+    if (pFormatConstraints) delete[] pFormatConstraints;
+    FreePnextChain(pNext);
+}
+
+void safe_VkImageConstraintsInfoFUCHSIA::initialize(const VkImageConstraintsInfoFUCHSIA* in_struct,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pFormatConstraints) delete[] pFormatConstraints;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    formatConstraintsCount = in_struct->formatConstraintsCount;
+    pFormatConstraints = nullptr;
+    bufferCollectionConstraints.initialize(&in_struct->bufferCollectionConstraints);
+    flags = in_struct->flags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (formatConstraintsCount && in_struct->pFormatConstraints) {
+        pFormatConstraints = new safe_VkImageFormatConstraintsInfoFUCHSIA[formatConstraintsCount];
+        for (uint32_t i = 0; i < formatConstraintsCount; ++i) {
+            pFormatConstraints[i].initialize(&in_struct->pFormatConstraints[i]);
+        }
+    }
+}
+
+void safe_VkImageConstraintsInfoFUCHSIA::initialize(const safe_VkImageConstraintsInfoFUCHSIA* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    formatConstraintsCount = copy_src->formatConstraintsCount;
+    pFormatConstraints = nullptr;
+    bufferCollectionConstraints.initialize(&copy_src->bufferCollectionConstraints);
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (formatConstraintsCount && copy_src->pFormatConstraints) {
+        pFormatConstraints = new safe_VkImageFormatConstraintsInfoFUCHSIA[formatConstraintsCount];
+        for (uint32_t i = 0; i < formatConstraintsCount; ++i) {
+            pFormatConstraints[i].initialize(&copy_src->pFormatConstraints[i]);
+        }
+    }
+}
+#endif  // VK_USE_PLATFORM_FUCHSIA
+
+safe_VkSubpassShadingPipelineCreateInfoHUAWEI::safe_VkSubpassShadingPipelineCreateInfoHUAWEI(
+    const VkSubpassShadingPipelineCreateInfoHUAWEI* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), renderPass(in_struct->renderPass), subpass(in_struct->subpass) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSubpassShadingPipelineCreateInfoHUAWEI::safe_VkSubpassShadingPipelineCreateInfoHUAWEI()
+    : sType(VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI), pNext(nullptr), renderPass(), subpass() {}
+
+safe_VkSubpassShadingPipelineCreateInfoHUAWEI::safe_VkSubpassShadingPipelineCreateInfoHUAWEI(
+    const safe_VkSubpassShadingPipelineCreateInfoHUAWEI& copy_src) {
+    sType = copy_src.sType;
+    renderPass = copy_src.renderPass;
+    subpass = copy_src.subpass;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSubpassShadingPipelineCreateInfoHUAWEI& safe_VkSubpassShadingPipelineCreateInfoHUAWEI::operator=(
+    const safe_VkSubpassShadingPipelineCreateInfoHUAWEI& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    renderPass = copy_src.renderPass;
+    subpass = copy_src.subpass;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSubpassShadingPipelineCreateInfoHUAWEI::~safe_VkSubpassShadingPipelineCreateInfoHUAWEI() { FreePnextChain(pNext); }
+
+void safe_VkSubpassShadingPipelineCreateInfoHUAWEI::initialize(const VkSubpassShadingPipelineCreateInfoHUAWEI* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    renderPass = in_struct->renderPass;
+    subpass = in_struct->subpass;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSubpassShadingPipelineCreateInfoHUAWEI::initialize(const safe_VkSubpassShadingPipelineCreateInfoHUAWEI* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    renderPass = copy_src->renderPass;
+    subpass = copy_src->subpass;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI::safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
+    const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), subpassShading(in_struct->subpassShading) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI::safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI), pNext(nullptr), subpassShading() {}
+
+safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI::safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
+    const safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI& copy_src) {
+    sType = copy_src.sType;
+    subpassShading = copy_src.subpassShading;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI& safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI::operator=(
+    const safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    subpassShading = copy_src.subpassShading;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI::~safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI::initialize(const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    subpassShading = in_struct->subpassShading;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI::initialize(
+    const safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    subpassShading = copy_src->subpassShading;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI::safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
+    const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), maxSubpassShadingWorkgroupSizeAspectRatio(in_struct->maxSubpassShadingWorkgroupSizeAspectRatio) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI::safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI),
+      pNext(nullptr),
+      maxSubpassShadingWorkgroupSizeAspectRatio() {}
+
+safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI::safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
+    const safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI& copy_src) {
+    sType = copy_src.sType;
+    maxSubpassShadingWorkgroupSizeAspectRatio = copy_src.maxSubpassShadingWorkgroupSizeAspectRatio;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI& safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI::operator=(
+    const safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxSubpassShadingWorkgroupSizeAspectRatio = copy_src.maxSubpassShadingWorkgroupSizeAspectRatio;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI::~safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI::initialize(
+    const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxSubpassShadingWorkgroupSizeAspectRatio = in_struct->maxSubpassShadingWorkgroupSizeAspectRatio;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI::initialize(
+    const safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxSubpassShadingWorkgroupSizeAspectRatio = copy_src->maxSubpassShadingWorkgroupSizeAspectRatio;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI::safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
+    const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), invocationMask(in_struct->invocationMask) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI::safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI), pNext(nullptr), invocationMask() {}
+
+safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI::safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
+    const safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI& copy_src) {
+    sType = copy_src.sType;
+    invocationMask = copy_src.invocationMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI& safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI::operator=(
+    const safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    invocationMask = copy_src.invocationMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI::~safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI::initialize(const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    invocationMask = in_struct->invocationMask;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI::initialize(
+    const safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    invocationMask = copy_src->invocationMask;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkMemoryGetRemoteAddressInfoNV::safe_VkMemoryGetRemoteAddressInfoNV(const VkMemoryGetRemoteAddressInfoNV* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType), memory(in_struct->memory), handleType(in_struct->handleType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMemoryGetRemoteAddressInfoNV::safe_VkMemoryGetRemoteAddressInfoNV()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV), pNext(nullptr), memory(), handleType() {}
+
+safe_VkMemoryGetRemoteAddressInfoNV::safe_VkMemoryGetRemoteAddressInfoNV(const safe_VkMemoryGetRemoteAddressInfoNV& copy_src) {
+    sType = copy_src.sType;
+    memory = copy_src.memory;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMemoryGetRemoteAddressInfoNV& safe_VkMemoryGetRemoteAddressInfoNV::operator=(
+    const safe_VkMemoryGetRemoteAddressInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    memory = copy_src.memory;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMemoryGetRemoteAddressInfoNV::~safe_VkMemoryGetRemoteAddressInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkMemoryGetRemoteAddressInfoNV::initialize(const VkMemoryGetRemoteAddressInfoNV* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    memory = in_struct->memory;
+    handleType = in_struct->handleType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMemoryGetRemoteAddressInfoNV::initialize(const safe_VkMemoryGetRemoteAddressInfoNV* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memory = copy_src->memory;
+    handleType = copy_src->handleType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV::safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
+    const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), externalMemoryRDMA(in_struct->externalMemoryRDMA) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV::safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV), pNext(nullptr), externalMemoryRDMA() {}
+
+safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV::safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
+    const safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    externalMemoryRDMA = copy_src.externalMemoryRDMA;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV& safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    externalMemoryRDMA = copy_src.externalMemoryRDMA;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV::~safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV::initialize(const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    externalMemoryRDMA = in_struct->externalMemoryRDMA;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV::initialize(
+    const safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    externalMemoryRDMA = copy_src->externalMemoryRDMA;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+
+safe_VkScreenSurfaceCreateInfoQNX::safe_VkScreenSurfaceCreateInfoQNX(const VkScreenSurfaceCreateInfoQNX* in_struct,
+                                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags), context(nullptr), window(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->context) {
+        context = new _screen_context(*in_struct->context);
+    }
+
+    if (in_struct->window) {
+        window = new _screen_window(*in_struct->window);
+    }
+}
+
+safe_VkScreenSurfaceCreateInfoQNX::safe_VkScreenSurfaceCreateInfoQNX()
+    : sType(VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX), pNext(nullptr), flags(), context(nullptr), window(nullptr) {}
+
+safe_VkScreenSurfaceCreateInfoQNX::safe_VkScreenSurfaceCreateInfoQNX(const safe_VkScreenSurfaceCreateInfoQNX& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    context = nullptr;
+    window = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.context) {
+        context = new _screen_context(*copy_src.context);
+    }
+
+    if (copy_src.window) {
+        window = new _screen_window(*copy_src.window);
+    }
+}
+
+safe_VkScreenSurfaceCreateInfoQNX& safe_VkScreenSurfaceCreateInfoQNX::operator=(const safe_VkScreenSurfaceCreateInfoQNX& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (context) delete context;
+    if (window) delete window;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    context = nullptr;
+    window = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.context) {
+        context = new _screen_context(*copy_src.context);
+    }
+
+    if (copy_src.window) {
+        window = new _screen_window(*copy_src.window);
+    }
+
+    return *this;
+}
+
+safe_VkScreenSurfaceCreateInfoQNX::~safe_VkScreenSurfaceCreateInfoQNX() {
+    if (context) delete context;
+    if (window) delete window;
+    FreePnextChain(pNext);
+}
+
+void safe_VkScreenSurfaceCreateInfoQNX::initialize(const VkScreenSurfaceCreateInfoQNX* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    if (context) delete context;
+    if (window) delete window;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    context = nullptr;
+    window = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->context) {
+        context = new _screen_context(*in_struct->context);
+    }
+
+    if (in_struct->window) {
+        window = new _screen_window(*in_struct->window);
+    }
+}
+
+void safe_VkScreenSurfaceCreateInfoQNX::initialize(const safe_VkScreenSurfaceCreateInfoQNX* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    context = nullptr;
+    window = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->context) {
+        context = new _screen_context(*copy_src->context);
+    }
+
+    if (copy_src->window) {
+        window = new _screen_window(*copy_src->window);
+    }
+}
+#endif  // VK_USE_PLATFORM_SCREEN_QNX
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+
+safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV::safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
+    const VkPhysicalDeviceDisplacementMicromapFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), displacementMicromap(in_struct->displacementMicromap) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV::safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV), pNext(nullptr), displacementMicromap() {}
+
+safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV::safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
+    const safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    displacementMicromap = copy_src.displacementMicromap;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV& safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    displacementMicromap = copy_src.displacementMicromap;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV::~safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV::initialize(
+    const VkPhysicalDeviceDisplacementMicromapFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    displacementMicromap = in_struct->displacementMicromap;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV::initialize(
+    const safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    displacementMicromap = copy_src->displacementMicromap;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV::safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
+    const VkPhysicalDeviceDisplacementMicromapPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), maxDisplacementMicromapSubdivisionLevel(in_struct->maxDisplacementMicromapSubdivisionLevel) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV::safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV),
+      pNext(nullptr),
+      maxDisplacementMicromapSubdivisionLevel() {}
+
+safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV::safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
+    const safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    maxDisplacementMicromapSubdivisionLevel = copy_src.maxDisplacementMicromapSubdivisionLevel;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV& safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV::operator=(
+    const safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxDisplacementMicromapSubdivisionLevel = copy_src.maxDisplacementMicromapSubdivisionLevel;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV::~safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV::initialize(
+    const VkPhysicalDeviceDisplacementMicromapPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxDisplacementMicromapSubdivisionLevel = in_struct->maxDisplacementMicromapSubdivisionLevel;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV::initialize(
+    const safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxDisplacementMicromapSubdivisionLevel = copy_src->maxDisplacementMicromapSubdivisionLevel;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+
+safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI::safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
+    const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      clustercullingShader(in_struct->clustercullingShader),
+      multiviewClusterCullingShader(in_struct->multiviewClusterCullingShader) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI::safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI),
+      pNext(nullptr),
+      clustercullingShader(),
+      multiviewClusterCullingShader() {}
+
+safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI::safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
+    const safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI& copy_src) {
+    sType = copy_src.sType;
+    clustercullingShader = copy_src.clustercullingShader;
+    multiviewClusterCullingShader = copy_src.multiviewClusterCullingShader;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI& safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI::operator=(
+    const safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    clustercullingShader = copy_src.clustercullingShader;
+    multiviewClusterCullingShader = copy_src.multiviewClusterCullingShader;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI::~safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI::initialize(
+    const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    clustercullingShader = in_struct->clustercullingShader;
+    multiviewClusterCullingShader = in_struct->multiviewClusterCullingShader;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI::initialize(
+    const safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    clustercullingShader = copy_src->clustercullingShader;
+    multiviewClusterCullingShader = copy_src->multiviewClusterCullingShader;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI::safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
+    const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      maxOutputClusterCount(in_struct->maxOutputClusterCount),
+      indirectBufferOffsetAlignment(in_struct->indirectBufferOffsetAlignment) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxWorkGroupCount[i] = in_struct->maxWorkGroupCount[i];
+    }
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxWorkGroupSize[i] = in_struct->maxWorkGroupSize[i];
+    }
+}
+
+safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI::safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI),
+      pNext(nullptr),
+      maxOutputClusterCount(),
+      indirectBufferOffsetAlignment() {}
+
+safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI::safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
+    const safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI& copy_src) {
+    sType = copy_src.sType;
+    maxOutputClusterCount = copy_src.maxOutputClusterCount;
+    indirectBufferOffsetAlignment = copy_src.indirectBufferOffsetAlignment;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxWorkGroupCount[i] = copy_src.maxWorkGroupCount[i];
+    }
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxWorkGroupSize[i] = copy_src.maxWorkGroupSize[i];
+    }
+}
+
+safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI& safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI::operator=(
+    const safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxOutputClusterCount = copy_src.maxOutputClusterCount;
+    indirectBufferOffsetAlignment = copy_src.indirectBufferOffsetAlignment;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxWorkGroupCount[i] = copy_src.maxWorkGroupCount[i];
+    }
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxWorkGroupSize[i] = copy_src.maxWorkGroupSize[i];
+    }
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI::~safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI::initialize(
+    const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxOutputClusterCount = in_struct->maxOutputClusterCount;
+    indirectBufferOffsetAlignment = in_struct->indirectBufferOffsetAlignment;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxWorkGroupCount[i] = in_struct->maxWorkGroupCount[i];
+    }
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxWorkGroupSize[i] = in_struct->maxWorkGroupSize[i];
+    }
+}
+
+void safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI::initialize(
+    const safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxOutputClusterCount = copy_src->maxOutputClusterCount;
+    indirectBufferOffsetAlignment = copy_src->indirectBufferOffsetAlignment;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxWorkGroupCount[i] = copy_src->maxWorkGroupCount[i];
+    }
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxWorkGroupSize[i] = copy_src->maxWorkGroupSize[i];
+    }
+}
+
+safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI::safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI(
+    const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), clusterShadingRate(in_struct->clusterShadingRate) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI::safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI), pNext(nullptr), clusterShadingRate() {}
+
+safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI::safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI(
+    const safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI& copy_src) {
+    sType = copy_src.sType;
+    clusterShadingRate = copy_src.clusterShadingRate;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI& safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI::operator=(
+    const safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    clusterShadingRate = copy_src.clusterShadingRate;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI::~safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI::initialize(
+    const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    clusterShadingRate = in_struct->clusterShadingRate;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI::initialize(
+    const safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    clusterShadingRate = copy_src->clusterShadingRate;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceShaderCorePropertiesARM::safe_VkPhysicalDeviceShaderCorePropertiesARM(
+    const VkPhysicalDeviceShaderCorePropertiesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), pixelRate(in_struct->pixelRate), texelRate(in_struct->texelRate), fmaRate(in_struct->fmaRate) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderCorePropertiesARM::safe_VkPhysicalDeviceShaderCorePropertiesARM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM), pNext(nullptr), pixelRate(), texelRate(), fmaRate() {}
+
+safe_VkPhysicalDeviceShaderCorePropertiesARM::safe_VkPhysicalDeviceShaderCorePropertiesARM(
+    const safe_VkPhysicalDeviceShaderCorePropertiesARM& copy_src) {
+    sType = copy_src.sType;
+    pixelRate = copy_src.pixelRate;
+    texelRate = copy_src.texelRate;
+    fmaRate = copy_src.fmaRate;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderCorePropertiesARM& safe_VkPhysicalDeviceShaderCorePropertiesARM::operator=(
+    const safe_VkPhysicalDeviceShaderCorePropertiesARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pixelRate = copy_src.pixelRate;
+    texelRate = copy_src.texelRate;
+    fmaRate = copy_src.fmaRate;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderCorePropertiesARM::~safe_VkPhysicalDeviceShaderCorePropertiesARM() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceShaderCorePropertiesARM::initialize(const VkPhysicalDeviceShaderCorePropertiesARM* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pixelRate = in_struct->pixelRate;
+    texelRate = in_struct->texelRate;
+    fmaRate = in_struct->fmaRate;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderCorePropertiesARM::initialize(const safe_VkPhysicalDeviceShaderCorePropertiesARM* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pixelRate = copy_src->pixelRate;
+    texelRate = copy_src->texelRate;
+    fmaRate = copy_src->fmaRate;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDeviceQueueShaderCoreControlCreateInfoARM::safe_VkDeviceQueueShaderCoreControlCreateInfoARM(
+    const VkDeviceQueueShaderCoreControlCreateInfoARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), shaderCoreCount(in_struct->shaderCoreCount) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDeviceQueueShaderCoreControlCreateInfoARM::safe_VkDeviceQueueShaderCoreControlCreateInfoARM()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM), pNext(nullptr), shaderCoreCount() {}
+
+safe_VkDeviceQueueShaderCoreControlCreateInfoARM::safe_VkDeviceQueueShaderCoreControlCreateInfoARM(
+    const safe_VkDeviceQueueShaderCoreControlCreateInfoARM& copy_src) {
+    sType = copy_src.sType;
+    shaderCoreCount = copy_src.shaderCoreCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDeviceQueueShaderCoreControlCreateInfoARM& safe_VkDeviceQueueShaderCoreControlCreateInfoARM::operator=(
+    const safe_VkDeviceQueueShaderCoreControlCreateInfoARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderCoreCount = copy_src.shaderCoreCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDeviceQueueShaderCoreControlCreateInfoARM::~safe_VkDeviceQueueShaderCoreControlCreateInfoARM() { FreePnextChain(pNext); }
+
+void safe_VkDeviceQueueShaderCoreControlCreateInfoARM::initialize(const VkDeviceQueueShaderCoreControlCreateInfoARM* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderCoreCount = in_struct->shaderCoreCount;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDeviceQueueShaderCoreControlCreateInfoARM::initialize(const safe_VkDeviceQueueShaderCoreControlCreateInfoARM* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderCoreCount = copy_src->shaderCoreCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceSchedulingControlsFeaturesARM::safe_VkPhysicalDeviceSchedulingControlsFeaturesARM(
+    const VkPhysicalDeviceSchedulingControlsFeaturesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), schedulingControls(in_struct->schedulingControls) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceSchedulingControlsFeaturesARM::safe_VkPhysicalDeviceSchedulingControlsFeaturesARM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM), pNext(nullptr), schedulingControls() {}
+
+safe_VkPhysicalDeviceSchedulingControlsFeaturesARM::safe_VkPhysicalDeviceSchedulingControlsFeaturesARM(
+    const safe_VkPhysicalDeviceSchedulingControlsFeaturesARM& copy_src) {
+    sType = copy_src.sType;
+    schedulingControls = copy_src.schedulingControls;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceSchedulingControlsFeaturesARM& safe_VkPhysicalDeviceSchedulingControlsFeaturesARM::operator=(
+    const safe_VkPhysicalDeviceSchedulingControlsFeaturesARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    schedulingControls = copy_src.schedulingControls;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceSchedulingControlsFeaturesARM::~safe_VkPhysicalDeviceSchedulingControlsFeaturesARM() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceSchedulingControlsFeaturesARM::initialize(const VkPhysicalDeviceSchedulingControlsFeaturesARM* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    schedulingControls = in_struct->schedulingControls;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceSchedulingControlsFeaturesARM::initialize(
+    const safe_VkPhysicalDeviceSchedulingControlsFeaturesARM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    schedulingControls = copy_src->schedulingControls;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceSchedulingControlsPropertiesARM::safe_VkPhysicalDeviceSchedulingControlsPropertiesARM(
+    const VkPhysicalDeviceSchedulingControlsPropertiesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), schedulingControlsFlags(in_struct->schedulingControlsFlags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceSchedulingControlsPropertiesARM::safe_VkPhysicalDeviceSchedulingControlsPropertiesARM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM), pNext(nullptr), schedulingControlsFlags() {}
+
+safe_VkPhysicalDeviceSchedulingControlsPropertiesARM::safe_VkPhysicalDeviceSchedulingControlsPropertiesARM(
+    const safe_VkPhysicalDeviceSchedulingControlsPropertiesARM& copy_src) {
+    sType = copy_src.sType;
+    schedulingControlsFlags = copy_src.schedulingControlsFlags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceSchedulingControlsPropertiesARM& safe_VkPhysicalDeviceSchedulingControlsPropertiesARM::operator=(
+    const safe_VkPhysicalDeviceSchedulingControlsPropertiesARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    schedulingControlsFlags = copy_src.schedulingControlsFlags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceSchedulingControlsPropertiesARM::~safe_VkPhysicalDeviceSchedulingControlsPropertiesARM() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceSchedulingControlsPropertiesARM::initialize(
+    const VkPhysicalDeviceSchedulingControlsPropertiesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    schedulingControlsFlags = in_struct->schedulingControlsFlags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceSchedulingControlsPropertiesARM::initialize(
+    const safe_VkPhysicalDeviceSchedulingControlsPropertiesARM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    schedulingControlsFlags = copy_src->schedulingControlsFlags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE::safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
+    const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), descriptorSetHostMapping(in_struct->descriptorSetHostMapping) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE::safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE),
+      pNext(nullptr),
+      descriptorSetHostMapping() {}
+
+safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE::safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
+    const safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE& copy_src) {
+    sType = copy_src.sType;
+    descriptorSetHostMapping = copy_src.descriptorSetHostMapping;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE& safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE::operator=(
+    const safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    descriptorSetHostMapping = copy_src.descriptorSetHostMapping;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE::~safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE::initialize(
+    const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    descriptorSetHostMapping = in_struct->descriptorSetHostMapping;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE::initialize(
+    const safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    descriptorSetHostMapping = copy_src->descriptorSetHostMapping;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDescriptorSetBindingReferenceVALVE::safe_VkDescriptorSetBindingReferenceVALVE(
+    const VkDescriptorSetBindingReferenceVALVE* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), descriptorSetLayout(in_struct->descriptorSetLayout), binding(in_struct->binding) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDescriptorSetBindingReferenceVALVE::safe_VkDescriptorSetBindingReferenceVALVE()
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE), pNext(nullptr), descriptorSetLayout(), binding() {}
+
+safe_VkDescriptorSetBindingReferenceVALVE::safe_VkDescriptorSetBindingReferenceVALVE(
+    const safe_VkDescriptorSetBindingReferenceVALVE& copy_src) {
+    sType = copy_src.sType;
+    descriptorSetLayout = copy_src.descriptorSetLayout;
+    binding = copy_src.binding;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDescriptorSetBindingReferenceVALVE& safe_VkDescriptorSetBindingReferenceVALVE::operator=(
+    const safe_VkDescriptorSetBindingReferenceVALVE& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    descriptorSetLayout = copy_src.descriptorSetLayout;
+    binding = copy_src.binding;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDescriptorSetBindingReferenceVALVE::~safe_VkDescriptorSetBindingReferenceVALVE() { FreePnextChain(pNext); }
+
+void safe_VkDescriptorSetBindingReferenceVALVE::initialize(const VkDescriptorSetBindingReferenceVALVE* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    descriptorSetLayout = in_struct->descriptorSetLayout;
+    binding = in_struct->binding;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDescriptorSetBindingReferenceVALVE::initialize(const safe_VkDescriptorSetBindingReferenceVALVE* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    descriptorSetLayout = copy_src->descriptorSetLayout;
+    binding = copy_src->binding;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDescriptorSetLayoutHostMappingInfoVALVE::safe_VkDescriptorSetLayoutHostMappingInfoVALVE(
+    const VkDescriptorSetLayoutHostMappingInfoVALVE* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), descriptorOffset(in_struct->descriptorOffset), descriptorSize(in_struct->descriptorSize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDescriptorSetLayoutHostMappingInfoVALVE::safe_VkDescriptorSetLayoutHostMappingInfoVALVE()
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE),
+      pNext(nullptr),
+      descriptorOffset(),
+      descriptorSize() {}
+
+safe_VkDescriptorSetLayoutHostMappingInfoVALVE::safe_VkDescriptorSetLayoutHostMappingInfoVALVE(
+    const safe_VkDescriptorSetLayoutHostMappingInfoVALVE& copy_src) {
+    sType = copy_src.sType;
+    descriptorOffset = copy_src.descriptorOffset;
+    descriptorSize = copy_src.descriptorSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDescriptorSetLayoutHostMappingInfoVALVE& safe_VkDescriptorSetLayoutHostMappingInfoVALVE::operator=(
+    const safe_VkDescriptorSetLayoutHostMappingInfoVALVE& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    descriptorOffset = copy_src.descriptorOffset;
+    descriptorSize = copy_src.descriptorSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDescriptorSetLayoutHostMappingInfoVALVE::~safe_VkDescriptorSetLayoutHostMappingInfoVALVE() { FreePnextChain(pNext); }
+
+void safe_VkDescriptorSetLayoutHostMappingInfoVALVE::initialize(const VkDescriptorSetLayoutHostMappingInfoVALVE* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    descriptorOffset = in_struct->descriptorOffset;
+    descriptorSize = in_struct->descriptorSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDescriptorSetLayoutHostMappingInfoVALVE::initialize(const safe_VkDescriptorSetLayoutHostMappingInfoVALVE* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    descriptorOffset = copy_src->descriptorOffset;
+    descriptorSize = copy_src->descriptorSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceRenderPassStripedFeaturesARM::safe_VkPhysicalDeviceRenderPassStripedFeaturesARM(
+    const VkPhysicalDeviceRenderPassStripedFeaturesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), renderPassStriped(in_struct->renderPassStriped) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceRenderPassStripedFeaturesARM::safe_VkPhysicalDeviceRenderPassStripedFeaturesARM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM), pNext(nullptr), renderPassStriped() {}
+
+safe_VkPhysicalDeviceRenderPassStripedFeaturesARM::safe_VkPhysicalDeviceRenderPassStripedFeaturesARM(
+    const safe_VkPhysicalDeviceRenderPassStripedFeaturesARM& copy_src) {
+    sType = copy_src.sType;
+    renderPassStriped = copy_src.renderPassStriped;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceRenderPassStripedFeaturesARM& safe_VkPhysicalDeviceRenderPassStripedFeaturesARM::operator=(
+    const safe_VkPhysicalDeviceRenderPassStripedFeaturesARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    renderPassStriped = copy_src.renderPassStriped;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceRenderPassStripedFeaturesARM::~safe_VkPhysicalDeviceRenderPassStripedFeaturesARM() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceRenderPassStripedFeaturesARM::initialize(const VkPhysicalDeviceRenderPassStripedFeaturesARM* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    renderPassStriped = in_struct->renderPassStriped;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceRenderPassStripedFeaturesARM::initialize(
+    const safe_VkPhysicalDeviceRenderPassStripedFeaturesARM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    renderPassStriped = copy_src->renderPassStriped;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceRenderPassStripedPropertiesARM::safe_VkPhysicalDeviceRenderPassStripedPropertiesARM(
+    const VkPhysicalDeviceRenderPassStripedPropertiesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      renderPassStripeGranularity(in_struct->renderPassStripeGranularity),
+      maxRenderPassStripes(in_struct->maxRenderPassStripes) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceRenderPassStripedPropertiesARM::safe_VkPhysicalDeviceRenderPassStripedPropertiesARM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM),
+      pNext(nullptr),
+      renderPassStripeGranularity(),
+      maxRenderPassStripes() {}
+
+safe_VkPhysicalDeviceRenderPassStripedPropertiesARM::safe_VkPhysicalDeviceRenderPassStripedPropertiesARM(
+    const safe_VkPhysicalDeviceRenderPassStripedPropertiesARM& copy_src) {
+    sType = copy_src.sType;
+    renderPassStripeGranularity = copy_src.renderPassStripeGranularity;
+    maxRenderPassStripes = copy_src.maxRenderPassStripes;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceRenderPassStripedPropertiesARM& safe_VkPhysicalDeviceRenderPassStripedPropertiesARM::operator=(
+    const safe_VkPhysicalDeviceRenderPassStripedPropertiesARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    renderPassStripeGranularity = copy_src.renderPassStripeGranularity;
+    maxRenderPassStripes = copy_src.maxRenderPassStripes;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceRenderPassStripedPropertiesARM::~safe_VkPhysicalDeviceRenderPassStripedPropertiesARM() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceRenderPassStripedPropertiesARM::initialize(
+    const VkPhysicalDeviceRenderPassStripedPropertiesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    renderPassStripeGranularity = in_struct->renderPassStripeGranularity;
+    maxRenderPassStripes = in_struct->maxRenderPassStripes;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceRenderPassStripedPropertiesARM::initialize(
+    const safe_VkPhysicalDeviceRenderPassStripedPropertiesARM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    renderPassStripeGranularity = copy_src->renderPassStripeGranularity;
+    maxRenderPassStripes = copy_src->maxRenderPassStripes;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkRenderPassStripeInfoARM::safe_VkRenderPassStripeInfoARM(const VkRenderPassStripeInfoARM* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), stripeArea(in_struct->stripeArea) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkRenderPassStripeInfoARM::safe_VkRenderPassStripeInfoARM()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM), pNext(nullptr), stripeArea() {}
+
+safe_VkRenderPassStripeInfoARM::safe_VkRenderPassStripeInfoARM(const safe_VkRenderPassStripeInfoARM& copy_src) {
+    sType = copy_src.sType;
+    stripeArea = copy_src.stripeArea;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkRenderPassStripeInfoARM& safe_VkRenderPassStripeInfoARM::operator=(const safe_VkRenderPassStripeInfoARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    stripeArea = copy_src.stripeArea;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkRenderPassStripeInfoARM::~safe_VkRenderPassStripeInfoARM() { FreePnextChain(pNext); }
+
+void safe_VkRenderPassStripeInfoARM::initialize(const VkRenderPassStripeInfoARM* in_struct,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    stripeArea = in_struct->stripeArea;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkRenderPassStripeInfoARM::initialize(const safe_VkRenderPassStripeInfoARM* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stripeArea = copy_src->stripeArea;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkRenderPassStripeBeginInfoARM::safe_VkRenderPassStripeBeginInfoARM(const VkRenderPassStripeBeginInfoARM* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType), stripeInfoCount(in_struct->stripeInfoCount), pStripeInfos(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (stripeInfoCount && in_struct->pStripeInfos) {
+        pStripeInfos = new safe_VkRenderPassStripeInfoARM[stripeInfoCount];
+        for (uint32_t i = 0; i < stripeInfoCount; ++i) {
+            pStripeInfos[i].initialize(&in_struct->pStripeInfos[i]);
+        }
+    }
+}
+
+safe_VkRenderPassStripeBeginInfoARM::safe_VkRenderPassStripeBeginInfoARM()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM), pNext(nullptr), stripeInfoCount(), pStripeInfos(nullptr) {}
+
+safe_VkRenderPassStripeBeginInfoARM::safe_VkRenderPassStripeBeginInfoARM(const safe_VkRenderPassStripeBeginInfoARM& copy_src) {
+    sType = copy_src.sType;
+    stripeInfoCount = copy_src.stripeInfoCount;
+    pStripeInfos = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (stripeInfoCount && copy_src.pStripeInfos) {
+        pStripeInfos = new safe_VkRenderPassStripeInfoARM[stripeInfoCount];
+        for (uint32_t i = 0; i < stripeInfoCount; ++i) {
+            pStripeInfos[i].initialize(&copy_src.pStripeInfos[i]);
+        }
+    }
+}
+
+safe_VkRenderPassStripeBeginInfoARM& safe_VkRenderPassStripeBeginInfoARM::operator=(
+    const safe_VkRenderPassStripeBeginInfoARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pStripeInfos) delete[] pStripeInfos;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    stripeInfoCount = copy_src.stripeInfoCount;
+    pStripeInfos = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (stripeInfoCount && copy_src.pStripeInfos) {
+        pStripeInfos = new safe_VkRenderPassStripeInfoARM[stripeInfoCount];
+        for (uint32_t i = 0; i < stripeInfoCount; ++i) {
+            pStripeInfos[i].initialize(&copy_src.pStripeInfos[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkRenderPassStripeBeginInfoARM::~safe_VkRenderPassStripeBeginInfoARM() {
+    if (pStripeInfos) delete[] pStripeInfos;
+    FreePnextChain(pNext);
+}
+
+void safe_VkRenderPassStripeBeginInfoARM::initialize(const VkRenderPassStripeBeginInfoARM* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pStripeInfos) delete[] pStripeInfos;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    stripeInfoCount = in_struct->stripeInfoCount;
+    pStripeInfos = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (stripeInfoCount && in_struct->pStripeInfos) {
+        pStripeInfos = new safe_VkRenderPassStripeInfoARM[stripeInfoCount];
+        for (uint32_t i = 0; i < stripeInfoCount; ++i) {
+            pStripeInfos[i].initialize(&in_struct->pStripeInfos[i]);
+        }
+    }
+}
+
+void safe_VkRenderPassStripeBeginInfoARM::initialize(const safe_VkRenderPassStripeBeginInfoARM* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stripeInfoCount = copy_src->stripeInfoCount;
+    pStripeInfos = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (stripeInfoCount && copy_src->pStripeInfos) {
+        pStripeInfos = new safe_VkRenderPassStripeInfoARM[stripeInfoCount];
+        for (uint32_t i = 0; i < stripeInfoCount; ++i) {
+            pStripeInfos[i].initialize(&copy_src->pStripeInfos[i]);
+        }
+    }
+}
+
+safe_VkRenderPassStripeSubmitInfoARM::safe_VkRenderPassStripeSubmitInfoARM(const VkRenderPassStripeSubmitInfoARM* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), stripeSemaphoreInfoCount(in_struct->stripeSemaphoreInfoCount), pStripeSemaphoreInfos(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (stripeSemaphoreInfoCount && in_struct->pStripeSemaphoreInfos) {
+        pStripeSemaphoreInfos = new safe_VkSemaphoreSubmitInfo[stripeSemaphoreInfoCount];
+        for (uint32_t i = 0; i < stripeSemaphoreInfoCount; ++i) {
+            pStripeSemaphoreInfos[i].initialize(&in_struct->pStripeSemaphoreInfos[i]);
+        }
+    }
+}
+
+safe_VkRenderPassStripeSubmitInfoARM::safe_VkRenderPassStripeSubmitInfoARM()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM),
+      pNext(nullptr),
+      stripeSemaphoreInfoCount(),
+      pStripeSemaphoreInfos(nullptr) {}
+
+safe_VkRenderPassStripeSubmitInfoARM::safe_VkRenderPassStripeSubmitInfoARM(const safe_VkRenderPassStripeSubmitInfoARM& copy_src) {
+    sType = copy_src.sType;
+    stripeSemaphoreInfoCount = copy_src.stripeSemaphoreInfoCount;
+    pStripeSemaphoreInfos = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (stripeSemaphoreInfoCount && copy_src.pStripeSemaphoreInfos) {
+        pStripeSemaphoreInfos = new safe_VkSemaphoreSubmitInfo[stripeSemaphoreInfoCount];
+        for (uint32_t i = 0; i < stripeSemaphoreInfoCount; ++i) {
+            pStripeSemaphoreInfos[i].initialize(&copy_src.pStripeSemaphoreInfos[i]);
+        }
+    }
+}
+
+safe_VkRenderPassStripeSubmitInfoARM& safe_VkRenderPassStripeSubmitInfoARM::operator=(
+    const safe_VkRenderPassStripeSubmitInfoARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pStripeSemaphoreInfos) delete[] pStripeSemaphoreInfos;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    stripeSemaphoreInfoCount = copy_src.stripeSemaphoreInfoCount;
+    pStripeSemaphoreInfos = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (stripeSemaphoreInfoCount && copy_src.pStripeSemaphoreInfos) {
+        pStripeSemaphoreInfos = new safe_VkSemaphoreSubmitInfo[stripeSemaphoreInfoCount];
+        for (uint32_t i = 0; i < stripeSemaphoreInfoCount; ++i) {
+            pStripeSemaphoreInfos[i].initialize(&copy_src.pStripeSemaphoreInfos[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkRenderPassStripeSubmitInfoARM::~safe_VkRenderPassStripeSubmitInfoARM() {
+    if (pStripeSemaphoreInfos) delete[] pStripeSemaphoreInfos;
+    FreePnextChain(pNext);
+}
+
+void safe_VkRenderPassStripeSubmitInfoARM::initialize(const VkRenderPassStripeSubmitInfoARM* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pStripeSemaphoreInfos) delete[] pStripeSemaphoreInfos;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    stripeSemaphoreInfoCount = in_struct->stripeSemaphoreInfoCount;
+    pStripeSemaphoreInfos = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (stripeSemaphoreInfoCount && in_struct->pStripeSemaphoreInfos) {
+        pStripeSemaphoreInfos = new safe_VkSemaphoreSubmitInfo[stripeSemaphoreInfoCount];
+        for (uint32_t i = 0; i < stripeSemaphoreInfoCount; ++i) {
+            pStripeSemaphoreInfos[i].initialize(&in_struct->pStripeSemaphoreInfos[i]);
+        }
+    }
+}
+
+void safe_VkRenderPassStripeSubmitInfoARM::initialize(const safe_VkRenderPassStripeSubmitInfoARM* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stripeSemaphoreInfoCount = copy_src->stripeSemaphoreInfoCount;
+    pStripeSemaphoreInfos = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (stripeSemaphoreInfoCount && copy_src->pStripeSemaphoreInfos) {
+        pStripeSemaphoreInfos = new safe_VkSemaphoreSubmitInfo[stripeSemaphoreInfoCount];
+        for (uint32_t i = 0; i < stripeSemaphoreInfoCount; ++i) {
+            pStripeSemaphoreInfos[i].initialize(&copy_src->pStripeSemaphoreInfos[i]);
+        }
+    }
+}
+
+safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM::safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+    const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), fragmentDensityMapOffset(in_struct->fragmentDensityMapOffset) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM::safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM),
+      pNext(nullptr),
+      fragmentDensityMapOffset() {}
+
+safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM::safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+    const safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& copy_src) {
+    sType = copy_src.sType;
+    fragmentDensityMapOffset = copy_src.fragmentDensityMapOffset;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM::operator=(
+    const safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    fragmentDensityMapOffset = copy_src.fragmentDensityMapOffset;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM::~safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM::initialize(
+    const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    fragmentDensityMapOffset = in_struct->fragmentDensityMapOffset;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM::initialize(
+    const safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    fragmentDensityMapOffset = copy_src->fragmentDensityMapOffset;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM::safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+    const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), fragmentDensityOffsetGranularity(in_struct->fragmentDensityOffsetGranularity) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM::safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM),
+      pNext(nullptr),
+      fragmentDensityOffsetGranularity() {}
+
+safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM::safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+    const safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM& copy_src) {
+    sType = copy_src.sType;
+    fragmentDensityOffsetGranularity = copy_src.fragmentDensityOffsetGranularity;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM& safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM::operator=(
+    const safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    fragmentDensityOffsetGranularity = copy_src.fragmentDensityOffsetGranularity;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM::~safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM::initialize(
+    const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    fragmentDensityOffsetGranularity = in_struct->fragmentDensityOffsetGranularity;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM::initialize(
+    const safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    fragmentDensityOffsetGranularity = copy_src->fragmentDensityOffsetGranularity;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM::safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
+    const VkSubpassFragmentDensityMapOffsetEndInfoQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), fragmentDensityOffsetCount(in_struct->fragmentDensityOffsetCount), pFragmentDensityOffsets(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pFragmentDensityOffsets) {
+        pFragmentDensityOffsets = new VkOffset2D[in_struct->fragmentDensityOffsetCount];
+        memcpy((void*)pFragmentDensityOffsets, (void*)in_struct->pFragmentDensityOffsets,
+               sizeof(VkOffset2D) * in_struct->fragmentDensityOffsetCount);
+    }
+}
+
+safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM::safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM()
+    : sType(VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM),
+      pNext(nullptr),
+      fragmentDensityOffsetCount(),
+      pFragmentDensityOffsets(nullptr) {}
+
+safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM::safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
+    const safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM& copy_src) {
+    sType = copy_src.sType;
+    fragmentDensityOffsetCount = copy_src.fragmentDensityOffsetCount;
+    pFragmentDensityOffsets = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pFragmentDensityOffsets) {
+        pFragmentDensityOffsets = new VkOffset2D[copy_src.fragmentDensityOffsetCount];
+        memcpy((void*)pFragmentDensityOffsets, (void*)copy_src.pFragmentDensityOffsets,
+               sizeof(VkOffset2D) * copy_src.fragmentDensityOffsetCount);
+    }
+}
+
+safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM& safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM::operator=(
+    const safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pFragmentDensityOffsets) delete[] pFragmentDensityOffsets;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    fragmentDensityOffsetCount = copy_src.fragmentDensityOffsetCount;
+    pFragmentDensityOffsets = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pFragmentDensityOffsets) {
+        pFragmentDensityOffsets = new VkOffset2D[copy_src.fragmentDensityOffsetCount];
+        memcpy((void*)pFragmentDensityOffsets, (void*)copy_src.pFragmentDensityOffsets,
+               sizeof(VkOffset2D) * copy_src.fragmentDensityOffsetCount);
+    }
+
+    return *this;
+}
+
+safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM::~safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM() {
+    if (pFragmentDensityOffsets) delete[] pFragmentDensityOffsets;
+    FreePnextChain(pNext);
+}
+
+void safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM::initialize(const VkSubpassFragmentDensityMapOffsetEndInfoQCOM* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pFragmentDensityOffsets) delete[] pFragmentDensityOffsets;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    fragmentDensityOffsetCount = in_struct->fragmentDensityOffsetCount;
+    pFragmentDensityOffsets = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pFragmentDensityOffsets) {
+        pFragmentDensityOffsets = new VkOffset2D[in_struct->fragmentDensityOffsetCount];
+        memcpy((void*)pFragmentDensityOffsets, (void*)in_struct->pFragmentDensityOffsets,
+               sizeof(VkOffset2D) * in_struct->fragmentDensityOffsetCount);
+    }
+}
+
+void safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM::initialize(
+    const safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    fragmentDensityOffsetCount = copy_src->fragmentDensityOffsetCount;
+    pFragmentDensityOffsets = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pFragmentDensityOffsets) {
+        pFragmentDensityOffsets = new VkOffset2D[copy_src->fragmentDensityOffsetCount];
+        memcpy((void*)pFragmentDensityOffsets, (void*)copy_src->pFragmentDensityOffsets,
+               sizeof(VkOffset2D) * copy_src->fragmentDensityOffsetCount);
+    }
+}
+
+safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV::safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
+    const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), indirectCopy(in_struct->indirectCopy) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV::safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV), pNext(nullptr), indirectCopy() {}
+
+safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV::safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
+    const safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    indirectCopy = copy_src.indirectCopy;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV& safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    indirectCopy = copy_src.indirectCopy;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV::~safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV::initialize(const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    indirectCopy = in_struct->indirectCopy;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV::initialize(
+    const safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    indirectCopy = copy_src->indirectCopy;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV::safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
+    const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), supportedQueues(in_struct->supportedQueues) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV::safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV), pNext(nullptr), supportedQueues() {}
+
+safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV::safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
+    const safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    supportedQueues = copy_src.supportedQueues;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV& safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV::operator=(
+    const safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    supportedQueues = copy_src.supportedQueues;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV::~safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV::initialize(
+    const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    supportedQueues = in_struct->supportedQueues;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV::initialize(
+    const safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    supportedQueues = copy_src->supportedQueues;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV::safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
+    const VkPhysicalDeviceMemoryDecompressionFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), memoryDecompression(in_struct->memoryDecompression) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV::safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV), pNext(nullptr), memoryDecompression() {}
+
+safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV::safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
+    const safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    memoryDecompression = copy_src.memoryDecompression;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV& safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    memoryDecompression = copy_src.memoryDecompression;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV::~safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV::initialize(const VkPhysicalDeviceMemoryDecompressionFeaturesNV* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    memoryDecompression = in_struct->memoryDecompression;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV::initialize(
+    const safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memoryDecompression = copy_src->memoryDecompression;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV::safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
+    const VkPhysicalDeviceMemoryDecompressionPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      decompressionMethods(in_struct->decompressionMethods),
+      maxDecompressionIndirectCount(in_struct->maxDecompressionIndirectCount) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV::safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV),
+      pNext(nullptr),
+      decompressionMethods(),
+      maxDecompressionIndirectCount() {}
+
+safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV::safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
+    const safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    decompressionMethods = copy_src.decompressionMethods;
+    maxDecompressionIndirectCount = copy_src.maxDecompressionIndirectCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV& safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV::operator=(
+    const safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    decompressionMethods = copy_src.decompressionMethods;
+    maxDecompressionIndirectCount = copy_src.maxDecompressionIndirectCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV::~safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV::initialize(
+    const VkPhysicalDeviceMemoryDecompressionPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    decompressionMethods = in_struct->decompressionMethods;
+    maxDecompressionIndirectCount = in_struct->maxDecompressionIndirectCount;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV::initialize(
+    const safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    decompressionMethods = copy_src->decompressionMethods;
+    maxDecompressionIndirectCount = copy_src->maxDecompressionIndirectCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV::safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV(
+    const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      deviceGeneratedCompute(in_struct->deviceGeneratedCompute),
+      deviceGeneratedComputePipelines(in_struct->deviceGeneratedComputePipelines),
+      deviceGeneratedComputeCaptureReplay(in_struct->deviceGeneratedComputeCaptureReplay) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV::safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV),
+      pNext(nullptr),
+      deviceGeneratedCompute(),
+      deviceGeneratedComputePipelines(),
+      deviceGeneratedComputeCaptureReplay() {}
+
+safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV::safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV(
+    const safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    deviceGeneratedCompute = copy_src.deviceGeneratedCompute;
+    deviceGeneratedComputePipelines = copy_src.deviceGeneratedComputePipelines;
+    deviceGeneratedComputeCaptureReplay = copy_src.deviceGeneratedComputeCaptureReplay;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV&
+safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    deviceGeneratedCompute = copy_src.deviceGeneratedCompute;
+    deviceGeneratedComputePipelines = copy_src.deviceGeneratedComputePipelines;
+    deviceGeneratedComputeCaptureReplay = copy_src.deviceGeneratedComputeCaptureReplay;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV::~safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV::initialize(
+    const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    deviceGeneratedCompute = in_struct->deviceGeneratedCompute;
+    deviceGeneratedComputePipelines = in_struct->deviceGeneratedComputePipelines;
+    deviceGeneratedComputeCaptureReplay = in_struct->deviceGeneratedComputeCaptureReplay;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV::initialize(
+    const safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    deviceGeneratedCompute = copy_src->deviceGeneratedCompute;
+    deviceGeneratedComputePipelines = copy_src->deviceGeneratedComputePipelines;
+    deviceGeneratedComputeCaptureReplay = copy_src->deviceGeneratedComputeCaptureReplay;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkComputePipelineIndirectBufferInfoNV::safe_VkComputePipelineIndirectBufferInfoNV(
+    const VkComputePipelineIndirectBufferInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      deviceAddress(in_struct->deviceAddress),
+      size(in_struct->size),
+      pipelineDeviceAddressCaptureReplay(in_struct->pipelineDeviceAddressCaptureReplay) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkComputePipelineIndirectBufferInfoNV::safe_VkComputePipelineIndirectBufferInfoNV()
+    : sType(VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV),
+      pNext(nullptr),
+      deviceAddress(),
+      size(),
+      pipelineDeviceAddressCaptureReplay() {}
+
+safe_VkComputePipelineIndirectBufferInfoNV::safe_VkComputePipelineIndirectBufferInfoNV(
+    const safe_VkComputePipelineIndirectBufferInfoNV& copy_src) {
+    sType = copy_src.sType;
+    deviceAddress = copy_src.deviceAddress;
+    size = copy_src.size;
+    pipelineDeviceAddressCaptureReplay = copy_src.pipelineDeviceAddressCaptureReplay;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkComputePipelineIndirectBufferInfoNV& safe_VkComputePipelineIndirectBufferInfoNV::operator=(
+    const safe_VkComputePipelineIndirectBufferInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    deviceAddress = copy_src.deviceAddress;
+    size = copy_src.size;
+    pipelineDeviceAddressCaptureReplay = copy_src.pipelineDeviceAddressCaptureReplay;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkComputePipelineIndirectBufferInfoNV::~safe_VkComputePipelineIndirectBufferInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkComputePipelineIndirectBufferInfoNV::initialize(const VkComputePipelineIndirectBufferInfoNV* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    deviceAddress = in_struct->deviceAddress;
+    size = in_struct->size;
+    pipelineDeviceAddressCaptureReplay = in_struct->pipelineDeviceAddressCaptureReplay;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkComputePipelineIndirectBufferInfoNV::initialize(const safe_VkComputePipelineIndirectBufferInfoNV* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    deviceAddress = copy_src->deviceAddress;
+    size = copy_src->size;
+    pipelineDeviceAddressCaptureReplay = copy_src->pipelineDeviceAddressCaptureReplay;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineIndirectDeviceAddressInfoNV::safe_VkPipelineIndirectDeviceAddressInfoNV(
+    const VkPipelineIndirectDeviceAddressInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), pipelineBindPoint(in_struct->pipelineBindPoint), pipeline(in_struct->pipeline) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPipelineIndirectDeviceAddressInfoNV::safe_VkPipelineIndirectDeviceAddressInfoNV()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV), pNext(nullptr), pipelineBindPoint(), pipeline() {}
+
+safe_VkPipelineIndirectDeviceAddressInfoNV::safe_VkPipelineIndirectDeviceAddressInfoNV(
+    const safe_VkPipelineIndirectDeviceAddressInfoNV& copy_src) {
+    sType = copy_src.sType;
+    pipelineBindPoint = copy_src.pipelineBindPoint;
+    pipeline = copy_src.pipeline;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPipelineIndirectDeviceAddressInfoNV& safe_VkPipelineIndirectDeviceAddressInfoNV::operator=(
+    const safe_VkPipelineIndirectDeviceAddressInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pipelineBindPoint = copy_src.pipelineBindPoint;
+    pipeline = copy_src.pipeline;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineIndirectDeviceAddressInfoNV::~safe_VkPipelineIndirectDeviceAddressInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkPipelineIndirectDeviceAddressInfoNV::initialize(const VkPipelineIndirectDeviceAddressInfoNV* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pipelineBindPoint = in_struct->pipelineBindPoint;
+    pipeline = in_struct->pipeline;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPipelineIndirectDeviceAddressInfoNV::initialize(const safe_VkPipelineIndirectDeviceAddressInfoNV* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pipelineBindPoint = copy_src->pipelineBindPoint;
+    pipeline = copy_src->pipeline;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV::safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
+    const VkPhysicalDeviceLinearColorAttachmentFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), linearColorAttachment(in_struct->linearColorAttachment) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV::safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV), pNext(nullptr), linearColorAttachment() {}
+
+safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV::safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
+    const safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    linearColorAttachment = copy_src.linearColorAttachment;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV& safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    linearColorAttachment = copy_src.linearColorAttachment;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV::~safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV::initialize(
+    const VkPhysicalDeviceLinearColorAttachmentFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    linearColorAttachment = in_struct->linearColorAttachment;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV::initialize(
+    const safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    linearColorAttachment = copy_src->linearColorAttachment;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkImageViewSampleWeightCreateInfoQCOM::safe_VkImageViewSampleWeightCreateInfoQCOM(
+    const VkImageViewSampleWeightCreateInfoQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      filterCenter(in_struct->filterCenter),
+      filterSize(in_struct->filterSize),
+      numPhases(in_struct->numPhases) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImageViewSampleWeightCreateInfoQCOM::safe_VkImageViewSampleWeightCreateInfoQCOM()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM),
+      pNext(nullptr),
+      filterCenter(),
+      filterSize(),
+      numPhases() {}
+
+safe_VkImageViewSampleWeightCreateInfoQCOM::safe_VkImageViewSampleWeightCreateInfoQCOM(
+    const safe_VkImageViewSampleWeightCreateInfoQCOM& copy_src) {
+    sType = copy_src.sType;
+    filterCenter = copy_src.filterCenter;
+    filterSize = copy_src.filterSize;
+    numPhases = copy_src.numPhases;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImageViewSampleWeightCreateInfoQCOM& safe_VkImageViewSampleWeightCreateInfoQCOM::operator=(
+    const safe_VkImageViewSampleWeightCreateInfoQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    filterCenter = copy_src.filterCenter;
+    filterSize = copy_src.filterSize;
+    numPhases = copy_src.numPhases;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImageViewSampleWeightCreateInfoQCOM::~safe_VkImageViewSampleWeightCreateInfoQCOM() { FreePnextChain(pNext); }
+
+void safe_VkImageViewSampleWeightCreateInfoQCOM::initialize(const VkImageViewSampleWeightCreateInfoQCOM* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    filterCenter = in_struct->filterCenter;
+    filterSize = in_struct->filterSize;
+    numPhases = in_struct->numPhases;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImageViewSampleWeightCreateInfoQCOM::initialize(const safe_VkImageViewSampleWeightCreateInfoQCOM* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    filterCenter = copy_src->filterCenter;
+    filterSize = copy_src->filterSize;
+    numPhases = copy_src->numPhases;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceImageProcessingFeaturesQCOM::safe_VkPhysicalDeviceImageProcessingFeaturesQCOM(
+    const VkPhysicalDeviceImageProcessingFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      textureSampleWeighted(in_struct->textureSampleWeighted),
+      textureBoxFilter(in_struct->textureBoxFilter),
+      textureBlockMatch(in_struct->textureBlockMatch) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceImageProcessingFeaturesQCOM::safe_VkPhysicalDeviceImageProcessingFeaturesQCOM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM),
+      pNext(nullptr),
+      textureSampleWeighted(),
+      textureBoxFilter(),
+      textureBlockMatch() {}
+
+safe_VkPhysicalDeviceImageProcessingFeaturesQCOM::safe_VkPhysicalDeviceImageProcessingFeaturesQCOM(
+    const safe_VkPhysicalDeviceImageProcessingFeaturesQCOM& copy_src) {
+    sType = copy_src.sType;
+    textureSampleWeighted = copy_src.textureSampleWeighted;
+    textureBoxFilter = copy_src.textureBoxFilter;
+    textureBlockMatch = copy_src.textureBlockMatch;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceImageProcessingFeaturesQCOM& safe_VkPhysicalDeviceImageProcessingFeaturesQCOM::operator=(
+    const safe_VkPhysicalDeviceImageProcessingFeaturesQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    textureSampleWeighted = copy_src.textureSampleWeighted;
+    textureBoxFilter = copy_src.textureBoxFilter;
+    textureBlockMatch = copy_src.textureBlockMatch;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceImageProcessingFeaturesQCOM::~safe_VkPhysicalDeviceImageProcessingFeaturesQCOM() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceImageProcessingFeaturesQCOM::initialize(const VkPhysicalDeviceImageProcessingFeaturesQCOM* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    textureSampleWeighted = in_struct->textureSampleWeighted;
+    textureBoxFilter = in_struct->textureBoxFilter;
+    textureBlockMatch = in_struct->textureBlockMatch;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceImageProcessingFeaturesQCOM::initialize(const safe_VkPhysicalDeviceImageProcessingFeaturesQCOM* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    textureSampleWeighted = copy_src->textureSampleWeighted;
+    textureBoxFilter = copy_src->textureBoxFilter;
+    textureBlockMatch = copy_src->textureBlockMatch;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceImageProcessingPropertiesQCOM::safe_VkPhysicalDeviceImageProcessingPropertiesQCOM(
+    const VkPhysicalDeviceImageProcessingPropertiesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      maxWeightFilterPhases(in_struct->maxWeightFilterPhases),
+      maxWeightFilterDimension(in_struct->maxWeightFilterDimension),
+      maxBlockMatchRegion(in_struct->maxBlockMatchRegion),
+      maxBoxFilterBlockSize(in_struct->maxBoxFilterBlockSize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceImageProcessingPropertiesQCOM::safe_VkPhysicalDeviceImageProcessingPropertiesQCOM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM),
+      pNext(nullptr),
+      maxWeightFilterPhases(),
+      maxWeightFilterDimension(),
+      maxBlockMatchRegion(),
+      maxBoxFilterBlockSize() {}
+
+safe_VkPhysicalDeviceImageProcessingPropertiesQCOM::safe_VkPhysicalDeviceImageProcessingPropertiesQCOM(
+    const safe_VkPhysicalDeviceImageProcessingPropertiesQCOM& copy_src) {
+    sType = copy_src.sType;
+    maxWeightFilterPhases = copy_src.maxWeightFilterPhases;
+    maxWeightFilterDimension = copy_src.maxWeightFilterDimension;
+    maxBlockMatchRegion = copy_src.maxBlockMatchRegion;
+    maxBoxFilterBlockSize = copy_src.maxBoxFilterBlockSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceImageProcessingPropertiesQCOM& safe_VkPhysicalDeviceImageProcessingPropertiesQCOM::operator=(
+    const safe_VkPhysicalDeviceImageProcessingPropertiesQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxWeightFilterPhases = copy_src.maxWeightFilterPhases;
+    maxWeightFilterDimension = copy_src.maxWeightFilterDimension;
+    maxBlockMatchRegion = copy_src.maxBlockMatchRegion;
+    maxBoxFilterBlockSize = copy_src.maxBoxFilterBlockSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceImageProcessingPropertiesQCOM::~safe_VkPhysicalDeviceImageProcessingPropertiesQCOM() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceImageProcessingPropertiesQCOM::initialize(const VkPhysicalDeviceImageProcessingPropertiesQCOM* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxWeightFilterPhases = in_struct->maxWeightFilterPhases;
+    maxWeightFilterDimension = in_struct->maxWeightFilterDimension;
+    maxBlockMatchRegion = in_struct->maxBlockMatchRegion;
+    maxBoxFilterBlockSize = in_struct->maxBoxFilterBlockSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceImageProcessingPropertiesQCOM::initialize(
+    const safe_VkPhysicalDeviceImageProcessingPropertiesQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxWeightFilterPhases = copy_src->maxWeightFilterPhases;
+    maxWeightFilterDimension = copy_src->maxWeightFilterDimension;
+    maxBlockMatchRegion = copy_src->maxBlockMatchRegion;
+    maxBoxFilterBlockSize = copy_src->maxBoxFilterBlockSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDirectDriverLoadingInfoLUNARG::safe_VkDirectDriverLoadingInfoLUNARG(const VkDirectDriverLoadingInfoLUNARG* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags), pfnGetInstanceProcAddr(in_struct->pfnGetInstanceProcAddr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDirectDriverLoadingInfoLUNARG::safe_VkDirectDriverLoadingInfoLUNARG()
+    : sType(VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG), pNext(nullptr), flags(), pfnGetInstanceProcAddr() {}
+
+safe_VkDirectDriverLoadingInfoLUNARG::safe_VkDirectDriverLoadingInfoLUNARG(const safe_VkDirectDriverLoadingInfoLUNARG& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pfnGetInstanceProcAddr = copy_src.pfnGetInstanceProcAddr;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDirectDriverLoadingInfoLUNARG& safe_VkDirectDriverLoadingInfoLUNARG::operator=(
+    const safe_VkDirectDriverLoadingInfoLUNARG& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pfnGetInstanceProcAddr = copy_src.pfnGetInstanceProcAddr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDirectDriverLoadingInfoLUNARG::~safe_VkDirectDriverLoadingInfoLUNARG() { FreePnextChain(pNext); }
+
+void safe_VkDirectDriverLoadingInfoLUNARG::initialize(const VkDirectDriverLoadingInfoLUNARG* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    pfnGetInstanceProcAddr = in_struct->pfnGetInstanceProcAddr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDirectDriverLoadingInfoLUNARG::initialize(const safe_VkDirectDriverLoadingInfoLUNARG* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pfnGetInstanceProcAddr = copy_src->pfnGetInstanceProcAddr;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDirectDriverLoadingListLUNARG::safe_VkDirectDriverLoadingListLUNARG(const VkDirectDriverLoadingListLUNARG* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), mode(in_struct->mode), driverCount(in_struct->driverCount), pDrivers(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (driverCount && in_struct->pDrivers) {
+        pDrivers = new safe_VkDirectDriverLoadingInfoLUNARG[driverCount];
+        for (uint32_t i = 0; i < driverCount; ++i) {
+            pDrivers[i].initialize(&in_struct->pDrivers[i]);
+        }
+    }
+}
+
+safe_VkDirectDriverLoadingListLUNARG::safe_VkDirectDriverLoadingListLUNARG()
+    : sType(VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG), pNext(nullptr), mode(), driverCount(), pDrivers(nullptr) {}
+
+safe_VkDirectDriverLoadingListLUNARG::safe_VkDirectDriverLoadingListLUNARG(const safe_VkDirectDriverLoadingListLUNARG& copy_src) {
+    sType = copy_src.sType;
+    mode = copy_src.mode;
+    driverCount = copy_src.driverCount;
+    pDrivers = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (driverCount && copy_src.pDrivers) {
+        pDrivers = new safe_VkDirectDriverLoadingInfoLUNARG[driverCount];
+        for (uint32_t i = 0; i < driverCount; ++i) {
+            pDrivers[i].initialize(&copy_src.pDrivers[i]);
+        }
+    }
+}
+
+safe_VkDirectDriverLoadingListLUNARG& safe_VkDirectDriverLoadingListLUNARG::operator=(
+    const safe_VkDirectDriverLoadingListLUNARG& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pDrivers) delete[] pDrivers;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    mode = copy_src.mode;
+    driverCount = copy_src.driverCount;
+    pDrivers = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (driverCount && copy_src.pDrivers) {
+        pDrivers = new safe_VkDirectDriverLoadingInfoLUNARG[driverCount];
+        for (uint32_t i = 0; i < driverCount; ++i) {
+            pDrivers[i].initialize(&copy_src.pDrivers[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkDirectDriverLoadingListLUNARG::~safe_VkDirectDriverLoadingListLUNARG() {
+    if (pDrivers) delete[] pDrivers;
+    FreePnextChain(pNext);
+}
+
+void safe_VkDirectDriverLoadingListLUNARG::initialize(const VkDirectDriverLoadingListLUNARG* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pDrivers) delete[] pDrivers;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    mode = in_struct->mode;
+    driverCount = in_struct->driverCount;
+    pDrivers = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (driverCount && in_struct->pDrivers) {
+        pDrivers = new safe_VkDirectDriverLoadingInfoLUNARG[driverCount];
+        for (uint32_t i = 0; i < driverCount; ++i) {
+            pDrivers[i].initialize(&in_struct->pDrivers[i]);
+        }
+    }
+}
+
+void safe_VkDirectDriverLoadingListLUNARG::initialize(const safe_VkDirectDriverLoadingListLUNARG* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    mode = copy_src->mode;
+    driverCount = copy_src->driverCount;
+    pDrivers = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (driverCount && copy_src->pDrivers) {
+        pDrivers = new safe_VkDirectDriverLoadingInfoLUNARG[driverCount];
+        for (uint32_t i = 0; i < driverCount; ++i) {
+            pDrivers[i].initialize(&copy_src->pDrivers[i]);
+        }
+    }
+}
+
+safe_VkPhysicalDeviceOpticalFlowFeaturesNV::safe_VkPhysicalDeviceOpticalFlowFeaturesNV(
+    const VkPhysicalDeviceOpticalFlowFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), opticalFlow(in_struct->opticalFlow) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceOpticalFlowFeaturesNV::safe_VkPhysicalDeviceOpticalFlowFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV), pNext(nullptr), opticalFlow() {}
+
+safe_VkPhysicalDeviceOpticalFlowFeaturesNV::safe_VkPhysicalDeviceOpticalFlowFeaturesNV(
+    const safe_VkPhysicalDeviceOpticalFlowFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    opticalFlow = copy_src.opticalFlow;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceOpticalFlowFeaturesNV& safe_VkPhysicalDeviceOpticalFlowFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceOpticalFlowFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    opticalFlow = copy_src.opticalFlow;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceOpticalFlowFeaturesNV::~safe_VkPhysicalDeviceOpticalFlowFeaturesNV() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceOpticalFlowFeaturesNV::initialize(const VkPhysicalDeviceOpticalFlowFeaturesNV* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    opticalFlow = in_struct->opticalFlow;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceOpticalFlowFeaturesNV::initialize(const safe_VkPhysicalDeviceOpticalFlowFeaturesNV* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    opticalFlow = copy_src->opticalFlow;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceOpticalFlowPropertiesNV::safe_VkPhysicalDeviceOpticalFlowPropertiesNV(
+    const VkPhysicalDeviceOpticalFlowPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      supportedOutputGridSizes(in_struct->supportedOutputGridSizes),
+      supportedHintGridSizes(in_struct->supportedHintGridSizes),
+      hintSupported(in_struct->hintSupported),
+      costSupported(in_struct->costSupported),
+      bidirectionalFlowSupported(in_struct->bidirectionalFlowSupported),
+      globalFlowSupported(in_struct->globalFlowSupported),
+      minWidth(in_struct->minWidth),
+      minHeight(in_struct->minHeight),
+      maxWidth(in_struct->maxWidth),
+      maxHeight(in_struct->maxHeight),
+      maxNumRegionsOfInterest(in_struct->maxNumRegionsOfInterest) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceOpticalFlowPropertiesNV::safe_VkPhysicalDeviceOpticalFlowPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV),
+      pNext(nullptr),
+      supportedOutputGridSizes(),
+      supportedHintGridSizes(),
+      hintSupported(),
+      costSupported(),
+      bidirectionalFlowSupported(),
+      globalFlowSupported(),
+      minWidth(),
+      minHeight(),
+      maxWidth(),
+      maxHeight(),
+      maxNumRegionsOfInterest() {}
+
+safe_VkPhysicalDeviceOpticalFlowPropertiesNV::safe_VkPhysicalDeviceOpticalFlowPropertiesNV(
+    const safe_VkPhysicalDeviceOpticalFlowPropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    supportedOutputGridSizes = copy_src.supportedOutputGridSizes;
+    supportedHintGridSizes = copy_src.supportedHintGridSizes;
+    hintSupported = copy_src.hintSupported;
+    costSupported = copy_src.costSupported;
+    bidirectionalFlowSupported = copy_src.bidirectionalFlowSupported;
+    globalFlowSupported = copy_src.globalFlowSupported;
+    minWidth = copy_src.minWidth;
+    minHeight = copy_src.minHeight;
+    maxWidth = copy_src.maxWidth;
+    maxHeight = copy_src.maxHeight;
+    maxNumRegionsOfInterest = copy_src.maxNumRegionsOfInterest;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceOpticalFlowPropertiesNV& safe_VkPhysicalDeviceOpticalFlowPropertiesNV::operator=(
+    const safe_VkPhysicalDeviceOpticalFlowPropertiesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    supportedOutputGridSizes = copy_src.supportedOutputGridSizes;
+    supportedHintGridSizes = copy_src.supportedHintGridSizes;
+    hintSupported = copy_src.hintSupported;
+    costSupported = copy_src.costSupported;
+    bidirectionalFlowSupported = copy_src.bidirectionalFlowSupported;
+    globalFlowSupported = copy_src.globalFlowSupported;
+    minWidth = copy_src.minWidth;
+    minHeight = copy_src.minHeight;
+    maxWidth = copy_src.maxWidth;
+    maxHeight = copy_src.maxHeight;
+    maxNumRegionsOfInterest = copy_src.maxNumRegionsOfInterest;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceOpticalFlowPropertiesNV::~safe_VkPhysicalDeviceOpticalFlowPropertiesNV() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceOpticalFlowPropertiesNV::initialize(const VkPhysicalDeviceOpticalFlowPropertiesNV* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    supportedOutputGridSizes = in_struct->supportedOutputGridSizes;
+    supportedHintGridSizes = in_struct->supportedHintGridSizes;
+    hintSupported = in_struct->hintSupported;
+    costSupported = in_struct->costSupported;
+    bidirectionalFlowSupported = in_struct->bidirectionalFlowSupported;
+    globalFlowSupported = in_struct->globalFlowSupported;
+    minWidth = in_struct->minWidth;
+    minHeight = in_struct->minHeight;
+    maxWidth = in_struct->maxWidth;
+    maxHeight = in_struct->maxHeight;
+    maxNumRegionsOfInterest = in_struct->maxNumRegionsOfInterest;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceOpticalFlowPropertiesNV::initialize(const safe_VkPhysicalDeviceOpticalFlowPropertiesNV* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    supportedOutputGridSizes = copy_src->supportedOutputGridSizes;
+    supportedHintGridSizes = copy_src->supportedHintGridSizes;
+    hintSupported = copy_src->hintSupported;
+    costSupported = copy_src->costSupported;
+    bidirectionalFlowSupported = copy_src->bidirectionalFlowSupported;
+    globalFlowSupported = copy_src->globalFlowSupported;
+    minWidth = copy_src->minWidth;
+    minHeight = copy_src->minHeight;
+    maxWidth = copy_src->maxWidth;
+    maxHeight = copy_src->maxHeight;
+    maxNumRegionsOfInterest = copy_src->maxNumRegionsOfInterest;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkOpticalFlowImageFormatInfoNV::safe_VkOpticalFlowImageFormatInfoNV(const VkOpticalFlowImageFormatInfoNV* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType), usage(in_struct->usage) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkOpticalFlowImageFormatInfoNV::safe_VkOpticalFlowImageFormatInfoNV()
+    : sType(VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV), pNext(nullptr), usage() {}
+
+safe_VkOpticalFlowImageFormatInfoNV::safe_VkOpticalFlowImageFormatInfoNV(const safe_VkOpticalFlowImageFormatInfoNV& copy_src) {
+    sType = copy_src.sType;
+    usage = copy_src.usage;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkOpticalFlowImageFormatInfoNV& safe_VkOpticalFlowImageFormatInfoNV::operator=(
+    const safe_VkOpticalFlowImageFormatInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    usage = copy_src.usage;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkOpticalFlowImageFormatInfoNV::~safe_VkOpticalFlowImageFormatInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkOpticalFlowImageFormatInfoNV::initialize(const VkOpticalFlowImageFormatInfoNV* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    usage = in_struct->usage;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkOpticalFlowImageFormatInfoNV::initialize(const safe_VkOpticalFlowImageFormatInfoNV* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    usage = copy_src->usage;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkOpticalFlowImageFormatPropertiesNV::safe_VkOpticalFlowImageFormatPropertiesNV(
+    const VkOpticalFlowImageFormatPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), format(in_struct->format) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkOpticalFlowImageFormatPropertiesNV::safe_VkOpticalFlowImageFormatPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV), pNext(nullptr), format() {}
+
+safe_VkOpticalFlowImageFormatPropertiesNV::safe_VkOpticalFlowImageFormatPropertiesNV(
+    const safe_VkOpticalFlowImageFormatPropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    format = copy_src.format;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkOpticalFlowImageFormatPropertiesNV& safe_VkOpticalFlowImageFormatPropertiesNV::operator=(
+    const safe_VkOpticalFlowImageFormatPropertiesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    format = copy_src.format;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkOpticalFlowImageFormatPropertiesNV::~safe_VkOpticalFlowImageFormatPropertiesNV() { FreePnextChain(pNext); }
+
+void safe_VkOpticalFlowImageFormatPropertiesNV::initialize(const VkOpticalFlowImageFormatPropertiesNV* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    format = in_struct->format;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkOpticalFlowImageFormatPropertiesNV::initialize(const safe_VkOpticalFlowImageFormatPropertiesNV* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    format = copy_src->format;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkOpticalFlowSessionCreateInfoNV::safe_VkOpticalFlowSessionCreateInfoNV(const VkOpticalFlowSessionCreateInfoNV* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType),
+      width(in_struct->width),
+      height(in_struct->height),
+      imageFormat(in_struct->imageFormat),
+      flowVectorFormat(in_struct->flowVectorFormat),
+      costFormat(in_struct->costFormat),
+      outputGridSize(in_struct->outputGridSize),
+      hintGridSize(in_struct->hintGridSize),
+      performanceLevel(in_struct->performanceLevel),
+      flags(in_struct->flags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkOpticalFlowSessionCreateInfoNV::safe_VkOpticalFlowSessionCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV),
+      pNext(nullptr),
+      width(),
+      height(),
+      imageFormat(),
+      flowVectorFormat(),
+      costFormat(),
+      outputGridSize(),
+      hintGridSize(),
+      performanceLevel(),
+      flags() {}
+
+safe_VkOpticalFlowSessionCreateInfoNV::safe_VkOpticalFlowSessionCreateInfoNV(
+    const safe_VkOpticalFlowSessionCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    width = copy_src.width;
+    height = copy_src.height;
+    imageFormat = copy_src.imageFormat;
+    flowVectorFormat = copy_src.flowVectorFormat;
+    costFormat = copy_src.costFormat;
+    outputGridSize = copy_src.outputGridSize;
+    hintGridSize = copy_src.hintGridSize;
+    performanceLevel = copy_src.performanceLevel;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkOpticalFlowSessionCreateInfoNV& safe_VkOpticalFlowSessionCreateInfoNV::operator=(
+    const safe_VkOpticalFlowSessionCreateInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    width = copy_src.width;
+    height = copy_src.height;
+    imageFormat = copy_src.imageFormat;
+    flowVectorFormat = copy_src.flowVectorFormat;
+    costFormat = copy_src.costFormat;
+    outputGridSize = copy_src.outputGridSize;
+    hintGridSize = copy_src.hintGridSize;
+    performanceLevel = copy_src.performanceLevel;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkOpticalFlowSessionCreateInfoNV::~safe_VkOpticalFlowSessionCreateInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkOpticalFlowSessionCreateInfoNV::initialize(const VkOpticalFlowSessionCreateInfoNV* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    width = in_struct->width;
+    height = in_struct->height;
+    imageFormat = in_struct->imageFormat;
+    flowVectorFormat = in_struct->flowVectorFormat;
+    costFormat = in_struct->costFormat;
+    outputGridSize = in_struct->outputGridSize;
+    hintGridSize = in_struct->hintGridSize;
+    performanceLevel = in_struct->performanceLevel;
+    flags = in_struct->flags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkOpticalFlowSessionCreateInfoNV::initialize(const safe_VkOpticalFlowSessionCreateInfoNV* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    width = copy_src->width;
+    height = copy_src->height;
+    imageFormat = copy_src->imageFormat;
+    flowVectorFormat = copy_src->flowVectorFormat;
+    costFormat = copy_src->costFormat;
+    outputGridSize = copy_src->outputGridSize;
+    hintGridSize = copy_src->hintGridSize;
+    performanceLevel = copy_src->performanceLevel;
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkOpticalFlowSessionCreatePrivateDataInfoNV::safe_VkOpticalFlowSessionCreatePrivateDataInfoNV(
+    const VkOpticalFlowSessionCreatePrivateDataInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), id(in_struct->id), size(in_struct->size), pPrivateData(in_struct->pPrivateData) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkOpticalFlowSessionCreatePrivateDataInfoNV::safe_VkOpticalFlowSessionCreatePrivateDataInfoNV()
+    : sType(VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV),
+      pNext(nullptr),
+      id(),
+      size(),
+      pPrivateData(nullptr) {}
+
+safe_VkOpticalFlowSessionCreatePrivateDataInfoNV::safe_VkOpticalFlowSessionCreatePrivateDataInfoNV(
+    const safe_VkOpticalFlowSessionCreatePrivateDataInfoNV& copy_src) {
+    sType = copy_src.sType;
+    id = copy_src.id;
+    size = copy_src.size;
+    pPrivateData = copy_src.pPrivateData;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkOpticalFlowSessionCreatePrivateDataInfoNV& safe_VkOpticalFlowSessionCreatePrivateDataInfoNV::operator=(
+    const safe_VkOpticalFlowSessionCreatePrivateDataInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    id = copy_src.id;
+    size = copy_src.size;
+    pPrivateData = copy_src.pPrivateData;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkOpticalFlowSessionCreatePrivateDataInfoNV::~safe_VkOpticalFlowSessionCreatePrivateDataInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkOpticalFlowSessionCreatePrivateDataInfoNV::initialize(const VkOpticalFlowSessionCreatePrivateDataInfoNV* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    id = in_struct->id;
+    size = in_struct->size;
+    pPrivateData = in_struct->pPrivateData;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkOpticalFlowSessionCreatePrivateDataInfoNV::initialize(const safe_VkOpticalFlowSessionCreatePrivateDataInfoNV* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    id = copy_src->id;
+    size = copy_src->size;
+    pPrivateData = copy_src->pPrivateData;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkOpticalFlowExecuteInfoNV::safe_VkOpticalFlowExecuteInfoNV(const VkOpticalFlowExecuteInfoNV* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags), regionCount(in_struct->regionCount), pRegions(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pRegions) {
+        pRegions = new VkRect2D[in_struct->regionCount];
+        memcpy((void*)pRegions, (void*)in_struct->pRegions, sizeof(VkRect2D) * in_struct->regionCount);
+    }
+}
+
+safe_VkOpticalFlowExecuteInfoNV::safe_VkOpticalFlowExecuteInfoNV()
+    : sType(VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV), pNext(nullptr), flags(), regionCount(), pRegions(nullptr) {}
+
+safe_VkOpticalFlowExecuteInfoNV::safe_VkOpticalFlowExecuteInfoNV(const safe_VkOpticalFlowExecuteInfoNV& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    regionCount = copy_src.regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pRegions) {
+        pRegions = new VkRect2D[copy_src.regionCount];
+        memcpy((void*)pRegions, (void*)copy_src.pRegions, sizeof(VkRect2D) * copy_src.regionCount);
+    }
+}
+
+safe_VkOpticalFlowExecuteInfoNV& safe_VkOpticalFlowExecuteInfoNV::operator=(const safe_VkOpticalFlowExecuteInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    regionCount = copy_src.regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pRegions) {
+        pRegions = new VkRect2D[copy_src.regionCount];
+        memcpy((void*)pRegions, (void*)copy_src.pRegions, sizeof(VkRect2D) * copy_src.regionCount);
+    }
+
+    return *this;
+}
+
+safe_VkOpticalFlowExecuteInfoNV::~safe_VkOpticalFlowExecuteInfoNV() {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+}
+
+void safe_VkOpticalFlowExecuteInfoNV::initialize(const VkOpticalFlowExecuteInfoNV* in_struct,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    regionCount = in_struct->regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pRegions) {
+        pRegions = new VkRect2D[in_struct->regionCount];
+        memcpy((void*)pRegions, (void*)in_struct->pRegions, sizeof(VkRect2D) * in_struct->regionCount);
+    }
+}
+
+void safe_VkOpticalFlowExecuteInfoNV::initialize(const safe_VkOpticalFlowExecuteInfoNV* copy_src,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    regionCount = copy_src->regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pRegions) {
+        pRegions = new VkRect2D[copy_src->regionCount];
+        memcpy((void*)pRegions, (void*)copy_src->pRegions, sizeof(VkRect2D) * copy_src->regionCount);
+    }
+}
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+
+safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID::safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID(
+    const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), externalFormatResolve(in_struct->externalFormatResolve) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID::safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID), pNext(nullptr), externalFormatResolve() {}
+
+safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID::safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID(
+    const safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID& copy_src) {
+    sType = copy_src.sType;
+    externalFormatResolve = copy_src.externalFormatResolve;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID& safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID::operator=(
+    const safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    externalFormatResolve = copy_src.externalFormatResolve;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID::~safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID::initialize(
+    const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    externalFormatResolve = in_struct->externalFormatResolve;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID::initialize(
+    const safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    externalFormatResolve = copy_src->externalFormatResolve;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID::safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID(
+    const VkPhysicalDeviceExternalFormatResolvePropertiesANDROID* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      nullColorAttachmentWithExternalFormatResolve(in_struct->nullColorAttachmentWithExternalFormatResolve),
+      externalFormatResolveChromaOffsetX(in_struct->externalFormatResolveChromaOffsetX),
+      externalFormatResolveChromaOffsetY(in_struct->externalFormatResolveChromaOffsetY) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID::safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID),
+      pNext(nullptr),
+      nullColorAttachmentWithExternalFormatResolve(),
+      externalFormatResolveChromaOffsetX(),
+      externalFormatResolveChromaOffsetY() {}
+
+safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID::safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID(
+    const safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID& copy_src) {
+    sType = copy_src.sType;
+    nullColorAttachmentWithExternalFormatResolve = copy_src.nullColorAttachmentWithExternalFormatResolve;
+    externalFormatResolveChromaOffsetX = copy_src.externalFormatResolveChromaOffsetX;
+    externalFormatResolveChromaOffsetY = copy_src.externalFormatResolveChromaOffsetY;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID& safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID::operator=(
+    const safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    nullColorAttachmentWithExternalFormatResolve = copy_src.nullColorAttachmentWithExternalFormatResolve;
+    externalFormatResolveChromaOffsetX = copy_src.externalFormatResolveChromaOffsetX;
+    externalFormatResolveChromaOffsetY = copy_src.externalFormatResolveChromaOffsetY;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID::~safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID::initialize(
+    const VkPhysicalDeviceExternalFormatResolvePropertiesANDROID* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    nullColorAttachmentWithExternalFormatResolve = in_struct->nullColorAttachmentWithExternalFormatResolve;
+    externalFormatResolveChromaOffsetX = in_struct->externalFormatResolveChromaOffsetX;
+    externalFormatResolveChromaOffsetY = in_struct->externalFormatResolveChromaOffsetY;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID::initialize(
+    const safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    nullColorAttachmentWithExternalFormatResolve = copy_src->nullColorAttachmentWithExternalFormatResolve;
+    externalFormatResolveChromaOffsetX = copy_src->externalFormatResolveChromaOffsetX;
+    externalFormatResolveChromaOffsetY = copy_src->externalFormatResolveChromaOffsetY;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID::safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID(
+    const VkAndroidHardwareBufferFormatResolvePropertiesANDROID* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), colorAttachmentFormat(in_struct->colorAttachmentFormat) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID::safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID()
+    : sType(VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID), pNext(nullptr), colorAttachmentFormat() {}
+
+safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID::safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID(
+    const safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID& copy_src) {
+    sType = copy_src.sType;
+    colorAttachmentFormat = copy_src.colorAttachmentFormat;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID& safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID::operator=(
+    const safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    colorAttachmentFormat = copy_src.colorAttachmentFormat;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID::~safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID::initialize(
+    const VkAndroidHardwareBufferFormatResolvePropertiesANDROID* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    colorAttachmentFormat = in_struct->colorAttachmentFormat;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID::initialize(
+    const safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    colorAttachmentFormat = copy_src->colorAttachmentFormat;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+#endif  // VK_USE_PLATFORM_ANDROID_KHR
+
+safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM::safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
+    const VkPhysicalDeviceTilePropertiesFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), tileProperties(in_struct->tileProperties) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM::safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM), pNext(nullptr), tileProperties() {}
+
+safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM::safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
+    const safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM& copy_src) {
+    sType = copy_src.sType;
+    tileProperties = copy_src.tileProperties;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM& safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM::operator=(
+    const safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    tileProperties = copy_src.tileProperties;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM::~safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM::initialize(const VkPhysicalDeviceTilePropertiesFeaturesQCOM* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    tileProperties = in_struct->tileProperties;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM::initialize(const safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    tileProperties = copy_src->tileProperties;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkTilePropertiesQCOM::safe_VkTilePropertiesQCOM(const VkTilePropertiesQCOM* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), tileSize(in_struct->tileSize), apronSize(in_struct->apronSize), origin(in_struct->origin) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkTilePropertiesQCOM::safe_VkTilePropertiesQCOM()
+    : sType(VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM), pNext(nullptr), tileSize(), apronSize(), origin() {}
+
+safe_VkTilePropertiesQCOM::safe_VkTilePropertiesQCOM(const safe_VkTilePropertiesQCOM& copy_src) {
+    sType = copy_src.sType;
+    tileSize = copy_src.tileSize;
+    apronSize = copy_src.apronSize;
+    origin = copy_src.origin;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkTilePropertiesQCOM& safe_VkTilePropertiesQCOM::operator=(const safe_VkTilePropertiesQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    tileSize = copy_src.tileSize;
+    apronSize = copy_src.apronSize;
+    origin = copy_src.origin;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkTilePropertiesQCOM::~safe_VkTilePropertiesQCOM() { FreePnextChain(pNext); }
+
+void safe_VkTilePropertiesQCOM::initialize(const VkTilePropertiesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    tileSize = in_struct->tileSize;
+    apronSize = in_struct->apronSize;
+    origin = in_struct->origin;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkTilePropertiesQCOM::initialize(const safe_VkTilePropertiesQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    tileSize = copy_src->tileSize;
+    apronSize = copy_src->apronSize;
+    origin = copy_src->origin;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC::safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
+    const VkPhysicalDeviceAmigoProfilingFeaturesSEC* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), amigoProfiling(in_struct->amigoProfiling) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC::safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC), pNext(nullptr), amigoProfiling() {}
+
+safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC::safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
+    const safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC& copy_src) {
+    sType = copy_src.sType;
+    amigoProfiling = copy_src.amigoProfiling;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC& safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC::operator=(
+    const safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    amigoProfiling = copy_src.amigoProfiling;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC::~safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC::initialize(const VkPhysicalDeviceAmigoProfilingFeaturesSEC* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    amigoProfiling = in_struct->amigoProfiling;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC::initialize(const safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    amigoProfiling = copy_src->amigoProfiling;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkAmigoProfilingSubmitInfoSEC::safe_VkAmigoProfilingSubmitInfoSEC(const VkAmigoProfilingSubmitInfoSEC* in_struct,
+                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      firstDrawTimestamp(in_struct->firstDrawTimestamp),
+      swapBufferTimestamp(in_struct->swapBufferTimestamp) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkAmigoProfilingSubmitInfoSEC::safe_VkAmigoProfilingSubmitInfoSEC()
+    : sType(VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC), pNext(nullptr), firstDrawTimestamp(), swapBufferTimestamp() {}
+
+safe_VkAmigoProfilingSubmitInfoSEC::safe_VkAmigoProfilingSubmitInfoSEC(const safe_VkAmigoProfilingSubmitInfoSEC& copy_src) {
+    sType = copy_src.sType;
+    firstDrawTimestamp = copy_src.firstDrawTimestamp;
+    swapBufferTimestamp = copy_src.swapBufferTimestamp;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkAmigoProfilingSubmitInfoSEC& safe_VkAmigoProfilingSubmitInfoSEC::operator=(
+    const safe_VkAmigoProfilingSubmitInfoSEC& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    firstDrawTimestamp = copy_src.firstDrawTimestamp;
+    swapBufferTimestamp = copy_src.swapBufferTimestamp;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkAmigoProfilingSubmitInfoSEC::~safe_VkAmigoProfilingSubmitInfoSEC() { FreePnextChain(pNext); }
+
+void safe_VkAmigoProfilingSubmitInfoSEC::initialize(const VkAmigoProfilingSubmitInfoSEC* in_struct,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    firstDrawTimestamp = in_struct->firstDrawTimestamp;
+    swapBufferTimestamp = in_struct->swapBufferTimestamp;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkAmigoProfilingSubmitInfoSEC::initialize(const safe_VkAmigoProfilingSubmitInfoSEC* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    firstDrawTimestamp = copy_src->firstDrawTimestamp;
+    swapBufferTimestamp = copy_src->swapBufferTimestamp;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM::safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
+    const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), multiviewPerViewViewports(in_struct->multiviewPerViewViewports) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM::safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM),
+      pNext(nullptr),
+      multiviewPerViewViewports() {}
+
+safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM::safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
+    const safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM& copy_src) {
+    sType = copy_src.sType;
+    multiviewPerViewViewports = copy_src.multiviewPerViewViewports;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM& safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM::operator=(
+    const safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    multiviewPerViewViewports = copy_src.multiviewPerViewViewports;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM::~safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM::initialize(
+    const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    multiviewPerViewViewports = in_struct->multiviewPerViewViewports;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM::initialize(
+    const safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    multiviewPerViewViewports = copy_src->multiviewPerViewViewports;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV::safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
+    const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), rayTracingInvocationReorderReorderingHint(in_struct->rayTracingInvocationReorderReorderingHint) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV::safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV),
+      pNext(nullptr),
+      rayTracingInvocationReorderReorderingHint() {}
+
+safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV::safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
+    const safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    rayTracingInvocationReorderReorderingHint = copy_src.rayTracingInvocationReorderReorderingHint;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV&
+safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV::operator=(
+    const safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    rayTracingInvocationReorderReorderingHint = copy_src.rayTracingInvocationReorderReorderingHint;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV::~safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV::initialize(
+    const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    rayTracingInvocationReorderReorderingHint = in_struct->rayTracingInvocationReorderReorderingHint;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV::initialize(
+    const safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    rayTracingInvocationReorderReorderingHint = copy_src->rayTracingInvocationReorderReorderingHint;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV::safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
+    const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), rayTracingInvocationReorder(in_struct->rayTracingInvocationReorder) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV::safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV),
+      pNext(nullptr),
+      rayTracingInvocationReorder() {}
+
+safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV::safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
+    const safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    rayTracingInvocationReorder = copy_src.rayTracingInvocationReorder;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV& safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    rayTracingInvocationReorder = copy_src.rayTracingInvocationReorder;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV::~safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV::initialize(
+    const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    rayTracingInvocationReorder = in_struct->rayTracingInvocationReorder;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV::initialize(
+    const safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    rayTracingInvocationReorder = copy_src->rayTracingInvocationReorder;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV::safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV(
+    const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), extendedSparseAddressSpace(in_struct->extendedSparseAddressSpace) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV::safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV),
+      pNext(nullptr),
+      extendedSparseAddressSpace() {}
+
+safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV::safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV(
+    const safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    extendedSparseAddressSpace = copy_src.extendedSparseAddressSpace;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV& safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    extendedSparseAddressSpace = copy_src.extendedSparseAddressSpace;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV::~safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV::initialize(
+    const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    extendedSparseAddressSpace = in_struct->extendedSparseAddressSpace;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV::initialize(
+    const safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    extendedSparseAddressSpace = copy_src->extendedSparseAddressSpace;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV::safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV(
+    const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      extendedSparseAddressSpaceSize(in_struct->extendedSparseAddressSpaceSize),
+      extendedSparseImageUsageFlags(in_struct->extendedSparseImageUsageFlags),
+      extendedSparseBufferUsageFlags(in_struct->extendedSparseBufferUsageFlags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV::safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV),
+      pNext(nullptr),
+      extendedSparseAddressSpaceSize(),
+      extendedSparseImageUsageFlags(),
+      extendedSparseBufferUsageFlags() {}
+
+safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV::safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV(
+    const safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    extendedSparseAddressSpaceSize = copy_src.extendedSparseAddressSpaceSize;
+    extendedSparseImageUsageFlags = copy_src.extendedSparseImageUsageFlags;
+    extendedSparseBufferUsageFlags = copy_src.extendedSparseBufferUsageFlags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV& safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV::operator=(
+    const safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    extendedSparseAddressSpaceSize = copy_src.extendedSparseAddressSpaceSize;
+    extendedSparseImageUsageFlags = copy_src.extendedSparseImageUsageFlags;
+    extendedSparseBufferUsageFlags = copy_src.extendedSparseBufferUsageFlags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV::~safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV::initialize(
+    const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    extendedSparseAddressSpaceSize = in_struct->extendedSparseAddressSpaceSize;
+    extendedSparseImageUsageFlags = in_struct->extendedSparseImageUsageFlags;
+    extendedSparseBufferUsageFlags = in_struct->extendedSparseBufferUsageFlags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV::initialize(
+    const safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    extendedSparseAddressSpaceSize = copy_src->extendedSparseAddressSpaceSize;
+    extendedSparseImageUsageFlags = copy_src->extendedSparseImageUsageFlags;
+    extendedSparseBufferUsageFlags = copy_src->extendedSparseBufferUsageFlags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM::safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
+    const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), shaderCoreBuiltins(in_struct->shaderCoreBuiltins) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM::safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM), pNext(nullptr), shaderCoreBuiltins() {}
+
+safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM::safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
+    const safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM& copy_src) {
+    sType = copy_src.sType;
+    shaderCoreBuiltins = copy_src.shaderCoreBuiltins;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM& safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM::operator=(
+    const safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderCoreBuiltins = copy_src.shaderCoreBuiltins;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM::~safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM::initialize(const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderCoreBuiltins = in_struct->shaderCoreBuiltins;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM::initialize(
+    const safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderCoreBuiltins = copy_src->shaderCoreBuiltins;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM::safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
+    const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      shaderCoreMask(in_struct->shaderCoreMask),
+      shaderCoreCount(in_struct->shaderCoreCount),
+      shaderWarpsPerCore(in_struct->shaderWarpsPerCore) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM::safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM),
+      pNext(nullptr),
+      shaderCoreMask(),
+      shaderCoreCount(),
+      shaderWarpsPerCore() {}
+
+safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM::safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
+    const safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM& copy_src) {
+    sType = copy_src.sType;
+    shaderCoreMask = copy_src.shaderCoreMask;
+    shaderCoreCount = copy_src.shaderCoreCount;
+    shaderWarpsPerCore = copy_src.shaderWarpsPerCore;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM& safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM::operator=(
+    const safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderCoreMask = copy_src.shaderCoreMask;
+    shaderCoreCount = copy_src.shaderCoreCount;
+    shaderWarpsPerCore = copy_src.shaderWarpsPerCore;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM::~safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM::initialize(
+    const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderCoreMask = in_struct->shaderCoreMask;
+    shaderCoreCount = in_struct->shaderCoreCount;
+    shaderWarpsPerCore = in_struct->shaderWarpsPerCore;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM::initialize(
+    const safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderCoreMask = copy_src->shaderCoreMask;
+    shaderCoreCount = copy_src->shaderCoreCount;
+    shaderWarpsPerCore = copy_src->shaderWarpsPerCore;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkLatencySleepModeInfoNV::safe_VkLatencySleepModeInfoNV(const VkLatencySleepModeInfoNV* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      lowLatencyMode(in_struct->lowLatencyMode),
+      lowLatencyBoost(in_struct->lowLatencyBoost),
+      minimumIntervalUs(in_struct->minimumIntervalUs) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkLatencySleepModeInfoNV::safe_VkLatencySleepModeInfoNV()
+    : sType(VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV),
+      pNext(nullptr),
+      lowLatencyMode(),
+      lowLatencyBoost(),
+      minimumIntervalUs() {}
+
+safe_VkLatencySleepModeInfoNV::safe_VkLatencySleepModeInfoNV(const safe_VkLatencySleepModeInfoNV& copy_src) {
+    sType = copy_src.sType;
+    lowLatencyMode = copy_src.lowLatencyMode;
+    lowLatencyBoost = copy_src.lowLatencyBoost;
+    minimumIntervalUs = copy_src.minimumIntervalUs;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkLatencySleepModeInfoNV& safe_VkLatencySleepModeInfoNV::operator=(const safe_VkLatencySleepModeInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    lowLatencyMode = copy_src.lowLatencyMode;
+    lowLatencyBoost = copy_src.lowLatencyBoost;
+    minimumIntervalUs = copy_src.minimumIntervalUs;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkLatencySleepModeInfoNV::~safe_VkLatencySleepModeInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkLatencySleepModeInfoNV::initialize(const VkLatencySleepModeInfoNV* in_struct,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    lowLatencyMode = in_struct->lowLatencyMode;
+    lowLatencyBoost = in_struct->lowLatencyBoost;
+    minimumIntervalUs = in_struct->minimumIntervalUs;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkLatencySleepModeInfoNV::initialize(const safe_VkLatencySleepModeInfoNV* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    lowLatencyMode = copy_src->lowLatencyMode;
+    lowLatencyBoost = copy_src->lowLatencyBoost;
+    minimumIntervalUs = copy_src->minimumIntervalUs;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkLatencySleepInfoNV::safe_VkLatencySleepInfoNV(const VkLatencySleepInfoNV* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), signalSemaphore(in_struct->signalSemaphore), value(in_struct->value) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkLatencySleepInfoNV::safe_VkLatencySleepInfoNV()
+    : sType(VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV), pNext(nullptr), signalSemaphore(), value() {}
+
+safe_VkLatencySleepInfoNV::safe_VkLatencySleepInfoNV(const safe_VkLatencySleepInfoNV& copy_src) {
+    sType = copy_src.sType;
+    signalSemaphore = copy_src.signalSemaphore;
+    value = copy_src.value;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkLatencySleepInfoNV& safe_VkLatencySleepInfoNV::operator=(const safe_VkLatencySleepInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    signalSemaphore = copy_src.signalSemaphore;
+    value = copy_src.value;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkLatencySleepInfoNV::~safe_VkLatencySleepInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkLatencySleepInfoNV::initialize(const VkLatencySleepInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    signalSemaphore = in_struct->signalSemaphore;
+    value = in_struct->value;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkLatencySleepInfoNV::initialize(const safe_VkLatencySleepInfoNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    signalSemaphore = copy_src->signalSemaphore;
+    value = copy_src->value;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSetLatencyMarkerInfoNV::safe_VkSetLatencyMarkerInfoNV(const VkSetLatencyMarkerInfoNV* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), presentID(in_struct->presentID), marker(in_struct->marker) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSetLatencyMarkerInfoNV::safe_VkSetLatencyMarkerInfoNV()
+    : sType(VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV), pNext(nullptr), presentID(), marker() {}
+
+safe_VkSetLatencyMarkerInfoNV::safe_VkSetLatencyMarkerInfoNV(const safe_VkSetLatencyMarkerInfoNV& copy_src) {
+    sType = copy_src.sType;
+    presentID = copy_src.presentID;
+    marker = copy_src.marker;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSetLatencyMarkerInfoNV& safe_VkSetLatencyMarkerInfoNV::operator=(const safe_VkSetLatencyMarkerInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    presentID = copy_src.presentID;
+    marker = copy_src.marker;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSetLatencyMarkerInfoNV::~safe_VkSetLatencyMarkerInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkSetLatencyMarkerInfoNV::initialize(const VkSetLatencyMarkerInfoNV* in_struct,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    presentID = in_struct->presentID;
+    marker = in_struct->marker;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSetLatencyMarkerInfoNV::initialize(const safe_VkSetLatencyMarkerInfoNV* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    presentID = copy_src->presentID;
+    marker = copy_src->marker;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkLatencyTimingsFrameReportNV::safe_VkLatencyTimingsFrameReportNV(const VkLatencyTimingsFrameReportNV* in_struct,
+                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      presentID(in_struct->presentID),
+      inputSampleTimeUs(in_struct->inputSampleTimeUs),
+      simStartTimeUs(in_struct->simStartTimeUs),
+      simEndTimeUs(in_struct->simEndTimeUs),
+      renderSubmitStartTimeUs(in_struct->renderSubmitStartTimeUs),
+      renderSubmitEndTimeUs(in_struct->renderSubmitEndTimeUs),
+      presentStartTimeUs(in_struct->presentStartTimeUs),
+      presentEndTimeUs(in_struct->presentEndTimeUs),
+      driverStartTimeUs(in_struct->driverStartTimeUs),
+      driverEndTimeUs(in_struct->driverEndTimeUs),
+      osRenderQueueStartTimeUs(in_struct->osRenderQueueStartTimeUs),
+      osRenderQueueEndTimeUs(in_struct->osRenderQueueEndTimeUs),
+      gpuRenderStartTimeUs(in_struct->gpuRenderStartTimeUs),
+      gpuRenderEndTimeUs(in_struct->gpuRenderEndTimeUs) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkLatencyTimingsFrameReportNV::safe_VkLatencyTimingsFrameReportNV()
+    : sType(VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV),
+      pNext(nullptr),
+      presentID(),
+      inputSampleTimeUs(),
+      simStartTimeUs(),
+      simEndTimeUs(),
+      renderSubmitStartTimeUs(),
+      renderSubmitEndTimeUs(),
+      presentStartTimeUs(),
+      presentEndTimeUs(),
+      driverStartTimeUs(),
+      driverEndTimeUs(),
+      osRenderQueueStartTimeUs(),
+      osRenderQueueEndTimeUs(),
+      gpuRenderStartTimeUs(),
+      gpuRenderEndTimeUs() {}
+
+safe_VkLatencyTimingsFrameReportNV::safe_VkLatencyTimingsFrameReportNV(const safe_VkLatencyTimingsFrameReportNV& copy_src) {
+    sType = copy_src.sType;
+    presentID = copy_src.presentID;
+    inputSampleTimeUs = copy_src.inputSampleTimeUs;
+    simStartTimeUs = copy_src.simStartTimeUs;
+    simEndTimeUs = copy_src.simEndTimeUs;
+    renderSubmitStartTimeUs = copy_src.renderSubmitStartTimeUs;
+    renderSubmitEndTimeUs = copy_src.renderSubmitEndTimeUs;
+    presentStartTimeUs = copy_src.presentStartTimeUs;
+    presentEndTimeUs = copy_src.presentEndTimeUs;
+    driverStartTimeUs = copy_src.driverStartTimeUs;
+    driverEndTimeUs = copy_src.driverEndTimeUs;
+    osRenderQueueStartTimeUs = copy_src.osRenderQueueStartTimeUs;
+    osRenderQueueEndTimeUs = copy_src.osRenderQueueEndTimeUs;
+    gpuRenderStartTimeUs = copy_src.gpuRenderStartTimeUs;
+    gpuRenderEndTimeUs = copy_src.gpuRenderEndTimeUs;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkLatencyTimingsFrameReportNV& safe_VkLatencyTimingsFrameReportNV::operator=(
+    const safe_VkLatencyTimingsFrameReportNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    presentID = copy_src.presentID;
+    inputSampleTimeUs = copy_src.inputSampleTimeUs;
+    simStartTimeUs = copy_src.simStartTimeUs;
+    simEndTimeUs = copy_src.simEndTimeUs;
+    renderSubmitStartTimeUs = copy_src.renderSubmitStartTimeUs;
+    renderSubmitEndTimeUs = copy_src.renderSubmitEndTimeUs;
+    presentStartTimeUs = copy_src.presentStartTimeUs;
+    presentEndTimeUs = copy_src.presentEndTimeUs;
+    driverStartTimeUs = copy_src.driverStartTimeUs;
+    driverEndTimeUs = copy_src.driverEndTimeUs;
+    osRenderQueueStartTimeUs = copy_src.osRenderQueueStartTimeUs;
+    osRenderQueueEndTimeUs = copy_src.osRenderQueueEndTimeUs;
+    gpuRenderStartTimeUs = copy_src.gpuRenderStartTimeUs;
+    gpuRenderEndTimeUs = copy_src.gpuRenderEndTimeUs;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkLatencyTimingsFrameReportNV::~safe_VkLatencyTimingsFrameReportNV() { FreePnextChain(pNext); }
+
+void safe_VkLatencyTimingsFrameReportNV::initialize(const VkLatencyTimingsFrameReportNV* in_struct,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    presentID = in_struct->presentID;
+    inputSampleTimeUs = in_struct->inputSampleTimeUs;
+    simStartTimeUs = in_struct->simStartTimeUs;
+    simEndTimeUs = in_struct->simEndTimeUs;
+    renderSubmitStartTimeUs = in_struct->renderSubmitStartTimeUs;
+    renderSubmitEndTimeUs = in_struct->renderSubmitEndTimeUs;
+    presentStartTimeUs = in_struct->presentStartTimeUs;
+    presentEndTimeUs = in_struct->presentEndTimeUs;
+    driverStartTimeUs = in_struct->driverStartTimeUs;
+    driverEndTimeUs = in_struct->driverEndTimeUs;
+    osRenderQueueStartTimeUs = in_struct->osRenderQueueStartTimeUs;
+    osRenderQueueEndTimeUs = in_struct->osRenderQueueEndTimeUs;
+    gpuRenderStartTimeUs = in_struct->gpuRenderStartTimeUs;
+    gpuRenderEndTimeUs = in_struct->gpuRenderEndTimeUs;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkLatencyTimingsFrameReportNV::initialize(const safe_VkLatencyTimingsFrameReportNV* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    presentID = copy_src->presentID;
+    inputSampleTimeUs = copy_src->inputSampleTimeUs;
+    simStartTimeUs = copy_src->simStartTimeUs;
+    simEndTimeUs = copy_src->simEndTimeUs;
+    renderSubmitStartTimeUs = copy_src->renderSubmitStartTimeUs;
+    renderSubmitEndTimeUs = copy_src->renderSubmitEndTimeUs;
+    presentStartTimeUs = copy_src->presentStartTimeUs;
+    presentEndTimeUs = copy_src->presentEndTimeUs;
+    driverStartTimeUs = copy_src->driverStartTimeUs;
+    driverEndTimeUs = copy_src->driverEndTimeUs;
+    osRenderQueueStartTimeUs = copy_src->osRenderQueueStartTimeUs;
+    osRenderQueueEndTimeUs = copy_src->osRenderQueueEndTimeUs;
+    gpuRenderStartTimeUs = copy_src->gpuRenderStartTimeUs;
+    gpuRenderEndTimeUs = copy_src->gpuRenderEndTimeUs;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkGetLatencyMarkerInfoNV::safe_VkGetLatencyMarkerInfoNV(const VkGetLatencyMarkerInfoNV* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), timingCount(in_struct->timingCount), pTimings(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (timingCount && in_struct->pTimings) {
+        pTimings = new safe_VkLatencyTimingsFrameReportNV[timingCount];
+        for (uint32_t i = 0; i < timingCount; ++i) {
+            pTimings[i].initialize(&in_struct->pTimings[i]);
+        }
+    }
+}
+
+safe_VkGetLatencyMarkerInfoNV::safe_VkGetLatencyMarkerInfoNV()
+    : sType(VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV), pNext(nullptr), timingCount(), pTimings(nullptr) {}
+
+safe_VkGetLatencyMarkerInfoNV::safe_VkGetLatencyMarkerInfoNV(const safe_VkGetLatencyMarkerInfoNV& copy_src) {
+    sType = copy_src.sType;
+    timingCount = copy_src.timingCount;
+    pTimings = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (timingCount && copy_src.pTimings) {
+        pTimings = new safe_VkLatencyTimingsFrameReportNV[timingCount];
+        for (uint32_t i = 0; i < timingCount; ++i) {
+            pTimings[i].initialize(&copy_src.pTimings[i]);
+        }
+    }
+}
+
+safe_VkGetLatencyMarkerInfoNV& safe_VkGetLatencyMarkerInfoNV::operator=(const safe_VkGetLatencyMarkerInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pTimings) delete[] pTimings;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    timingCount = copy_src.timingCount;
+    pTimings = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (timingCount && copy_src.pTimings) {
+        pTimings = new safe_VkLatencyTimingsFrameReportNV[timingCount];
+        for (uint32_t i = 0; i < timingCount; ++i) {
+            pTimings[i].initialize(&copy_src.pTimings[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkGetLatencyMarkerInfoNV::~safe_VkGetLatencyMarkerInfoNV() {
+    if (pTimings) delete[] pTimings;
+    FreePnextChain(pNext);
+}
+
+void safe_VkGetLatencyMarkerInfoNV::initialize(const VkGetLatencyMarkerInfoNV* in_struct,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pTimings) delete[] pTimings;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    timingCount = in_struct->timingCount;
+    pTimings = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (timingCount && in_struct->pTimings) {
+        pTimings = new safe_VkLatencyTimingsFrameReportNV[timingCount];
+        for (uint32_t i = 0; i < timingCount; ++i) {
+            pTimings[i].initialize(&in_struct->pTimings[i]);
+        }
+    }
+}
+
+void safe_VkGetLatencyMarkerInfoNV::initialize(const safe_VkGetLatencyMarkerInfoNV* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    timingCount = copy_src->timingCount;
+    pTimings = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (timingCount && copy_src->pTimings) {
+        pTimings = new safe_VkLatencyTimingsFrameReportNV[timingCount];
+        for (uint32_t i = 0; i < timingCount; ++i) {
+            pTimings[i].initialize(&copy_src->pTimings[i]);
+        }
+    }
+}
+
+safe_VkLatencySubmissionPresentIdNV::safe_VkLatencySubmissionPresentIdNV(const VkLatencySubmissionPresentIdNV* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType), presentID(in_struct->presentID) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkLatencySubmissionPresentIdNV::safe_VkLatencySubmissionPresentIdNV()
+    : sType(VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV), pNext(nullptr), presentID() {}
+
+safe_VkLatencySubmissionPresentIdNV::safe_VkLatencySubmissionPresentIdNV(const safe_VkLatencySubmissionPresentIdNV& copy_src) {
+    sType = copy_src.sType;
+    presentID = copy_src.presentID;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkLatencySubmissionPresentIdNV& safe_VkLatencySubmissionPresentIdNV::operator=(
+    const safe_VkLatencySubmissionPresentIdNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    presentID = copy_src.presentID;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkLatencySubmissionPresentIdNV::~safe_VkLatencySubmissionPresentIdNV() { FreePnextChain(pNext); }
+
+void safe_VkLatencySubmissionPresentIdNV::initialize(const VkLatencySubmissionPresentIdNV* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    presentID = in_struct->presentID;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkLatencySubmissionPresentIdNV::initialize(const safe_VkLatencySubmissionPresentIdNV* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    presentID = copy_src->presentID;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSwapchainLatencyCreateInfoNV::safe_VkSwapchainLatencyCreateInfoNV(const VkSwapchainLatencyCreateInfoNV* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType), latencyModeEnable(in_struct->latencyModeEnable) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSwapchainLatencyCreateInfoNV::safe_VkSwapchainLatencyCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV), pNext(nullptr), latencyModeEnable() {}
+
+safe_VkSwapchainLatencyCreateInfoNV::safe_VkSwapchainLatencyCreateInfoNV(const safe_VkSwapchainLatencyCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    latencyModeEnable = copy_src.latencyModeEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSwapchainLatencyCreateInfoNV& safe_VkSwapchainLatencyCreateInfoNV::operator=(
+    const safe_VkSwapchainLatencyCreateInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    latencyModeEnable = copy_src.latencyModeEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSwapchainLatencyCreateInfoNV::~safe_VkSwapchainLatencyCreateInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkSwapchainLatencyCreateInfoNV::initialize(const VkSwapchainLatencyCreateInfoNV* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    latencyModeEnable = in_struct->latencyModeEnable;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSwapchainLatencyCreateInfoNV::initialize(const safe_VkSwapchainLatencyCreateInfoNV* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    latencyModeEnable = copy_src->latencyModeEnable;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkOutOfBandQueueTypeInfoNV::safe_VkOutOfBandQueueTypeInfoNV(const VkOutOfBandQueueTypeInfoNV* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), queueType(in_struct->queueType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkOutOfBandQueueTypeInfoNV::safe_VkOutOfBandQueueTypeInfoNV()
+    : sType(VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV), pNext(nullptr), queueType() {}
+
+safe_VkOutOfBandQueueTypeInfoNV::safe_VkOutOfBandQueueTypeInfoNV(const safe_VkOutOfBandQueueTypeInfoNV& copy_src) {
+    sType = copy_src.sType;
+    queueType = copy_src.queueType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkOutOfBandQueueTypeInfoNV& safe_VkOutOfBandQueueTypeInfoNV::operator=(const safe_VkOutOfBandQueueTypeInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    queueType = copy_src.queueType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkOutOfBandQueueTypeInfoNV::~safe_VkOutOfBandQueueTypeInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkOutOfBandQueueTypeInfoNV::initialize(const VkOutOfBandQueueTypeInfoNV* in_struct,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    queueType = in_struct->queueType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkOutOfBandQueueTypeInfoNV::initialize(const safe_VkOutOfBandQueueTypeInfoNV* copy_src,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    queueType = copy_src->queueType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkLatencySurfaceCapabilitiesNV::safe_VkLatencySurfaceCapabilitiesNV(const VkLatencySurfaceCapabilitiesNV* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType), presentModeCount(in_struct->presentModeCount), pPresentModes(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pPresentModes) {
+        pPresentModes = new VkPresentModeKHR[in_struct->presentModeCount];
+        memcpy((void*)pPresentModes, (void*)in_struct->pPresentModes, sizeof(VkPresentModeKHR) * in_struct->presentModeCount);
+    }
+}
+
+safe_VkLatencySurfaceCapabilitiesNV::safe_VkLatencySurfaceCapabilitiesNV()
+    : sType(VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV), pNext(nullptr), presentModeCount(), pPresentModes(nullptr) {}
+
+safe_VkLatencySurfaceCapabilitiesNV::safe_VkLatencySurfaceCapabilitiesNV(const safe_VkLatencySurfaceCapabilitiesNV& copy_src) {
+    sType = copy_src.sType;
+    presentModeCount = copy_src.presentModeCount;
+    pPresentModes = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pPresentModes) {
+        pPresentModes = new VkPresentModeKHR[copy_src.presentModeCount];
+        memcpy((void*)pPresentModes, (void*)copy_src.pPresentModes, sizeof(VkPresentModeKHR) * copy_src.presentModeCount);
+    }
+}
+
+safe_VkLatencySurfaceCapabilitiesNV& safe_VkLatencySurfaceCapabilitiesNV::operator=(
+    const safe_VkLatencySurfaceCapabilitiesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pPresentModes) delete[] pPresentModes;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    presentModeCount = copy_src.presentModeCount;
+    pPresentModes = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pPresentModes) {
+        pPresentModes = new VkPresentModeKHR[copy_src.presentModeCount];
+        memcpy((void*)pPresentModes, (void*)copy_src.pPresentModes, sizeof(VkPresentModeKHR) * copy_src.presentModeCount);
+    }
+
+    return *this;
+}
+
+safe_VkLatencySurfaceCapabilitiesNV::~safe_VkLatencySurfaceCapabilitiesNV() {
+    if (pPresentModes) delete[] pPresentModes;
+    FreePnextChain(pNext);
+}
+
+void safe_VkLatencySurfaceCapabilitiesNV::initialize(const VkLatencySurfaceCapabilitiesNV* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pPresentModes) delete[] pPresentModes;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    presentModeCount = in_struct->presentModeCount;
+    pPresentModes = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pPresentModes) {
+        pPresentModes = new VkPresentModeKHR[in_struct->presentModeCount];
+        memcpy((void*)pPresentModes, (void*)in_struct->pPresentModes, sizeof(VkPresentModeKHR) * in_struct->presentModeCount);
+    }
+}
+
+void safe_VkLatencySurfaceCapabilitiesNV::initialize(const safe_VkLatencySurfaceCapabilitiesNV* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    presentModeCount = copy_src->presentModeCount;
+    pPresentModes = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pPresentModes) {
+        pPresentModes = new VkPresentModeKHR[copy_src->presentModeCount];
+        memcpy((void*)pPresentModes, (void*)copy_src->pPresentModes, sizeof(VkPresentModeKHR) * copy_src->presentModeCount);
+    }
+}
+
+safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM::safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
+    const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), multiviewPerViewRenderAreas(in_struct->multiviewPerViewRenderAreas) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM::safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM),
+      pNext(nullptr),
+      multiviewPerViewRenderAreas() {}
+
+safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM::safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
+    const safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM& copy_src) {
+    sType = copy_src.sType;
+    multiviewPerViewRenderAreas = copy_src.multiviewPerViewRenderAreas;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM&
+safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM::operator=(
+    const safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    multiviewPerViewRenderAreas = copy_src.multiviewPerViewRenderAreas;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM::~safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM::initialize(
+    const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    multiviewPerViewRenderAreas = in_struct->multiviewPerViewRenderAreas;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM::initialize(
+    const safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    multiviewPerViewRenderAreas = copy_src->multiviewPerViewRenderAreas;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM::safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
+    const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), perViewRenderAreaCount(in_struct->perViewRenderAreaCount), pPerViewRenderAreas(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pPerViewRenderAreas) {
+        pPerViewRenderAreas = new VkRect2D[in_struct->perViewRenderAreaCount];
+        memcpy((void*)pPerViewRenderAreas, (void*)in_struct->pPerViewRenderAreas,
+               sizeof(VkRect2D) * in_struct->perViewRenderAreaCount);
+    }
+}
+
+safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM::safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM()
+    : sType(VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM),
+      pNext(nullptr),
+      perViewRenderAreaCount(),
+      pPerViewRenderAreas(nullptr) {}
+
+safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM::safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
+    const safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM& copy_src) {
+    sType = copy_src.sType;
+    perViewRenderAreaCount = copy_src.perViewRenderAreaCount;
+    pPerViewRenderAreas = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pPerViewRenderAreas) {
+        pPerViewRenderAreas = new VkRect2D[copy_src.perViewRenderAreaCount];
+        memcpy((void*)pPerViewRenderAreas, (void*)copy_src.pPerViewRenderAreas, sizeof(VkRect2D) * copy_src.perViewRenderAreaCount);
+    }
+}
+
+safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM& safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM::operator=(
+    const safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pPerViewRenderAreas) delete[] pPerViewRenderAreas;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    perViewRenderAreaCount = copy_src.perViewRenderAreaCount;
+    pPerViewRenderAreas = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pPerViewRenderAreas) {
+        pPerViewRenderAreas = new VkRect2D[copy_src.perViewRenderAreaCount];
+        memcpy((void*)pPerViewRenderAreas, (void*)copy_src.pPerViewRenderAreas, sizeof(VkRect2D) * copy_src.perViewRenderAreaCount);
+    }
+
+    return *this;
+}
+
+safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM::~safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM() {
+    if (pPerViewRenderAreas) delete[] pPerViewRenderAreas;
+    FreePnextChain(pNext);
+}
+
+void safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM::initialize(
+    const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pPerViewRenderAreas) delete[] pPerViewRenderAreas;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    perViewRenderAreaCount = in_struct->perViewRenderAreaCount;
+    pPerViewRenderAreas = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pPerViewRenderAreas) {
+        pPerViewRenderAreas = new VkRect2D[in_struct->perViewRenderAreaCount];
+        memcpy((void*)pPerViewRenderAreas, (void*)in_struct->pPerViewRenderAreas,
+               sizeof(VkRect2D) * in_struct->perViewRenderAreaCount);
+    }
+}
+
+void safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM::initialize(
+    const safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    perViewRenderAreaCount = copy_src->perViewRenderAreaCount;
+    pPerViewRenderAreas = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pPerViewRenderAreas) {
+        pPerViewRenderAreas = new VkRect2D[copy_src->perViewRenderAreaCount];
+        memcpy((void*)pPerViewRenderAreas, (void*)copy_src->pPerViewRenderAreas,
+               sizeof(VkRect2D) * copy_src->perViewRenderAreaCount);
+    }
+}
+
+safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV::safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV(
+    const VkPhysicalDevicePerStageDescriptorSetFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      perStageDescriptorSet(in_struct->perStageDescriptorSet),
+      dynamicPipelineLayout(in_struct->dynamicPipelineLayout) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV::safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV),
+      pNext(nullptr),
+      perStageDescriptorSet(),
+      dynamicPipelineLayout() {}
+
+safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV::safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV(
+    const safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    perStageDescriptorSet = copy_src.perStageDescriptorSet;
+    dynamicPipelineLayout = copy_src.dynamicPipelineLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV& safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV::operator=(
+    const safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    perStageDescriptorSet = copy_src.perStageDescriptorSet;
+    dynamicPipelineLayout = copy_src.dynamicPipelineLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV::~safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV::initialize(
+    const VkPhysicalDevicePerStageDescriptorSetFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    perStageDescriptorSet = in_struct->perStageDescriptorSet;
+    dynamicPipelineLayout = in_struct->dynamicPipelineLayout;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV::initialize(
+    const safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    perStageDescriptorSet = copy_src->perStageDescriptorSet;
+    dynamicPipelineLayout = copy_src->dynamicPipelineLayout;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM::safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM(
+    const VkPhysicalDeviceImageProcessing2FeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), textureBlockMatch2(in_struct->textureBlockMatch2) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM::safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM), pNext(nullptr), textureBlockMatch2() {}
+
+safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM::safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM(
+    const safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM& copy_src) {
+    sType = copy_src.sType;
+    textureBlockMatch2 = copy_src.textureBlockMatch2;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM& safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM::operator=(
+    const safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    textureBlockMatch2 = copy_src.textureBlockMatch2;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM::~safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM::initialize(const VkPhysicalDeviceImageProcessing2FeaturesQCOM* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    textureBlockMatch2 = in_struct->textureBlockMatch2;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM::initialize(
+    const safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    textureBlockMatch2 = copy_src->textureBlockMatch2;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM::safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM(
+    const VkPhysicalDeviceImageProcessing2PropertiesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), maxBlockMatchWindow(in_struct->maxBlockMatchWindow) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM::safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM), pNext(nullptr), maxBlockMatchWindow() {}
+
+safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM::safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM(
+    const safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM& copy_src) {
+    sType = copy_src.sType;
+    maxBlockMatchWindow = copy_src.maxBlockMatchWindow;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM& safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM::operator=(
+    const safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxBlockMatchWindow = copy_src.maxBlockMatchWindow;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM::~safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM::initialize(
+    const VkPhysicalDeviceImageProcessing2PropertiesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxBlockMatchWindow = in_struct->maxBlockMatchWindow;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM::initialize(
+    const safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxBlockMatchWindow = copy_src->maxBlockMatchWindow;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSamplerBlockMatchWindowCreateInfoQCOM::safe_VkSamplerBlockMatchWindowCreateInfoQCOM(
+    const VkSamplerBlockMatchWindowCreateInfoQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), windowExtent(in_struct->windowExtent), windowCompareMode(in_struct->windowCompareMode) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSamplerBlockMatchWindowCreateInfoQCOM::safe_VkSamplerBlockMatchWindowCreateInfoQCOM()
+    : sType(VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM), pNext(nullptr), windowExtent(), windowCompareMode() {}
+
+safe_VkSamplerBlockMatchWindowCreateInfoQCOM::safe_VkSamplerBlockMatchWindowCreateInfoQCOM(
+    const safe_VkSamplerBlockMatchWindowCreateInfoQCOM& copy_src) {
+    sType = copy_src.sType;
+    windowExtent = copy_src.windowExtent;
+    windowCompareMode = copy_src.windowCompareMode;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSamplerBlockMatchWindowCreateInfoQCOM& safe_VkSamplerBlockMatchWindowCreateInfoQCOM::operator=(
+    const safe_VkSamplerBlockMatchWindowCreateInfoQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    windowExtent = copy_src.windowExtent;
+    windowCompareMode = copy_src.windowCompareMode;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSamplerBlockMatchWindowCreateInfoQCOM::~safe_VkSamplerBlockMatchWindowCreateInfoQCOM() { FreePnextChain(pNext); }
+
+void safe_VkSamplerBlockMatchWindowCreateInfoQCOM::initialize(const VkSamplerBlockMatchWindowCreateInfoQCOM* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    windowExtent = in_struct->windowExtent;
+    windowCompareMode = in_struct->windowCompareMode;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSamplerBlockMatchWindowCreateInfoQCOM::initialize(const safe_VkSamplerBlockMatchWindowCreateInfoQCOM* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    windowExtent = copy_src->windowExtent;
+    windowCompareMode = copy_src->windowCompareMode;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM::safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM(
+    const VkPhysicalDeviceCubicWeightsFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), selectableCubicWeights(in_struct->selectableCubicWeights) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM::safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM), pNext(nullptr), selectableCubicWeights() {}
+
+safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM::safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM(
+    const safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM& copy_src) {
+    sType = copy_src.sType;
+    selectableCubicWeights = copy_src.selectableCubicWeights;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM& safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM::operator=(
+    const safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    selectableCubicWeights = copy_src.selectableCubicWeights;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM::~safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM::initialize(const VkPhysicalDeviceCubicWeightsFeaturesQCOM* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    selectableCubicWeights = in_struct->selectableCubicWeights;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM::initialize(const safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    selectableCubicWeights = copy_src->selectableCubicWeights;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSamplerCubicWeightsCreateInfoQCOM::safe_VkSamplerCubicWeightsCreateInfoQCOM(
+    const VkSamplerCubicWeightsCreateInfoQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), cubicWeights(in_struct->cubicWeights) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSamplerCubicWeightsCreateInfoQCOM::safe_VkSamplerCubicWeightsCreateInfoQCOM()
+    : sType(VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM), pNext(nullptr), cubicWeights() {}
+
+safe_VkSamplerCubicWeightsCreateInfoQCOM::safe_VkSamplerCubicWeightsCreateInfoQCOM(
+    const safe_VkSamplerCubicWeightsCreateInfoQCOM& copy_src) {
+    sType = copy_src.sType;
+    cubicWeights = copy_src.cubicWeights;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSamplerCubicWeightsCreateInfoQCOM& safe_VkSamplerCubicWeightsCreateInfoQCOM::operator=(
+    const safe_VkSamplerCubicWeightsCreateInfoQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    cubicWeights = copy_src.cubicWeights;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSamplerCubicWeightsCreateInfoQCOM::~safe_VkSamplerCubicWeightsCreateInfoQCOM() { FreePnextChain(pNext); }
+
+void safe_VkSamplerCubicWeightsCreateInfoQCOM::initialize(const VkSamplerCubicWeightsCreateInfoQCOM* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    cubicWeights = in_struct->cubicWeights;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSamplerCubicWeightsCreateInfoQCOM::initialize(const safe_VkSamplerCubicWeightsCreateInfoQCOM* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    cubicWeights = copy_src->cubicWeights;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkBlitImageCubicWeightsInfoQCOM::safe_VkBlitImageCubicWeightsInfoQCOM(const VkBlitImageCubicWeightsInfoQCOM* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), cubicWeights(in_struct->cubicWeights) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkBlitImageCubicWeightsInfoQCOM::safe_VkBlitImageCubicWeightsInfoQCOM()
+    : sType(VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM), pNext(nullptr), cubicWeights() {}
+
+safe_VkBlitImageCubicWeightsInfoQCOM::safe_VkBlitImageCubicWeightsInfoQCOM(const safe_VkBlitImageCubicWeightsInfoQCOM& copy_src) {
+    sType = copy_src.sType;
+    cubicWeights = copy_src.cubicWeights;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBlitImageCubicWeightsInfoQCOM& safe_VkBlitImageCubicWeightsInfoQCOM::operator=(
+    const safe_VkBlitImageCubicWeightsInfoQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    cubicWeights = copy_src.cubicWeights;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkBlitImageCubicWeightsInfoQCOM::~safe_VkBlitImageCubicWeightsInfoQCOM() { FreePnextChain(pNext); }
+
+void safe_VkBlitImageCubicWeightsInfoQCOM::initialize(const VkBlitImageCubicWeightsInfoQCOM* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    cubicWeights = in_struct->cubicWeights;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkBlitImageCubicWeightsInfoQCOM::initialize(const safe_VkBlitImageCubicWeightsInfoQCOM* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    cubicWeights = copy_src->cubicWeights;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM::safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM(
+    const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), ycbcrDegamma(in_struct->ycbcrDegamma) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM::safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM), pNext(nullptr), ycbcrDegamma() {}
+
+safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM::safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM(
+    const safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM& copy_src) {
+    sType = copy_src.sType;
+    ycbcrDegamma = copy_src.ycbcrDegamma;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM& safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM::operator=(
+    const safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    ycbcrDegamma = copy_src.ycbcrDegamma;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM::~safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM::initialize(const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    ycbcrDegamma = in_struct->ycbcrDegamma;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM::initialize(const safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    ycbcrDegamma = copy_src->ycbcrDegamma;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM::safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM(
+    const VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), enableYDegamma(in_struct->enableYDegamma), enableCbCrDegamma(in_struct->enableCbCrDegamma) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM::safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM()
+    : sType(VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM),
+      pNext(nullptr),
+      enableYDegamma(),
+      enableCbCrDegamma() {}
+
+safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM::safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM(
+    const safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM& copy_src) {
+    sType = copy_src.sType;
+    enableYDegamma = copy_src.enableYDegamma;
+    enableCbCrDegamma = copy_src.enableCbCrDegamma;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM& safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM::operator=(
+    const safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    enableYDegamma = copy_src.enableYDegamma;
+    enableCbCrDegamma = copy_src.enableCbCrDegamma;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM::~safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM::initialize(
+    const VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    enableYDegamma = in_struct->enableYDegamma;
+    enableCbCrDegamma = in_struct->enableCbCrDegamma;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM::initialize(
+    const safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    enableYDegamma = copy_src->enableYDegamma;
+    enableCbCrDegamma = copy_src->enableCbCrDegamma;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceCubicClampFeaturesQCOM::safe_VkPhysicalDeviceCubicClampFeaturesQCOM(
+    const VkPhysicalDeviceCubicClampFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), cubicRangeClamp(in_struct->cubicRangeClamp) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceCubicClampFeaturesQCOM::safe_VkPhysicalDeviceCubicClampFeaturesQCOM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM), pNext(nullptr), cubicRangeClamp() {}
+
+safe_VkPhysicalDeviceCubicClampFeaturesQCOM::safe_VkPhysicalDeviceCubicClampFeaturesQCOM(
+    const safe_VkPhysicalDeviceCubicClampFeaturesQCOM& copy_src) {
+    sType = copy_src.sType;
+    cubicRangeClamp = copy_src.cubicRangeClamp;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceCubicClampFeaturesQCOM& safe_VkPhysicalDeviceCubicClampFeaturesQCOM::operator=(
+    const safe_VkPhysicalDeviceCubicClampFeaturesQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    cubicRangeClamp = copy_src.cubicRangeClamp;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceCubicClampFeaturesQCOM::~safe_VkPhysicalDeviceCubicClampFeaturesQCOM() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceCubicClampFeaturesQCOM::initialize(const VkPhysicalDeviceCubicClampFeaturesQCOM* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    cubicRangeClamp = in_struct->cubicRangeClamp;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceCubicClampFeaturesQCOM::initialize(const safe_VkPhysicalDeviceCubicClampFeaturesQCOM* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    cubicRangeClamp = copy_src->cubicRangeClamp;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+
+safe_VkScreenBufferPropertiesQNX::safe_VkScreenBufferPropertiesQNX(const VkScreenBufferPropertiesQNX* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), allocationSize(in_struct->allocationSize), memoryTypeBits(in_struct->memoryTypeBits) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkScreenBufferPropertiesQNX::safe_VkScreenBufferPropertiesQNX()
+    : sType(VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX), pNext(nullptr), allocationSize(), memoryTypeBits() {}
+
+safe_VkScreenBufferPropertiesQNX::safe_VkScreenBufferPropertiesQNX(const safe_VkScreenBufferPropertiesQNX& copy_src) {
+    sType = copy_src.sType;
+    allocationSize = copy_src.allocationSize;
+    memoryTypeBits = copy_src.memoryTypeBits;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkScreenBufferPropertiesQNX& safe_VkScreenBufferPropertiesQNX::operator=(const safe_VkScreenBufferPropertiesQNX& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    allocationSize = copy_src.allocationSize;
+    memoryTypeBits = copy_src.memoryTypeBits;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkScreenBufferPropertiesQNX::~safe_VkScreenBufferPropertiesQNX() { FreePnextChain(pNext); }
+
+void safe_VkScreenBufferPropertiesQNX::initialize(const VkScreenBufferPropertiesQNX* in_struct,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    allocationSize = in_struct->allocationSize;
+    memoryTypeBits = in_struct->memoryTypeBits;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkScreenBufferPropertiesQNX::initialize(const safe_VkScreenBufferPropertiesQNX* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    allocationSize = copy_src->allocationSize;
+    memoryTypeBits = copy_src->memoryTypeBits;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkScreenBufferFormatPropertiesQNX::safe_VkScreenBufferFormatPropertiesQNX(const VkScreenBufferFormatPropertiesQNX* in_struct,
+                                                                               [[maybe_unused]] PNextCopyState* copy_state,
+                                                                               bool copy_pnext)
+    : sType(in_struct->sType),
+      format(in_struct->format),
+      externalFormat(in_struct->externalFormat),
+      screenUsage(in_struct->screenUsage),
+      formatFeatures(in_struct->formatFeatures),
+      samplerYcbcrConversionComponents(in_struct->samplerYcbcrConversionComponents),
+      suggestedYcbcrModel(in_struct->suggestedYcbcrModel),
+      suggestedYcbcrRange(in_struct->suggestedYcbcrRange),
+      suggestedXChromaOffset(in_struct->suggestedXChromaOffset),
+      suggestedYChromaOffset(in_struct->suggestedYChromaOffset) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkScreenBufferFormatPropertiesQNX::safe_VkScreenBufferFormatPropertiesQNX()
+    : sType(VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX),
+      pNext(nullptr),
+      format(),
+      externalFormat(),
+      screenUsage(),
+      formatFeatures(),
+      samplerYcbcrConversionComponents(),
+      suggestedYcbcrModel(),
+      suggestedYcbcrRange(),
+      suggestedXChromaOffset(),
+      suggestedYChromaOffset() {}
+
+safe_VkScreenBufferFormatPropertiesQNX::safe_VkScreenBufferFormatPropertiesQNX(
+    const safe_VkScreenBufferFormatPropertiesQNX& copy_src) {
+    sType = copy_src.sType;
+    format = copy_src.format;
+    externalFormat = copy_src.externalFormat;
+    screenUsage = copy_src.screenUsage;
+    formatFeatures = copy_src.formatFeatures;
+    samplerYcbcrConversionComponents = copy_src.samplerYcbcrConversionComponents;
+    suggestedYcbcrModel = copy_src.suggestedYcbcrModel;
+    suggestedYcbcrRange = copy_src.suggestedYcbcrRange;
+    suggestedXChromaOffset = copy_src.suggestedXChromaOffset;
+    suggestedYChromaOffset = copy_src.suggestedYChromaOffset;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkScreenBufferFormatPropertiesQNX& safe_VkScreenBufferFormatPropertiesQNX::operator=(
+    const safe_VkScreenBufferFormatPropertiesQNX& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    format = copy_src.format;
+    externalFormat = copy_src.externalFormat;
+    screenUsage = copy_src.screenUsage;
+    formatFeatures = copy_src.formatFeatures;
+    samplerYcbcrConversionComponents = copy_src.samplerYcbcrConversionComponents;
+    suggestedYcbcrModel = copy_src.suggestedYcbcrModel;
+    suggestedYcbcrRange = copy_src.suggestedYcbcrRange;
+    suggestedXChromaOffset = copy_src.suggestedXChromaOffset;
+    suggestedYChromaOffset = copy_src.suggestedYChromaOffset;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkScreenBufferFormatPropertiesQNX::~safe_VkScreenBufferFormatPropertiesQNX() { FreePnextChain(pNext); }
+
+void safe_VkScreenBufferFormatPropertiesQNX::initialize(const VkScreenBufferFormatPropertiesQNX* in_struct,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    format = in_struct->format;
+    externalFormat = in_struct->externalFormat;
+    screenUsage = in_struct->screenUsage;
+    formatFeatures = in_struct->formatFeatures;
+    samplerYcbcrConversionComponents = in_struct->samplerYcbcrConversionComponents;
+    suggestedYcbcrModel = in_struct->suggestedYcbcrModel;
+    suggestedYcbcrRange = in_struct->suggestedYcbcrRange;
+    suggestedXChromaOffset = in_struct->suggestedXChromaOffset;
+    suggestedYChromaOffset = in_struct->suggestedYChromaOffset;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkScreenBufferFormatPropertiesQNX::initialize(const safe_VkScreenBufferFormatPropertiesQNX* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    format = copy_src->format;
+    externalFormat = copy_src->externalFormat;
+    screenUsage = copy_src->screenUsage;
+    formatFeatures = copy_src->formatFeatures;
+    samplerYcbcrConversionComponents = copy_src->samplerYcbcrConversionComponents;
+    suggestedYcbcrModel = copy_src->suggestedYcbcrModel;
+    suggestedYcbcrRange = copy_src->suggestedYcbcrRange;
+    suggestedXChromaOffset = copy_src->suggestedXChromaOffset;
+    suggestedYChromaOffset = copy_src->suggestedYChromaOffset;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkImportScreenBufferInfoQNX::safe_VkImportScreenBufferInfoQNX(const VkImportScreenBufferInfoQNX* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), buffer(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->buffer) {
+        buffer = new _screen_buffer(*in_struct->buffer);
+    }
+}
+
+safe_VkImportScreenBufferInfoQNX::safe_VkImportScreenBufferInfoQNX()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX), pNext(nullptr), buffer(nullptr) {}
+
+safe_VkImportScreenBufferInfoQNX::safe_VkImportScreenBufferInfoQNX(const safe_VkImportScreenBufferInfoQNX& copy_src) {
+    sType = copy_src.sType;
+    buffer = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.buffer) {
+        buffer = new _screen_buffer(*copy_src.buffer);
+    }
+}
+
+safe_VkImportScreenBufferInfoQNX& safe_VkImportScreenBufferInfoQNX::operator=(const safe_VkImportScreenBufferInfoQNX& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (buffer) delete buffer;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    buffer = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.buffer) {
+        buffer = new _screen_buffer(*copy_src.buffer);
+    }
+
+    return *this;
+}
+
+safe_VkImportScreenBufferInfoQNX::~safe_VkImportScreenBufferInfoQNX() {
+    if (buffer) delete buffer;
+    FreePnextChain(pNext);
+}
+
+void safe_VkImportScreenBufferInfoQNX::initialize(const VkImportScreenBufferInfoQNX* in_struct,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    if (buffer) delete buffer;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    buffer = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->buffer) {
+        buffer = new _screen_buffer(*in_struct->buffer);
+    }
+}
+
+void safe_VkImportScreenBufferInfoQNX::initialize(const safe_VkImportScreenBufferInfoQNX* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    buffer = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->buffer) {
+        buffer = new _screen_buffer(*copy_src->buffer);
+    }
+}
+
+safe_VkExternalFormatQNX::safe_VkExternalFormatQNX(const VkExternalFormatQNX* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), externalFormat(in_struct->externalFormat) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkExternalFormatQNX::safe_VkExternalFormatQNX()
+    : sType(VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX), pNext(nullptr), externalFormat() {}
+
+safe_VkExternalFormatQNX::safe_VkExternalFormatQNX(const safe_VkExternalFormatQNX& copy_src) {
+    sType = copy_src.sType;
+    externalFormat = copy_src.externalFormat;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkExternalFormatQNX& safe_VkExternalFormatQNX::operator=(const safe_VkExternalFormatQNX& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    externalFormat = copy_src.externalFormat;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkExternalFormatQNX::~safe_VkExternalFormatQNX() { FreePnextChain(pNext); }
+
+void safe_VkExternalFormatQNX::initialize(const VkExternalFormatQNX* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    externalFormat = in_struct->externalFormat;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkExternalFormatQNX::initialize(const safe_VkExternalFormatQNX* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    externalFormat = copy_src->externalFormat;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX::safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX(
+    const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), screenBufferImport(in_struct->screenBufferImport) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX::safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX), pNext(nullptr), screenBufferImport() {}
+
+safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX::safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX(
+    const safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX& copy_src) {
+    sType = copy_src.sType;
+    screenBufferImport = copy_src.screenBufferImport;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX& safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX::operator=(
+    const safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    screenBufferImport = copy_src.screenBufferImport;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX::~safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX::initialize(
+    const VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    screenBufferImport = in_struct->screenBufferImport;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX::initialize(
+    const safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    screenBufferImport = copy_src->screenBufferImport;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+#endif  // VK_USE_PLATFORM_SCREEN_QNX
+
+safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT::safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT(
+    const VkPhysicalDeviceLayeredDriverPropertiesMSFT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), underlyingAPI(in_struct->underlyingAPI) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT::safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT), pNext(nullptr), underlyingAPI() {}
+
+safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT::safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT(
+    const safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT& copy_src) {
+    sType = copy_src.sType;
+    underlyingAPI = copy_src.underlyingAPI;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT& safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT::operator=(
+    const safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    underlyingAPI = copy_src.underlyingAPI;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT::~safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT::initialize(const VkPhysicalDeviceLayeredDriverPropertiesMSFT* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    underlyingAPI = in_struct->underlyingAPI;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT::initialize(const safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    underlyingAPI = copy_src->underlyingAPI;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV::safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV(
+    const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), descriptorPoolOverallocation(in_struct->descriptorPoolOverallocation) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV::safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV),
+      pNext(nullptr),
+      descriptorPoolOverallocation() {}
+
+safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV::safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV(
+    const safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    descriptorPoolOverallocation = copy_src.descriptorPoolOverallocation;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV& safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    descriptorPoolOverallocation = copy_src.descriptorPoolOverallocation;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV::~safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV::initialize(
+    const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    descriptorPoolOverallocation = in_struct->descriptorPoolOverallocation;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV::initialize(
+    const safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    descriptorPoolOverallocation = copy_src->descriptorPoolOverallocation;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceRawAccessChainsFeaturesNV::safe_VkPhysicalDeviceRawAccessChainsFeaturesNV(
+    const VkPhysicalDeviceRawAccessChainsFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), shaderRawAccessChains(in_struct->shaderRawAccessChains) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceRawAccessChainsFeaturesNV::safe_VkPhysicalDeviceRawAccessChainsFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV), pNext(nullptr), shaderRawAccessChains() {}
+
+safe_VkPhysicalDeviceRawAccessChainsFeaturesNV::safe_VkPhysicalDeviceRawAccessChainsFeaturesNV(
+    const safe_VkPhysicalDeviceRawAccessChainsFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    shaderRawAccessChains = copy_src.shaderRawAccessChains;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceRawAccessChainsFeaturesNV& safe_VkPhysicalDeviceRawAccessChainsFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceRawAccessChainsFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderRawAccessChains = copy_src.shaderRawAccessChains;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceRawAccessChainsFeaturesNV::~safe_VkPhysicalDeviceRawAccessChainsFeaturesNV() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceRawAccessChainsFeaturesNV::initialize(const VkPhysicalDeviceRawAccessChainsFeaturesNV* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderRawAccessChains = in_struct->shaderRawAccessChains;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceRawAccessChainsFeaturesNV::initialize(const safe_VkPhysicalDeviceRawAccessChainsFeaturesNV* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderRawAccessChains = copy_src->shaderRawAccessChains;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV::safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV(
+    const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), shaderFloat16VectorAtomics(in_struct->shaderFloat16VectorAtomics) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV::safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV),
+      pNext(nullptr),
+      shaderFloat16VectorAtomics() {}
+
+safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV::safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV(
+    const safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    shaderFloat16VectorAtomics = copy_src.shaderFloat16VectorAtomics;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV& safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderFloat16VectorAtomics = copy_src.shaderFloat16VectorAtomics;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV::~safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV::initialize(
+    const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderFloat16VectorAtomics = in_struct->shaderFloat16VectorAtomics;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV::initialize(
+    const safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderFloat16VectorAtomics = copy_src->shaderFloat16VectorAtomics;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceRayTracingValidationFeaturesNV::safe_VkPhysicalDeviceRayTracingValidationFeaturesNV(
+    const VkPhysicalDeviceRayTracingValidationFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), rayTracingValidation(in_struct->rayTracingValidation) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceRayTracingValidationFeaturesNV::safe_VkPhysicalDeviceRayTracingValidationFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV), pNext(nullptr), rayTracingValidation() {}
+
+safe_VkPhysicalDeviceRayTracingValidationFeaturesNV::safe_VkPhysicalDeviceRayTracingValidationFeaturesNV(
+    const safe_VkPhysicalDeviceRayTracingValidationFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    rayTracingValidation = copy_src.rayTracingValidation;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceRayTracingValidationFeaturesNV& safe_VkPhysicalDeviceRayTracingValidationFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceRayTracingValidationFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    rayTracingValidation = copy_src.rayTracingValidation;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceRayTracingValidationFeaturesNV::~safe_VkPhysicalDeviceRayTracingValidationFeaturesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceRayTracingValidationFeaturesNV::initialize(
+    const VkPhysicalDeviceRayTracingValidationFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    rayTracingValidation = in_struct->rayTracingValidation;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceRayTracingValidationFeaturesNV::initialize(
+    const safe_VkPhysicalDeviceRayTracingValidationFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    rayTracingValidation = copy_src->rayTracingValidation;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+}  // namespace vku
+
+// NOLINTEND
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 3bf1283..12b40df 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -16,6 +16,7 @@ target_include_directories(vul_tests PRIVATE
 )
 
 target_sources(vul_tests PRIVATE
+    safe_struct.cpp
     struct_helper.cpp
     test_formats.cpp
     test_interface.cpp
@@ -35,6 +36,7 @@ target_link_libraries(vul_tests PRIVATE
     Vulkan::UtilityHeaders
     Vulkan::LayerSettings
     Vulkan::CompilerConfiguration
+    Vulkan::SafeStruct
 )
 
 # Test add_subdirectory suppport
diff --git a/tests/safe_struct.cpp b/tests/safe_struct.cpp
new file mode 100644
index 0000000..4af6640
--- /dev/null
+++ b/tests/safe_struct.cpp
@@ -0,0 +1,239 @@
+// Copyright 2023 The Khronos Group Inc.
+// Copyright 2023 Valve Corporation
+// Copyright 2023 LunarG, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <vulkan/utility/vk_safe_struct.hpp>
+#include <vulkan/utility/vk_struct_helper.hpp>
+#include <gtest/gtest.h>
+#include <array>
+
+TEST(safe_struct, basic) {
+    vku::safe_VkInstanceCreateInfo safe_info;
+    {
+        VkApplicationInfo app = vku::InitStructHelper();
+        app.pApplicationName = "test";
+        app.applicationVersion = 42;
+
+        VkDebugUtilsMessengerCreateInfoEXT debug_ci = vku::InitStructHelper();
+        debug_ci.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
+
+        VkInstanceCreateInfo info = vku::InitStructHelper();
+        info.pApplicationInfo = &app;
+        info.pNext = &debug_ci;
+
+        safe_info.initialize(&info);
+
+        memset(&info, 0x11, sizeof(info));
+        memset(&app, 0x22, sizeof(app));
+        memset(&debug_ci, 0x33, sizeof(debug_ci));
+    }
+    ASSERT_EQ(VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, safe_info.sType);
+    ASSERT_EQ(0, strcmp("test", safe_info.pApplicationInfo->pApplicationName));
+    ASSERT_EQ(42, safe_info.pApplicationInfo->applicationVersion);
+
+    auto debug_ci = vku::FindStructInPNextChain<VkDebugUtilsMessengerCreateInfoEXT>(safe_info.pNext);
+    ASSERT_NE(nullptr, debug_ci);
+    ASSERT_EQ(VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT, debug_ci->messageSeverity);
+}
+
+TEST(safe_struct, safe_void_pointer_copies) {
+    // vku::safe_VkSpecializationInfo, constructor
+    {
+        std::vector<std::byte> data(20, std::byte{0b11110000});
+
+        VkSpecializationInfo info = {};
+        info.dataSize = uint32_t(data.size());
+        info.pData = data.data();
+
+        vku::safe_VkSpecializationInfo safe(&info);
+
+        ASSERT_TRUE(safe.pData != info.pData);
+        ASSERT_TRUE(safe.dataSize == info.dataSize);
+
+        data.clear();  // Invalidate any references, pointers, or iterators referring to contained elements.
+
+        auto copied_bytes = reinterpret_cast<const std::byte *>(safe.pData);
+        ASSERT_TRUE(copied_bytes[19] == std::byte{0b11110000});
+    }
+
+    // vku::safe_VkPipelineExecutableInternalRepresentationKHR, initialize
+    {
+        std::vector<std::byte> data(11, std::byte{0b01001001});
+
+        VkPipelineExecutableInternalRepresentationKHR info = {};
+        info.dataSize = uint32_t(data.size());
+        info.pData = data.data();
+
+        vku::safe_VkPipelineExecutableInternalRepresentationKHR safe;
+
+        safe.initialize(&info);
+
+        ASSERT_TRUE(safe.dataSize == info.dataSize);
+        ASSERT_TRUE(safe.pData != info.pData);
+
+        data.clear();  // Invalidate any references, pointers, or iterators referring to contained elements.
+
+        auto copied_bytes = reinterpret_cast<const std::byte *>(safe.pData);
+        ASSERT_TRUE(copied_bytes[10] == std::byte{0b01001001});
+    }
+}
+
+TEST(safe_struct, custom_safe_pnext_copy) {
+    // This tests an additional "copy_state" parameter in the SafePNextCopy function that allows "customizing" safe_* struct
+    // construction.. This is required for structs such as VkPipelineRenderingCreateInfo (which extend VkGraphicsPipelineCreateInfo)
+    // whose members must be partially ignored depending on the graphics sub-state present.
+
+    VkFormat format = VK_FORMAT_B8G8R8A8_UNORM;
+    VkPipelineRenderingCreateInfo pri = vku::InitStructHelper();
+    pri.colorAttachmentCount = 1;
+    pri.pColorAttachmentFormats = &format;
+
+    bool ignore_default_construction = true;
+    vku::PNextCopyState copy_state = {
+        [&ignore_default_construction](VkBaseOutStructure *safe_struct,
+                                       [[maybe_unused]] const VkBaseOutStructure *in_struct) -> bool {
+            if (ignore_default_construction) {
+                auto tmp = reinterpret_cast<vku::safe_VkPipelineRenderingCreateInfo *>(safe_struct);
+                tmp->colorAttachmentCount = 0;
+                tmp->pColorAttachmentFormats = nullptr;
+                return true;
+            }
+            return false;
+        },
+    };
+
+    {
+        VkGraphicsPipelineCreateInfo gpci = vku::InitStructHelper(&pri);
+        vku::safe_VkGraphicsPipelineCreateInfo safe_gpci(&gpci, false, false, &copy_state);
+
+        auto safe_pri = reinterpret_cast<const vku::safe_VkPipelineRenderingCreateInfo *>(safe_gpci.pNext);
+        // Ensure original input struct was not modified
+        ASSERT_EQ(pri.colorAttachmentCount, 1);
+        ASSERT_EQ(pri.pColorAttachmentFormats, &format);
+
+        // Ensure safe struct was modified
+        ASSERT_EQ(safe_pri->colorAttachmentCount, 0);
+        ASSERT_EQ(safe_pri->pColorAttachmentFormats, nullptr);
+    }
+
+    // Ensure PNextCopyState::init is also applied when there is more than one element in the pNext chain
+    {
+        VkGraphicsPipelineLibraryCreateInfoEXT gpl_info = vku::InitStructHelper(&pri);
+        VkGraphicsPipelineCreateInfo gpci = vku::InitStructHelper(&gpl_info);
+
+        vku::safe_VkGraphicsPipelineCreateInfo safe_gpci(&gpci, false, false, &copy_state);
+
+        auto safe_gpl_info = reinterpret_cast<const vku::safe_VkGraphicsPipelineLibraryCreateInfoEXT *>(safe_gpci.pNext);
+        auto safe_pri = reinterpret_cast<const vku::safe_VkPipelineRenderingCreateInfo *>(safe_gpl_info->pNext);
+        // Ensure original input struct was not modified
+        ASSERT_EQ(pri.colorAttachmentCount, 1);
+        ASSERT_EQ(pri.pColorAttachmentFormats, &format);
+
+        // Ensure safe struct was modified
+        ASSERT_EQ(safe_pri->colorAttachmentCount, 0);
+        ASSERT_EQ(safe_pri->pColorAttachmentFormats, nullptr);
+    }
+
+    // Check that signaling to use the default constructor works
+    {
+        pri.colorAttachmentCount = 1;
+        pri.pColorAttachmentFormats = &format;
+
+        ignore_default_construction = false;
+        VkGraphicsPipelineCreateInfo gpci = vku::InitStructHelper(&pri);
+        vku::safe_VkGraphicsPipelineCreateInfo safe_gpci(&gpci, false, false, &copy_state);
+
+        auto safe_pri = reinterpret_cast<const vku::safe_VkPipelineRenderingCreateInfo *>(safe_gpci.pNext);
+        // Ensure original input struct was not modified
+        ASSERT_EQ(pri.colorAttachmentCount, 1);
+        ASSERT_EQ(pri.pColorAttachmentFormats, &format);
+
+        // Ensure safe struct was modified
+        ASSERT_EQ(safe_pri->colorAttachmentCount, 1);
+        ASSERT_EQ(*safe_pri->pColorAttachmentFormats, format);
+    }
+}
+
+TEST(safe_struct, extension_add_remove) {
+    std::array<const char *, 6> extensions{
+        "VK_KHR_maintenance1", "VK_KHR_maintenance2", "VK_KHR_maintenance3",
+        "VK_KHR_maintenance4", "VK_KHR_maintenance5", "VK_KHR_maintenance6",
+    };
+    VkDeviceCreateInfo ci = vku::InitStructHelper();
+    ci.ppEnabledExtensionNames = extensions.data();
+    ci.enabledExtensionCount = static_cast<uint32_t>(extensions.size());
+
+    vku::safe_VkDeviceCreateInfo safe_ci(&ci);
+    ASSERT_EQ(3, vku::FindExtension(safe_ci, "VK_KHR_maintenance4"));
+    ASSERT_EQ(safe_ci.enabledExtensionCount, vku::FindExtension(safe_ci, "VK_KHR_maintenance0"));
+
+    ASSERT_EQ(false, vku::RemoveExtension(safe_ci, "VK_KHR_maintenance0"));
+    ASSERT_EQ(true, vku::AddExtension(safe_ci, "VK_KHR_maintenance0"));
+
+    ASSERT_EQ(true, vku::RemoveExtension(safe_ci, "VK_KHR_maintenance0"));
+    for (const auto &ext : extensions) {
+        ASSERT_EQ(true, vku::RemoveExtension(safe_ci, ext));
+    }
+    ASSERT_EQ(false, vku::RemoveExtension(safe_ci, "VK_KHR_maintenance0"));
+
+    ASSERT_EQ(0, safe_ci.enabledExtensionCount);
+    ASSERT_EQ(nullptr, safe_ci.ppEnabledExtensionNames);
+
+    for (const auto &ext : extensions) {
+        ASSERT_EQ(true, vku::AddExtension(safe_ci, ext));
+    }
+    ASSERT_EQ(extensions.size(), safe_ci.enabledExtensionCount);
+}
+
+TEST(safe_struct, pnext_add_remove) {
+    VkPhysicalDeviceRayTracingPipelineFeaturesKHR rtp = vku::InitStructHelper();
+    VkPhysicalDeviceRayQueryFeaturesKHR rtq = vku::InitStructHelper(&rtp);
+    VkPhysicalDeviceMeshShaderFeaturesEXT mesh = vku::InitStructHelper(&rtq);
+    VkPhysicalDeviceFeatures2 features = vku::InitStructHelper(&mesh);
+
+    vku::safe_VkPhysicalDeviceFeatures2 sf(&features);
+
+    // unlink the structs so they can be added one at a time.
+    rtp.pNext = nullptr;
+    rtq.pNext = nullptr;
+    mesh.pNext = nullptr;
+
+    ASSERT_EQ(true, vku::RemoveFromPnext(sf, rtq.sType));
+    ASSERT_EQ(nullptr, vku::FindStructInPNextChain<VkPhysicalDeviceRayQueryFeaturesKHR>(sf.pNext));
+    ASSERT_EQ(false, vku::RemoveFromPnext(sf, rtq.sType));
+
+    ASSERT_EQ(true, vku::RemoveFromPnext(sf, rtp.sType));
+    ASSERT_EQ(nullptr, vku::FindStructInPNextChain<VkPhysicalDeviceRayTracingPipelineFeaturesKHR>(sf.pNext));
+
+    ASSERT_EQ(true, vku::RemoveFromPnext(sf, mesh.sType));
+    ASSERT_EQ(nullptr, vku::FindStructInPNextChain<VkPhysicalDeviceMeshShaderFeaturesEXT>(sf.pNext));
+
+    ASSERT_EQ(nullptr, sf.pNext);
+    ASSERT_EQ(true, vku::AddToPnext(sf, mesh));
+    ASSERT_EQ(false, vku::AddToPnext(sf, mesh));
+    ASSERT_NE(nullptr, vku::FindStructInPNextChain<VkPhysicalDeviceMeshShaderFeaturesEXT>(sf.pNext));
+
+    ASSERT_EQ(true, vku::AddToPnext(sf, rtq));
+    ASSERT_EQ(false, vku::AddToPnext(sf, rtq));
+    ASSERT_NE(nullptr, vku::FindStructInPNextChain<VkPhysicalDeviceRayQueryFeaturesKHR>(sf.pNext));
+
+    ASSERT_EQ(true, vku::AddToPnext(sf, rtp));
+    ASSERT_EQ(false, vku::AddToPnext(sf, rtp));
+    ASSERT_NE(nullptr, vku::FindStructInPNextChain<VkPhysicalDeviceRayTracingPipelineFeaturesKHR>(sf.pNext));
+
+    ASSERT_EQ(true, vku::RemoveFromPnext(sf, mesh.sType));
+    ASSERT_EQ(true, vku::RemoveFromPnext(sf, rtp.sType));
+    ASSERT_EQ(true, vku::RemoveFromPnext(sf, rtq.sType));
+
+    // relink the structs so they can be added all at once
+    rtq.pNext = &rtp;
+    mesh.pNext = &rtq;
+
+    ASSERT_EQ(true, vku::AddToPnext(sf, mesh));
+    ASSERT_NE(nullptr, vku::FindStructInPNextChain<VkPhysicalDeviceRayTracingPipelineFeaturesKHR>(sf.pNext));
+    ASSERT_NE(nullptr, vku::FindStructInPNextChain<VkPhysicalDeviceMeshShaderFeaturesEXT>(sf.pNext));
+    ASSERT_NE(nullptr, vku::FindStructInPNextChain<VkPhysicalDeviceRayQueryFeaturesKHR>(sf.pNext));
+}

From 0519e66f426d13d06b4172f29a5476831382f79c Mon Sep 17 00:00:00 2001
From: Jeremy Gebben <jeremyg@lunarg.com>
Date: Thu, 21 Mar 2024 14:56:48 -0600
Subject: [PATCH 011/106] utils: Add custom containers from vvl

---
 include/CMakeLists.txt                        |    8 +-
 .../vulkan/utility/vk_small_containers.hpp    |  712 ++++++
 .../vulkan/utility/vk_sparse_range_map.hpp    | 2033 +++++++++++++++++
 scripts/gn/stub.cpp                           |    4 +-
 tests/CMakeLists.txt                          |    8 +-
 tests/small_containers.cpp                    |  415 ++++
 tests/sparse_range_map.cpp                    |   43 +
 7 files changed, 3216 insertions(+), 7 deletions(-)
 create mode 100644 include/vulkan/utility/vk_small_containers.hpp
 create mode 100644 include/vulkan/utility/vk_sparse_range_map.hpp
 create mode 100644 tests/small_containers.cpp
 create mode 100644 tests/sparse_range_map.cpp

diff --git a/include/CMakeLists.txt b/include/CMakeLists.txt
index 58c48e9..8a8a2c6 100644
--- a/include/CMakeLists.txt
+++ b/include/CMakeLists.txt
@@ -1,6 +1,6 @@
-# Copyright 2023 The Khronos Group Inc.
-# Copyright 2023 Valve Corporation
-# Copyright 2023 LunarG, Inc.
+# Copyright 2023-2024 The Khronos Group Inc.
+# Copyright 2023-2024 Valve Corporation
+# Copyright 2023-2024 LunarG, Inc.
 #
 # SPDX-License-Identifier: Apache-2.0
 target_include_directories(VulkanLayerSettings PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
@@ -29,6 +29,8 @@ if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.19")
         vulkan/utility/vk_concurrent_unordered_map.hpp
         vulkan/utility/vk_dispatch_table.h
         vulkan/utility/vk_format_utils.h
+        vulkan/utility/vk_small_containers.hpp
+        vulkan/utility/vk_sparse_range_map.hpp
         vulkan/utility/vk_struct_helper.hpp
     )
 endif()
diff --git a/include/vulkan/utility/vk_small_containers.hpp b/include/vulkan/utility/vk_small_containers.hpp
new file mode 100644
index 0000000..0c0786d
--- /dev/null
+++ b/include/vulkan/utility/vk_small_containers.hpp
@@ -0,0 +1,712 @@
+/* Copyright (c) 2015-2017, 2019-2024 The Khronos Group Inc.
+ * Copyright (c) 2015-2017, 2019-2024 Valve Corporation
+ * Copyright (c) 2015-2017, 2019-2024 LunarG, Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ */
+
+#pragma once
+
+#include <cassert>
+#include <unordered_map>
+#include <unordered_set>
+
+namespace vku {
+namespace small {
+
+// A vector class with "small string optimization" -- meaning that the class contains a fixed working store for N elements.
+// Useful in in situations where the needed size is unknown, but the typical size is known  If size increases beyond the
+// fixed capacity, a dynamically allocated working store is created.
+//
+// NOTE: Unlike std::vector which only requires T to be CopyAssignable and CopyConstructable, small::vector requires T to be
+//       MoveAssignable and MoveConstructable
+// NOTE: Unlike std::vector, iterators are invalidated by move assignment between small::vector objects effectively the
+//       "small string" allocation functions as an incompatible allocator.
+template <typename T, size_t N, typename SizeType = uint32_t>
+class vector {
+  public:
+    using value_type = T;
+    using reference = value_type &;
+    using const_reference = const value_type &;
+    using pointer = value_type *;
+    using const_pointer = const value_type *;
+    using iterator = pointer;
+    using const_iterator = const_pointer;
+    using size_type = SizeType;
+    static const size_type kSmallCapacity = N;
+    static const size_type kMaxCapacity = std::numeric_limits<size_type>::max();
+    static_assert(N <= kMaxCapacity, "size must be less than size_type::max");
+
+    vector() : size_(0), capacity_(N), working_store_(GetSmallStore()) {}
+
+    vector(std::initializer_list<T> list) : size_(0), capacity_(N), working_store_(GetSmallStore()) { PushBackFrom(list); }
+
+    vector(const vector &other) : size_(0), capacity_(N), working_store_(GetSmallStore()) { PushBackFrom(other); }
+
+    vector(vector &&other) : size_(0), capacity_(N), working_store_(GetSmallStore()) {
+        if (other.large_store_) {
+            MoveLargeStore(other);
+        } else {
+            PushBackFrom(std::move(other));
+        }
+        // Per the spec, when constructing from other, other is guaranteed to be empty after the constructor runs
+        other.clear();
+    }
+
+    vector(size_type size, const value_type &value = value_type()) : size_(0), capacity_(N), working_store_(GetSmallStore()) {
+        reserve(size);
+        auto dest = GetWorkingStore();
+        for (size_type i = 0; i < size; i++) {
+            new (dest) value_type(value);
+            ++dest;
+        }
+        size_ = size;
+    }
+
+    ~vector() { clear(); }
+
+    bool operator==(const vector &rhs) const {
+        if (size_ != rhs.size_) return false;
+        auto value = begin();
+        for (const auto &rh_value : rhs) {
+            if (!(*value == rh_value)) {
+                return false;
+            }
+            ++value;
+        }
+        return true;
+    }
+
+    bool operator!=(const vector &rhs) const { return !(*this == rhs); }
+
+    vector &operator=(const vector &other) {
+        if (this != &other) {
+            if (other.size_ > capacity_) {
+                // Calling reserve would move construct and destroy all current contents, so just clear them before calling
+                // PushBackFrom (which does a reserve vs. the now empty this)
+                clear();
+                PushBackFrom(other);
+            } else {
+                // The copy will fit into the current allocation
+                auto dest = GetWorkingStore();
+                auto source = other.GetWorkingStore();
+
+                const auto overlap = std::min(size_, other.size_);
+                // Copy assign anywhere we have objects in this
+                // Note: usually cheaper than destruct/construct
+                for (size_type i = 0; i < overlap; i++) {
+                    dest[i] = source[i];
+                }
+
+                // Copy construct anywhere we *don't* have objects in this
+                for (size_type i = overlap; i < other.size_; i++) {
+                    new (dest + i) value_type(source[i]);
+                }
+
+                // Any entries in this past other_size_ must be cleaned up...
+                for (size_type i = other.size_; i < size_; i++) {
+                    dest[i].~value_type();
+                }
+                size_ = other.size_;
+            }
+        }
+        return *this;
+    }
+
+    vector &operator=(vector &&other) {
+        if (this != &other) {
+            // Note: move assign doesn't require other to become empty (as does move construction)
+            //       so we'll leave other alone except in the large store case, while moving the object
+            //       *in* the vector from other
+            if (other.large_store_) {
+                // Moving the other large store intact is probably best, even if we have to destroy everything in this.
+                clear();
+                MoveLargeStore(other);
+            } else if (other.size_ > capacity_) {
+                // If we'd have to reallocate, just clean up minimally and copy normally
+                clear();
+                PushBackFrom(std::move(other));
+            } else {
+                // The copy will fit into the current allocation
+                auto dest = GetWorkingStore();
+                auto source = other.GetWorkingStore();
+
+                const auto overlap = std::min(size_, other.size_);
+
+                // Move assign where we have objects in this
+                // Note: usually cheaper than destruct/construct
+                for (size_type i = 0; i < overlap; i++) {
+                    dest[i] = std::move(source[i]);
+                }
+
+                // Move construct where we *don't* have objects in this
+                for (size_type i = overlap; i < other.size_; i++) {
+                    new (dest + i) value_type(std::move(source[i]));
+                }
+
+                // Any entries in this past other_size_ must be cleaned up...
+                for (size_type i = other.size_; i < size_; i++) {
+                    dest[i].~value_type();
+                }
+                size_ = other.size_;
+            }
+        }
+        return *this;
+    }
+
+    reference operator[](size_type pos) {
+        assert(pos < size_);
+        return GetWorkingStore()[pos];
+    }
+    const_reference operator[](size_type pos) const {
+        assert(pos < size_);
+        return GetWorkingStore()[pos];
+    }
+
+    // Like std::vector:: calling front or back on an empty container causes undefined behavior
+    reference front() {
+        assert(size_ > 0);
+        return GetWorkingStore()[0];
+    }
+    const_reference front() const {
+        assert(size_ > 0);
+        return GetWorkingStore()[0];
+    }
+    reference back() {
+        assert(size_ > 0);
+        return GetWorkingStore()[size_ - 1];
+    }
+    const_reference back() const {
+        assert(size_ > 0);
+        return GetWorkingStore()[size_ - 1];
+    }
+
+    bool empty() const { return size_ == 0; }
+
+    template <class... Args>
+    void emplace_back(Args &&...args) {
+        assert(size_ < kMaxCapacity);
+        reserve(size_ + 1);
+        new (GetWorkingStore() + size_) value_type(args...);
+        size_++;
+    }
+
+    // Note: probably should update this to reflect C++23 ranges
+    template <typename Container>
+    void PushBackFrom(const Container &from) {
+        assert(from.size() <= kMaxCapacity);
+        assert(size_ <= kMaxCapacity - from.size());
+        const size_type new_size = size_ + static_cast<size_type>(from.size());
+        reserve(new_size);
+
+        auto dest = GetWorkingStore() + size_;
+        for (const auto &element : from) {
+            new (dest) value_type(element);
+            ++dest;
+        }
+        size_ = new_size;
+    }
+
+    template <typename Container>
+    void PushBackFrom(Container &&from) {
+        assert(from.size() < kMaxCapacity);
+        const size_type new_size = size_ + static_cast<size_type>(from.size());
+        reserve(new_size);
+
+        auto dest = GetWorkingStore() + size_;
+        for (auto &element : from) {
+            new (dest) value_type(std::move(element));
+            ++dest;
+        }
+        size_ = new_size;
+    }
+
+    void reserve(size_type new_cap) {
+        // Since this can't shrink, if we're growing we're newing
+        if (new_cap > capacity_) {
+            assert(capacity_ >= kSmallCapacity);
+            auto new_store = std::unique_ptr<BackingStore[]>(new BackingStore[new_cap]);
+            auto working_store = GetWorkingStore();
+            for (size_type i = 0; i < size_; i++) {
+                new (new_store[i].data) value_type(std::move(working_store[i]));
+                working_store[i].~value_type();
+            }
+            large_store_ = std::move(new_store);
+            assert(new_cap > kSmallCapacity);
+            capacity_ = new_cap;
+        }
+        UpdateWorkingStore();
+        // No shrink here.
+    }
+
+    void clear() {
+        // Keep clear minimal to optimize reset functions for enduring objects
+        // more work is deferred until destruction (freeing of large_store for example)
+        // and we intentionally *aren't* shrinking.  Callers that desire shrink semantics
+        // can call shrink_to_fit.
+        auto working_store = GetWorkingStore();
+        for (size_type i = 0; i < size_; i++) {
+            working_store[i].~value_type();
+        }
+        size_ = 0;
+    }
+
+    void resize(size_type count) {
+        struct ValueInitTag {  // tag to request value-initialization
+            explicit ValueInitTag() = default;
+        };
+        Resize(count, ValueInitTag{});
+    }
+
+    void resize(size_type count, const value_type &value) { Resize(count, value); }
+
+    void shrink_to_fit() {
+        if (size_ == 0) {
+            // shrink resets to small when empty
+            capacity_ = kSmallCapacity;
+            large_store_.reset();
+            UpdateWorkingStore();
+        } else if ((capacity_ > kSmallCapacity) && (capacity_ > size_)) {
+            auto source = GetWorkingStore();
+            // Keep the source from disappearing until the end of the function
+            auto old_store = std::unique_ptr<BackingStore[]>(std::move(large_store_));
+            assert(!large_store_);
+            if (size_ < kSmallCapacity) {
+                capacity_ = kSmallCapacity;
+            } else {
+                large_store_ = std::unique_ptr<BackingStore[]>(new BackingStore[size_]);
+                capacity_ = size_;
+            }
+            UpdateWorkingStore();
+            auto dest = GetWorkingStore();
+            for (size_type i = 0; i < size_; i++) {
+                dest[i] = std::move(source[i]);
+                source[i].~value_type();
+            }
+        }
+    }
+
+    inline iterator begin() { return GetWorkingStore(); }
+    inline const_iterator cbegin() const { return GetWorkingStore(); }
+    inline const_iterator begin() const { return GetWorkingStore(); }
+
+    inline iterator end() { return GetWorkingStore() + size_; }
+    inline const_iterator cend() const { return GetWorkingStore() + size_; }
+    inline const_iterator end() const { return GetWorkingStore() + size_; }
+    inline size_type size() const { return size_; }
+    auto capacity() const { return capacity_; }
+
+    inline pointer data() { return GetWorkingStore(); }
+    inline const_pointer data() const { return GetWorkingStore(); }
+
+  protected:
+    inline const_pointer ComputeWorkingStore() const {
+        assert(large_store_ || (capacity_ == kSmallCapacity));
+
+        const BackingStore *store = large_store_ ? large_store_.get() : small_store_;
+        return &store->object;
+    }
+    inline pointer ComputeWorkingStore() {
+        assert(large_store_ || (capacity_ == kSmallCapacity));
+
+        BackingStore *store = large_store_ ? large_store_.get() : small_store_;
+        return &store->object;
+    }
+
+    void UpdateWorkingStore() { working_store_ = ComputeWorkingStore(); }
+
+    inline const_pointer GetWorkingStore() const {
+        DbgWorkingStoreCheck();
+        return working_store_;
+    }
+    inline pointer GetWorkingStore() {
+        DbgWorkingStoreCheck();
+        return working_store_;
+    }
+
+    inline pointer GetSmallStore() { return &small_store_->object; }
+
+    union BackingStore {
+        BackingStore() {}
+        ~BackingStore() {}
+
+        uint8_t data[sizeof(value_type)];
+        value_type object;
+    };
+    size_type size_;
+    size_type capacity_;
+    BackingStore small_store_[N];
+    std::unique_ptr<BackingStore[]> large_store_;
+    value_type *working_store_;
+
+#ifndef NDEBUG
+    void DbgWorkingStoreCheck() const { assert(ComputeWorkingStore() == working_store_); }
+#else
+    void DbgWorkingStoreCheck() const {}
+#endif
+
+  private:
+    void MoveLargeStore(vector &other) {
+        assert(other.large_store_);
+        assert(other.capacity_ > kSmallCapacity);
+        // In move operations, from a small vector with a large store, we can move from it
+        large_store_ = std::move(other.large_store_);
+        capacity_ = other.capacity_;
+        size_ = other.size_;
+        UpdateWorkingStore();
+
+        // We've stolen other's large store, must leave it in a valid state
+        other.size_ = 0;
+        other.capacity_ = kSmallCapacity;
+        other.UpdateWorkingStore();
+    }
+
+    template <typename T2>
+    void Resize(size_type new_size, const T2 &value) {
+        if (new_size < size_) {
+            auto working_store = GetWorkingStore();
+            for (size_type i = new_size; i < size_; i++) {
+                working_store[i].~value_type();
+            }
+            size_ = new_size;
+        } else if (new_size > size_) {
+            reserve(new_size);
+            // if T2 != T and T is not DefaultInsertable, new values will be undefined
+            if constexpr (std::is_same_v<T2, T> || std::is_default_constructible_v<T>) {
+                for (size_type i = size_; i < new_size; ++i) {
+                    if constexpr (std::is_same_v<T2, T>) {
+                        emplace_back(value_type(value));
+                    } else if constexpr (std::is_default_constructible_v<T>) {
+                        emplace_back(value_type());
+                    }
+                }
+                assert(size() == new_size);
+            } else {
+                size_ = new_size;
+            }
+        }
+    }
+};
+
+// This is a wrapper around unordered_map that optimizes for the common case
+// of only containing a small number of elements. The first N elements are stored
+// inline in the object and don't require hashing or memory (de)allocation.
+
+template <typename Key, typename value_type, typename inner_container_type, typename value_type_helper, int N>
+class container_base {
+  protected:
+    bool small_data_allocated[N];
+    value_type small_data[N];
+
+    inner_container_type inner_cont;
+
+    value_type_helper helper;
+
+  public:
+    container_base() {
+        for (int i = 0; i < N; ++i) {
+            small_data_allocated[i] = false;
+        }
+    }
+
+    class iterator {
+        typedef typename inner_container_type::iterator inner_iterator;
+        friend class container_base<Key, value_type, inner_container_type, value_type_helper, N>;
+
+        container_base<Key, value_type, inner_container_type, value_type_helper, N> *parent;
+        int index;
+        inner_iterator it;
+
+      public:
+        iterator() {}
+
+        iterator operator++() {
+            if (index < N) {
+                index++;
+                while (index < N && !parent->small_data_allocated[index]) {
+                    index++;
+                }
+                if (index < N) {
+                    return *this;
+                }
+                it = parent->inner_cont.begin();
+                return *this;
+            }
+            ++it;
+            return *this;
+        }
+
+        bool operator==(const iterator &other) const {
+            if ((index < N) != (other.index < N)) {
+                return false;
+            }
+            if (index < N) {
+                return (index == other.index);
+            }
+            return it == other.it;
+        }
+
+        bool operator!=(const iterator &other) const { return !(*this == other); }
+
+        value_type &operator*() const {
+            if (index < N) {
+                return parent->small_data[index];
+            }
+            return *it;
+        }
+        value_type *operator->() const {
+            if (index < N) {
+                return &parent->small_data[index];
+            }
+            return &*it;
+        }
+    };
+
+    class const_iterator {
+        typedef typename inner_container_type::const_iterator inner_iterator;
+        friend class container_base<Key, value_type, inner_container_type, value_type_helper, N>;
+
+        const container_base<Key, value_type, inner_container_type, value_type_helper, N> *parent;
+        int index;
+        inner_iterator it;
+
+      public:
+        const_iterator() {}
+
+        const_iterator operator++() {
+            if (index < N) {
+                index++;
+                while (index < N && !parent->small_data_allocated[index]) {
+                    index++;
+                }
+                if (index < N) {
+                    return *this;
+                }
+                it = parent->inner_cont.begin();
+                return *this;
+            }
+            ++it;
+            return *this;
+        }
+
+        bool operator==(const const_iterator &other) const {
+            if ((index < N) != (other.index < N)) {
+                return false;
+            }
+            if (index < N) {
+                return (index == other.index);
+            }
+            return it == other.it;
+        }
+
+        bool operator!=(const const_iterator &other) const { return !(*this == other); }
+
+        const value_type &operator*() const {
+            if (index < N) {
+                return parent->small_data[index];
+            }
+            return *it;
+        }
+        const value_type *operator->() const {
+            if (index < N) {
+                return &parent->small_data[index];
+            }
+            return &*it;
+        }
+    };
+
+    iterator begin() {
+        iterator it;
+        it.parent = this;
+        // If index 0 is allocated, return it, otherwise use operator++ to find the first
+        // allocated element.
+        it.index = 0;
+        if (small_data_allocated[0]) {
+            return it;
+        }
+        ++it;
+        return it;
+    }
+
+    iterator end() {
+        iterator it;
+        it.parent = this;
+        it.index = N;
+        it.it = inner_cont.end();
+        return it;
+    }
+
+    const_iterator begin() const {
+        const_iterator it;
+        it.parent = this;
+        // If index 0 is allocated, return it, otherwise use operator++ to find the first
+        // allocated element.
+        it.index = 0;
+        if (small_data_allocated[0]) {
+            return it;
+        }
+        ++it;
+        return it;
+    }
+
+    const_iterator end() const {
+        const_iterator it;
+        it.parent = this;
+        it.index = N;
+        it.it = inner_cont.end();
+        return it;
+    }
+
+    bool contains(const Key &key) const {
+        for (int i = 0; i < N; ++i) {
+            if (small_data_allocated[i] && helper.compare_equal(small_data[i], key)) {
+                return true;
+            }
+        }
+        // check size() first to avoid hashing key unnecessarily.
+        if (inner_cont.size() == 0) {
+            return false;
+        }
+        return inner_cont.find(key) != inner_cont.end();
+    }
+
+    typename inner_container_type::size_type count(const Key &key) const { return contains(key) ? 1 : 0; }
+
+    std::pair<iterator, bool> insert(const value_type &value) {
+        for (int i = 0; i < N; ++i) {
+            if (small_data_allocated[i] && helper.compare_equal(small_data[i], value)) {
+                iterator it;
+                it.parent = this;
+                it.index = i;
+                return std::make_pair(it, false);
+            }
+        }
+        // check size() first to avoid hashing key unnecessarily.
+        auto iter = inner_cont.size() > 0 ? inner_cont.find(helper.get_key(value)) : inner_cont.end();
+        if (iter != inner_cont.end()) {
+            iterator it;
+            it.parent = this;
+            it.index = N;
+            it.it = iter;
+            return std::make_pair(it, false);
+        } else {
+            for (int i = 0; i < N; ++i) {
+                if (!small_data_allocated[i]) {
+                    small_data_allocated[i] = true;
+                    helper.assign(small_data[i], value);
+                    iterator it;
+                    it.parent = this;
+                    it.index = i;
+                    return std::make_pair(it, true);
+                }
+            }
+            iter = inner_cont.insert(value).first;
+            iterator it;
+            it.parent = this;
+            it.index = N;
+            it.it = iter;
+            return std::make_pair(it, true);
+        }
+    }
+
+    typename inner_container_type::size_type erase(const Key &key) {
+        for (int i = 0; i < N; ++i) {
+            if (small_data_allocated[i] && helper.compare_equal(small_data[i], key)) {
+                small_data_allocated[i] = false;
+                return 1;
+            }
+        }
+        return inner_cont.erase(key);
+    }
+
+    typename inner_container_type::size_type size() const {
+        auto size = inner_cont.size();
+        for (int i = 0; i < N; ++i) {
+            if (small_data_allocated[i]) {
+                size++;
+            }
+        }
+        return size;
+    }
+
+    bool empty() const {
+        for (int i = 0; i < N; ++i) {
+            if (small_data_allocated[i]) {
+                return false;
+            }
+        }
+        return inner_cont.size() == 0;
+    }
+
+    void clear() {
+        for (int i = 0; i < N; ++i) {
+            small_data_allocated[i] = false;
+        }
+        inner_cont.clear();
+    }
+};
+
+// Helper function objects to compare/assign/get keys in small_unordered_set/map.
+// This helps to abstract away whether value_type is a Key or a pair<Key, T>.
+template <typename MapType>
+class value_type_helper_map {
+    using PairType = typename MapType::value_type;
+    using Key = typename std::remove_const<typename PairType::first_type>::type;
+
+  public:
+    bool compare_equal(const PairType &lhs, const Key &rhs) const { return lhs.first == rhs; }
+    bool compare_equal(const PairType &lhs, const PairType &rhs) const { return lhs.first == rhs.first; }
+
+    void assign(PairType &lhs, const PairType &rhs) const {
+        // While the const_cast may be unsatisfactory, we are using small_data as
+        // stand-in for placement new and a small-block allocator, so the const_cast
+        // is minimal, contained, valid, and allows operators * and -> to avoid copies
+        const_cast<Key &>(lhs.first) = rhs.first;
+        lhs.second = rhs.second;
+    }
+
+    Key get_key(const PairType &value) const { return value.first; }
+};
+
+template <typename Key>
+class value_type_helper_set {
+  public:
+    bool compare_equal(const Key &lhs, const Key &rhs) const { return lhs == rhs; }
+
+    void assign(Key &lhs, const Key &rhs) const { lhs = rhs; }
+
+    Key get_key(const Key &value) const { return value; }
+};
+
+template <typename Key, typename T, int N = 1, typename Map = std::unordered_map<Key, T>>
+class unordered_map : public container_base<Key, typename Map::value_type, Map, value_type_helper_map<Map>, N> {
+  public:
+    T &operator[](const Key &key) {
+        for (int i = 0; i < N; ++i) {
+            if (this->small_data_allocated[i] && this->helper.compare_equal(this->small_data[i], key)) {
+                return this->small_data[i].second;
+            }
+        }
+        auto iter = this->inner_cont.find(key);
+        if (iter != this->inner_cont.end()) {
+            return iter->second;
+        } else {
+            for (int i = 0; i < N; ++i) {
+                if (!this->small_data_allocated[i]) {
+                    this->small_data_allocated[i] = true;
+                    this->helper.assign(this->small_data[i], {key, T()});
+
+                    return this->small_data[i].second;
+                }
+            }
+            return this->inner_cont[key];
+        }
+    }
+};
+
+template <typename Key, int N = 1, typename Set = std::unordered_set<Key>>
+class unordered_set : public container_base<Key, Key, Set, value_type_helper_set<Key>, N> {};
+
+}  // namespace small
+}  // namespace vku
diff --git a/include/vulkan/utility/vk_sparse_range_map.hpp b/include/vulkan/utility/vk_sparse_range_map.hpp
new file mode 100644
index 0000000..36b8460
--- /dev/null
+++ b/include/vulkan/utility/vk_sparse_range_map.hpp
@@ -0,0 +1,2033 @@
+/* Copyright (c) 2019-2024 The Khronos Group Inc.
+ * Copyright (c) 2019-2024 Valve Corporation
+ * Copyright (c) 2019-2024 LunarG, Inc.
+ * Copyright (C) 2019-2024 Google Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ */
+#pragma once
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <limits>
+#include <map>
+#include <optional>
+#include <string>
+#include <sstream>
+#include <utility>
+#include <cstdint>
+#include <vulkan/utility/vk_small_containers.hpp>
+
+namespace vku {
+namespace sparse {
+// range_map
+//
+// Implements an ordered map of non-overlapping, non-empty ranges
+//
+template <typename Index>
+struct range {
+    using index_type = Index;
+    index_type begin;  // Inclusive lower bound of range
+    index_type end;    // Exlcusive upper bound of range
+
+    inline bool empty() const { return begin == end; }
+    inline bool valid() const { return begin <= end; }
+    inline bool invalid() const { return !valid(); }
+    inline bool non_empty() const { return begin < end; }  //  valid and !empty
+
+    inline bool is_prior_to(const range &other) const { return end == other.begin; }
+    inline bool is_subsequent_to(const range &other) const { return begin == other.end; }
+    inline bool includes(const index_type &index) const { return (begin <= index) && (index < end); }
+    inline bool includes(const range &other) const { return (begin <= other.begin) && (other.end <= end); }
+    inline bool excludes(const index_type &index) const { return (index < begin) || (end <= index); }
+    inline bool excludes(const range &other) const { return (other.end <= begin) || (end <= other.begin); }
+    inline bool intersects(const range &other) const { return includes(other.begin) || other.includes(begin); }
+    inline index_type distance() const { return end - begin; }
+
+    inline bool operator==(const range &rhs) const { return (begin == rhs.begin) && (end == rhs.end); }
+    inline bool operator!=(const range &rhs) const { return (begin != rhs.begin) || (end != rhs.end); }
+
+    inline range &operator-=(const index_type &offset) {
+        begin = begin - offset;
+        end = end - offset;
+        return *this;
+    }
+
+    inline range &operator+=(const index_type &offset) {
+        begin = begin + offset;
+        end = end + offset;
+        return *this;
+    }
+
+    inline range operator+(const index_type &offset) const { return range(begin + offset, end + offset); }
+
+    // for a reversible/transitive < operator compare first on begin and then end
+    // only less or begin is less or if end is less when begin is equal
+    bool operator<(const range &rhs) const {
+        bool result = false;
+        if (invalid()) {
+            // all invalid < valid, allows map/set validity check by looking at begin()->first
+            // all invalid are equal, thus only equal if this is invalid and rhs is valid
+            result = rhs.valid();
+        } else if (begin < rhs.begin) {
+            result = true;
+        } else if ((begin == rhs.begin) && (end < rhs.end)) {
+            result = true;  // Simple common case -- boundary case require equality check for correctness.
+        }
+        return result;
+    }
+
+    // use as "strictly less/greater than" to check for non-overlapping ranges
+    bool strictly_less(const range &rhs) const { return end <= rhs.begin; }
+    bool strictly_less(const index_type &index) const { return end <= index; }
+    bool strictly_greater(const range &rhs) const { return rhs.end <= begin; }
+    bool strictly_greater(const index_type &index) const { return index < begin; }
+
+    range &operator=(const range &rhs) {
+        begin = rhs.begin;
+        end = rhs.end;
+        return *this;
+    }
+
+    // Compute ranges intersection. Returns empty range on non-intersection
+    range operator&(const range &rhs) const {
+        if (includes(rhs.begin)) {
+            return range(rhs.begin, std::min(end, rhs.end));
+        } else if (rhs.includes(begin)) {
+            return range(begin, std::min(end, rhs.end));
+        }
+        return range();
+    }
+
+    index_type size() const { return end - begin; }
+    range() : begin(), end() {}
+    range(const index_type &begin_, const index_type &end_) : begin(begin_), end(end_) {}
+    range(const range &other) : begin(other.begin), end(other.end) {}
+};
+
+template <typename Range>
+class range_view {
+  public:
+    using index_type = typename Range::index_type;
+    class iterator {
+      public:
+        iterator &operator++() {
+            ++current;
+            return *this;
+        }
+        const index_type &operator*() const { return current; }
+        bool operator!=(const iterator &rhs) const { return current != rhs.current; }
+        iterator(index_type value) : current(value) {}
+
+      private:
+        index_type current;
+    };
+    range_view(const Range &range) : range_(range) {}
+    const iterator begin() const { return iterator(range_.begin); }
+    const iterator end() const { return iterator(range_.end); }
+
+  private:
+    const Range &range_;
+};
+
+template <typename Range>
+std::string string_range(const Range &range) {
+    std::stringstream ss;
+    ss << "[" << range.begin << ", " << range.end << ')';
+    return ss.str();
+}
+
+template <typename Range>
+std::string string_range_hex(const Range &range) {
+    std::stringstream ss;
+    ss << std::hex << "[0x" << range.begin << ", 0x" << range.end << ')';
+    return ss.str();
+}
+
+// Type parameters for the range_map(s)
+struct insert_range_no_split_bounds {
+    const static bool split_boundaries = false;
+};
+
+struct insert_range_split_bounds {
+    const static bool split_boundaries = true;
+};
+
+struct split_op_keep_both {
+    static constexpr bool keep_lower() { return true; }
+    static constexpr bool keep_upper() { return true; }
+};
+
+struct split_op_keep_lower {
+    static constexpr bool keep_lower() { return true; }
+    static constexpr bool keep_upper() { return false; }
+};
+
+struct split_op_keep_upper {
+    static constexpr bool keep_lower() { return false; }
+    static constexpr bool keep_upper() { return true; }
+};
+
+enum class value_precedence { prefer_source, prefer_dest };
+
+template <typename Iterator, typename Map, typename Range>
+Iterator split(Iterator in, Map &map, const Range &range);
+
+// The range based sparse map implemented on the ImplMap
+template <typename Key, typename T, typename RangeKey = range<Key>, typename ImplMap = std::map<RangeKey, T>>
+class range_map {
+  public:
+  protected:
+    using MapKey = RangeKey;
+    ImplMap impl_map_;
+    using ImplIterator = typename ImplMap::iterator;
+    using ImplConstIterator = typename ImplMap::const_iterator;
+
+  public:
+    using mapped_type = typename ImplMap::mapped_type;
+    using value_type = typename ImplMap::value_type;
+    using key_type = typename ImplMap::key_type;
+    using index_type = typename key_type::index_type;
+    using size_type = typename ImplMap::size_type;
+
+  protected:
+    template <typename ThisType>
+    using ConstCorrectImplIterator = decltype(std::declval<ThisType>().impl_begin());
+
+    template <typename ThisType, typename WrappedIterator = ConstCorrectImplIterator<ThisType>>
+    static WrappedIterator lower_bound_impl(ThisType &that, const key_type &key) {
+        if (key.valid()) {
+            // ImplMap doesn't give us what want with a direct query, it will give us the first entry contained (if any) in key,
+            // not the first entry intersecting key, so, first look for the the first entry that starts at or after key.begin
+            // with the operator > in range, we can safely use an empty range for comparison
+            auto lower = that.impl_map_.lower_bound(key_type(key.begin, key.begin));
+
+            // If there is a preceding entry it's possible that begin is included, as all we know is that lower.begin >= key.begin
+            // or lower is at end
+            if (!that.at_impl_begin(lower)) {
+                auto prev = lower;
+                --prev;
+                // If the previous entry includes begin (and we know key.begin > prev.begin) then prev is actually lower
+                if (key.begin < prev->first.end) {
+                    lower = prev;
+                }
+            }
+            return lower;
+        }
+        // Key is ill-formed
+        return that.impl_end();  // Point safely to nothing.
+    }
+
+    ImplIterator lower_bound_impl(const key_type &key) { return lower_bound_impl(*this, key); }
+
+    ImplConstIterator lower_bound_impl(const key_type &key) const { return lower_bound_impl(*this, key); }
+
+    template <typename ThisType, typename WrappedIterator = ConstCorrectImplIterator<ThisType>>
+    static WrappedIterator upper_bound_impl(ThisType &that, const key_type &key) {
+        if (key.valid()) {
+            // the upper bound is the first range that is full greater (upper.begin >= key.end
+            // we can get close by looking for the first to exclude key.end, then adjust to account for the fact that key.end is
+            // exclusive and we thus ImplMap::upper_bound may be off by one here, i.e. the previous may be the upper bound
+            auto upper = that.impl_map_.upper_bound(key_type(key.end, key.end));
+            if (!that.at_impl_end(upper) && (upper != that.impl_begin())) {
+                auto prev = upper;
+                --prev;
+                // We know key.end  is >= prev.begin, the only question is whether it's ==
+                if (prev->first.begin == key.end) {
+                    upper = prev;
+                }
+            }
+            return upper;
+        }
+        return that.impl_end();  // Point safely to nothing.
+    }
+
+    ImplIterator upper_bound_impl(const key_type &key) { return upper_bound_impl(*this, key); }
+
+    ImplConstIterator upper_bound_impl(const key_type &key) const { return upper_bound_impl(*this, key); }
+
+    ImplIterator impl_find(const key_type &key) { return impl_map_.find(key); }
+    ImplConstIterator impl_find(const key_type &key) const { return impl_map_.find(key); }
+    bool impl_not_found(const key_type &key) const { return impl_end() == impl_find(key); }
+
+    ImplIterator impl_end() { return impl_map_.end(); }
+    ImplConstIterator impl_end() const { return impl_map_.end(); }
+
+    ImplIterator impl_begin() { return impl_map_.begin(); }
+    ImplConstIterator impl_begin() const { return impl_map_.begin(); }
+
+    inline bool at_impl_end(const ImplIterator &pos) { return pos == impl_end(); }
+    inline bool at_impl_end(const ImplConstIterator &pos) const { return pos == impl_end(); }
+
+    inline bool at_impl_begin(const ImplIterator &pos) { return pos == impl_begin(); }
+    inline bool at_impl_begin(const ImplConstIterator &pos) const { return pos == impl_begin(); }
+
+    ImplIterator impl_erase(const ImplIterator &pos) { return impl_map_.erase(pos); }
+
+    template <typename Value>
+    ImplIterator impl_insert(const ImplIterator &hint, Value &&value) {
+        assert(impl_not_found(value.first));
+        assert(value.first.non_empty());
+        return impl_map_.emplace_hint(hint, std::forward<Value>(value));
+    }
+    ImplIterator impl_insert(const ImplIterator &hint, const key_type &key, const mapped_type &value) {
+        return impl_insert(hint, std::make_pair(key, value));
+    }
+
+    ImplIterator impl_insert(const ImplIterator &hint, const index_type &begin, const index_type &end, const mapped_type &value) {
+        return impl_insert(hint, key_type(begin, end), value);
+    }
+
+    template <typename SplitOp>
+    ImplIterator split_impl(const ImplIterator &split_it, const index_type &index, const SplitOp &) {
+        // Make sure contains the split point
+        if (!split_it->first.includes(index)) return split_it;  // If we don't have a valid split point, just return the iterator
+
+        const auto range = split_it->first;
+        key_type lower_range(range.begin, index);
+        if (lower_range.empty() && SplitOp::keep_upper()) {
+            return split_it;  // this is a noop we're keeping the upper half which is the same as split_it;
+        }
+        // Save the contents of it and erase it
+        auto value = split_it->second;
+        auto next_it = impl_map_.erase(split_it);  // Keep this, just in case the split point results in an empty "keep" set
+
+        if (lower_range.empty() && !SplitOp::keep_upper()) {
+            // This effectively an erase...
+            return next_it;
+        }
+        // Upper range cannot be empty
+        key_type upper_range(index, range.end);
+        key_type move_range;
+        key_type copy_range;
+
+        // Were either going to keep one or both of the split pieces.  If we keep both, we'll copy value to the upper,
+        // and move to the lower, and return the lower, else move to, and return the kept one.
+        if (SplitOp::keep_lower() && !lower_range.empty()) {
+            move_range = lower_range;
+            if (SplitOp::keep_upper()) {
+                copy_range = upper_range;  // only need a valid copy range if we keep both.
+            }
+        } else if (SplitOp::keep_upper()) {  // We're not keeping the lower split because it's either empty or not wanted
+            move_range = upper_range;        // this will be non_empty as index is included ( < end) in the original range)
+        }
+
+        // we insert from upper to lower because that's what emplace_hint can do in constant time. (not log time in C++11)
+        if (!copy_range.empty()) {
+            // We have a second range to create, so do it by copy
+            assert(impl_map_.find(copy_range) == impl_map_.end());
+            next_it = impl_map_.emplace_hint(next_it, std::make_pair(copy_range, value));
+        }
+
+        if (!move_range.empty()) {
+            // Whether we keep one or both, the one we return gets value moved to it, as the other one already has a copy
+            assert(impl_map_.find(move_range) == impl_map_.end());
+            next_it = impl_map_.emplace_hint(next_it, std::make_pair(move_range, std::move(value)));
+        }
+
+        // point to the beginning of the inserted elements (or the next from the erase
+        return next_it;
+    }
+
+    // do an ranged insert that splits existing ranges at the boundaries, and writes value to any non-initialized sub-ranges
+    range<ImplIterator> infill_and_split(const key_type &bounds, const mapped_type &value, ImplIterator lower, bool split_bounds) {
+        auto pos = lower;
+        if (at_impl_end(pos)) return range<ImplIterator>(pos, pos);  // defensive...
+
+        // Logic assumes we are starting at lower bound
+        assert(lower == lower_bound_impl(bounds));
+
+        // Trim/infil the beginning if needed
+        const auto first_begin = pos->first.begin;
+        if (bounds.begin > first_begin && split_bounds) {
+            pos = split_impl(pos, bounds.begin, split_op_keep_both());
+            lower = pos;
+            ++lower;
+            assert(lower == lower_bound_impl(bounds));
+        } else if (bounds.begin < first_begin) {
+            pos = impl_insert(pos, bounds.begin, first_begin, value);
+            lower = pos;
+            assert(lower == lower_bound_impl(bounds));
+        }
+
+        // in the trim case pos starts one before lower_bound, but that allows trimming a single entry range in loop.
+        // NOTE that the loop is trimming and infilling at pos + 1
+        while (!at_impl_end(pos) && pos->first.begin < bounds.end) {
+            auto last_end = pos->first.end;
+            // check for in-fill
+            ++pos;
+            if (at_impl_end(pos)) {
+                if (last_end < bounds.end) {
+                    // Gap after last entry in impl_map and before end,
+                    pos = impl_insert(pos, last_end, bounds.end, value);
+                    ++pos;  // advances to impl_end, as we're at upper boundary
+                    assert(at_impl_end(pos));
+                }
+            } else if (pos->first.begin != last_end) {
+                // we have a gap between last entry and current... fill, but not beyond bounds
+                if (bounds.includes(pos->first.begin)) {
+                    pos = impl_insert(pos, last_end, pos->first.begin, value);
+                    //  don't further advance pos, because we may need to split the next entry and thus can't skip it.
+                } else if (last_end < bounds.end) {
+                    // Non-zero length final gap in-bounds
+                    pos = impl_insert(pos, last_end, bounds.end, value);
+                    ++pos;  // advances back to the out of bounds entry which we inserted just before
+                    assert(!bounds.includes(pos->first.begin));
+                }
+            } else if (pos->first.includes(bounds.end)) {
+                if (split_bounds) {
+                    // extends past the end of the bounds range, snip to only include the bounded section
+                    // NOTE: this splits pos, but the upper half of the split should now be considered upper_bound
+                    // for the range
+                    pos = split_impl(pos, bounds.end, split_op_keep_both());
+                }
+                // advance to the upper half of the split which will be upper_bound  or to next which will both be out of bounds
+                ++pos;
+                assert(!bounds.includes(pos->first.begin));
+            }
+        }
+        // Return the current position which should be the upper_bound for bounds
+        assert(pos == upper_bound_impl(bounds));
+        return range<ImplIterator>(lower, pos);
+    }
+
+    template <typename TouchOp>
+    ImplIterator impl_erase_range(const key_type &bounds, ImplIterator lower, const TouchOp &touch_mapped_value) {
+        // Logic assumes we are starting at a valid lower bound
+        assert(!at_impl_end(lower));
+        assert(lower == lower_bound_impl(bounds));
+
+        // Trim/infill the beginning if needed
+        auto current = lower;
+        const auto first_begin = current->first.begin;
+        if (bounds.begin > first_begin) {
+            // Preserve the portion of lower bound excluded from bounds
+            if (current->first.end <= bounds.end) {
+                // If current ends within the erased bound we can discard the the upper portion of current
+                current = split_impl(current, bounds.begin, split_op_keep_lower());
+            } else {
+                // Keep the upper portion of current for the later split below
+                current = split_impl(current, bounds.begin, split_op_keep_both());
+            }
+            // Exclude the preserved portion
+            ++current;
+            assert(current == lower_bound_impl(bounds));
+        }
+
+        // Loop over completely contained entries and erase them
+        while (!at_impl_end(current) && (current->first.end <= bounds.end)) {
+            if (touch_mapped_value(current->second)) {
+                current = impl_erase(current);
+            } else {
+                ++current;
+            }
+        }
+
+        if (!at_impl_end(current) && current->first.includes(bounds.end)) {
+            // last entry extends past the end of the bounds range, snip to only erase the bounded section
+            current = split_impl(current, bounds.end, split_op_keep_both());
+            // test if lower_bound (eventually) computed in split_impl is not empty.
+            // If it is not empty, then it contains values inside the bounds range,
+            // they need to be touched
+            if ((current->first & bounds).non_empty()) {
+                if (touch_mapped_value(current->second)) {
+                    current = impl_erase(current);
+                } else {
+                    // make current point to upper bound
+                    ++current;
+                }
+            }
+        }
+
+        assert(current == upper_bound_impl(bounds));
+        return current;
+    }
+
+    template <typename ValueType, typename WrappedIterator_>
+    struct iterator_impl {
+      public:
+        friend class range_map;
+        using WrappedIterator = WrappedIterator_;
+
+      private:
+        WrappedIterator pos_;
+
+        // Create an iterator at a specific internal state -- only from the parent container
+        iterator_impl(const WrappedIterator &pos) : pos_(pos) {}
+
+      public:
+        iterator_impl() : iterator_impl(WrappedIterator()) {}
+        iterator_impl(const iterator_impl &other) : pos_(other.pos_) {}
+
+        iterator_impl &operator=(const iterator_impl &rhs) {
+            pos_ = rhs.pos_;
+            return *this;
+        }
+
+        inline bool operator==(const iterator_impl &rhs) const { return pos_ == rhs.pos_; }
+
+        inline bool operator!=(const iterator_impl &rhs) const { return pos_ != rhs.pos_; }
+
+        ValueType &operator*() const { return *pos_; }
+        ValueType *operator->() const { return &*pos_; }
+
+        iterator_impl &operator++() {
+            ++pos_;
+            return *this;
+        }
+
+        iterator_impl &operator--() {
+            --pos_;
+            return *this;
+        }
+
+        // To allow for iterator -> const_iterator construction
+        // NOTE: while it breaks strict encapsulation, it does so less than friend
+        const WrappedIterator &get_pos() const { return pos_; }
+    };
+
+  public:
+    using iterator = iterator_impl<value_type, ImplIterator>;
+
+    // The const iterator must be derived to allow the conversion from iterator, which iterator doesn't support
+    class const_iterator : public iterator_impl<const value_type, ImplConstIterator> {
+        using Base = iterator_impl<const value_type, ImplConstIterator>;
+        friend range_map;
+
+      public:
+        const_iterator &operator=(const const_iterator &other) {
+            Base::operator=(other);
+            return *this;
+        }
+        const_iterator(const const_iterator &other) : Base(other) {}
+        const_iterator(const iterator &it) : Base(ImplConstIterator(it.get_pos())) {}
+        const_iterator() : Base() {}
+
+      private:
+        const_iterator(const ImplConstIterator &pos) : Base(pos) {}
+    };
+
+  protected:
+    inline bool at_end(const iterator &it) { return at_impl_end(it.pos_); }
+    inline bool at_end(const const_iterator &it) const { return at_impl_end(it.pos_); }
+    inline bool at_begin(const iterator &it) { return at_impl_begin(it.pos_); }
+
+    template <typename That, typename Iterator>
+    static bool is_contiguous_impl(That *const that, const key_type &range, const Iterator &lower) {
+        // Search range or intersection is empty
+        if (lower == that->impl_end() || lower->first.excludes(range)) return false;
+
+        if (lower->first.includes(range)) {
+            return true;  // there is one entry that contains the whole key range
+        }
+
+        bool contiguous = true;
+        for (auto pos = lower; contiguous && pos != that->impl_end() && range.includes(pos->first.begin); ++pos) {
+            // if current doesn't cover the rest of the key range, check to see that the next is extant and abuts
+            if (pos->first.end < range.end) {
+                auto next = pos;
+                ++next;
+                contiguous = (next != that->impl_end()) && pos->first.is_prior_to(next->first);
+            }
+        }
+        return contiguous;
+    }
+
+  public:
+    iterator end() { return iterator(impl_map_.end()); }                          //  policy and bounds don't matter for end
+    const_iterator end() const { return const_iterator(impl_map_.end()); }        //  policy and bounds don't matter for end
+    iterator begin() { return iterator(impl_map_.begin()); }                      // with default policy, and thus no bounds
+    const_iterator begin() const { return const_iterator(impl_map_.begin()); }    // with default policy, and thus no bounds
+    const_iterator cbegin() const { return const_iterator(impl_map_.cbegin()); }  // with default policy, and thus no bounds
+    const_iterator cend() const { return const_iterator(impl_map_.cend()); }      // with default policy, and thus no bounds
+
+    iterator erase(const iterator &pos) {
+        assert(!at_end(pos));
+        return iterator(impl_erase(pos.pos_));
+    }
+
+    iterator erase(range<iterator> bounds) {
+        auto current = bounds.begin.pos_;
+        while (current != bounds.end.pos_) {
+            assert(!at_impl_end(current));
+            current = impl_map_.erase(current);
+        }
+        assert(current == bounds.end.pos_);
+        return current;
+    }
+
+    iterator erase(iterator first, iterator last) { return erase(range<iterator>(first, last)); }
+
+    // Before trying to erase a range, function touch_mapped_value is called on the mapped value.
+    // touch_mapped_value is allowed to have it's parameter type to be non const reference.
+    // If it returns true, regular erase will occur.
+    // Else, range is kept.
+    template <typename TouchOp>
+    iterator erase_range_or_touch(const key_type &bounds, const TouchOp &touch_mapped_value) {
+        auto lower = lower_bound_impl(bounds);
+
+        if (at_impl_end(lower) || !bounds.intersects(lower->first)) {
+            // There is nothing in this range lower bound is above bound
+            return iterator(lower);
+        }
+        auto next = impl_erase_range(bounds, lower, touch_mapped_value);
+        return iterator(next);
+    }
+
+    iterator erase_range(const key_type &bounds) {
+        return erase_range_or_touch(bounds, [](const auto &) { return true; });
+    }
+
+    void clear() { impl_map_.clear(); }
+
+    iterator find(const key_type &key) { return iterator(impl_map_.find(key)); }
+
+    const_iterator find(const key_type &key) const { return const_iterator(impl_map_.find(key)); }
+
+    iterator find(const index_type &index) {
+        auto lower = lower_bound(range<index_type>(index, index + 1));
+        if (!at_end(lower) && lower->first.includes(index)) {
+            return lower;
+        }
+        return end();
+    }
+
+    const_iterator find(const index_type &index) const {
+        auto lower = lower_bound(key_type(index, index + 1));
+        if (!at_end(lower) && lower->first.includes(index)) {
+            return lower;
+        }
+        return end();
+    }
+
+    iterator lower_bound(const key_type &key) { return iterator(lower_bound_impl(key)); }
+
+    const_iterator lower_bound(const key_type &key) const { return const_iterator(lower_bound_impl(key)); }
+
+    iterator upper_bound(const key_type &key) { return iterator(upper_bound_impl(key)); }
+
+    const_iterator upper_bound(const key_type &key) const { return const_iterator(upper_bound_impl(key)); }
+
+    range<iterator> bounds(const key_type &key) { return {lower_bound(key), upper_bound(key)}; }
+    range<const_iterator> cbounds(const key_type &key) const { return {lower_bound(key), upper_bound(key)}; }
+    range<const_iterator> bounds(const key_type &key) const { return cbounds(key); }
+
+    using insert_pair = std::pair<iterator, bool>;
+
+    // This is traditional no replacement insert.
+    insert_pair insert(const value_type &value) {
+        const auto &key = value.first;
+        if (!key.non_empty()) {
+            // It's an invalid key, early bail pointing to end
+            return std::make_pair(end(), false);
+        }
+
+        // Look for range conflicts (and an insertion point, which makes the lower_bound *not* wasted work)
+        // we don't have to check upper if just check that lower doesn't intersect (which it would if lower != upper)
+        auto lower = lower_bound_impl(key);
+        if (at_impl_end(lower) || !lower->first.intersects(key)) {
+            // range is not even partially overlapped, and lower is strictly > than key
+            auto impl_insert = impl_map_.emplace_hint(lower, value);
+            // auto impl_insert = impl_map_.emplace(value);
+            iterator wrap_it(impl_insert);
+            return std::make_pair(wrap_it, true);
+        }
+        // We don't replace
+        return std::make_pair(iterator(lower), false);
+    }
+
+    iterator insert(const_iterator hint, const value_type &value) {
+        bool hint_open;
+        ImplConstIterator impl_next = hint.pos_;
+        if (impl_map_.empty()) {
+            hint_open = true;
+        } else if (impl_next == impl_map_.cbegin()) {
+            hint_open = value.first.strictly_less(impl_next->first);
+        } else if (impl_next == impl_map_.cend()) {
+            auto impl_prev = impl_next;
+            --impl_prev;
+            hint_open = value.first.strictly_greater(impl_prev->first);
+        } else {
+            auto impl_prev = impl_next;
+            --impl_prev;
+            hint_open = value.first.strictly_greater(impl_prev->first) && value.first.strictly_less(impl_next->first);
+        }
+
+        if (!hint_open) {
+            // Hint was unhelpful, fall back to the non-hinted version
+            auto plain_insert = insert(value);
+            return plain_insert.first;
+        }
+
+        auto impl_insert = impl_map_.insert(impl_next, value);
+        return iterator(impl_insert);
+    }
+
+    // Try to insert value. If insertion failed, recursively split union of retrieved stored range with inserted range.
+    // Split at intersection of stored range and inserted range.
+    // Range intersection is merged using merge_op.
+    // Ranges before and after this intersection are recursively inserted.
+    // merge_pos should have this signature: (mapped_type& current_value, const mapped_type& new_value) -> void
+    template <typename MergeOp>
+    iterator split_and_merge_insert(const value_type &value, const MergeOp &merge_op) {
+        if (!value.first.non_empty()) {
+            return end();
+        }
+
+        if (auto [it, was_inserted] = insert(value); !was_inserted) {
+            // insert failed, so at least one stored range intersects with new range
+            const RangeKey it_range = it->first;
+            const auto &[inserted_range, insert_mapped_value] = value;
+            const RangeKey intersection = it_range & inserted_range;
+            // if intersection is empty or invalid, insertion should have succeeded
+            assert(intersection.non_empty());
+
+            const iterator split_point_it = split(it, *this, intersection);
+            // given it->first and instersection do intersect, split should have succeeded
+            assert(split_point_it != end());
+            // merge values at inserted range and retrieved range intersection
+            merge_op(split_point_it->second, insert_mapped_value);
+
+            // Recursively insert ranges before and after intersection
+            const RangeKey range_after_intersection(intersection.end, std::max(it_range.end, inserted_range.end));
+            const RangeKey range_before_intersection(std::min(it_range.begin, inserted_range.begin), intersection.begin);
+            split_and_merge_insert({range_after_intersection, insert_mapped_value}, merge_op);
+            if (range_before_intersection.non_empty()) {
+                return split_and_merge_insert({range_before_intersection, insert_mapped_value}, merge_op);
+            } else {
+                return split_point_it;
+            }
+        } else {
+            return it;
+        }
+    }
+
+    template <typename SplitOp>
+    iterator split(const iterator whole_it, const index_type &index, const SplitOp &split_op) {
+        auto split_it = split_impl(whole_it.pos_, index, split_op);
+        return iterator(split_it);
+    }
+
+    // The overwrite hint here is lower.... and if it's not right... this fails
+    template <typename Value>
+    iterator overwrite_range(const iterator &lower, Value &&value) {
+        // We're not robust to a bad hint, so detect it with extreme prejudice
+        // TODO: Add bad hint test to make this robust...
+        auto lower_impl = lower.pos_;
+        auto insert_hint = lower_impl;
+        if (!at_impl_end(lower_impl)) {
+            // If we're at end (and the hint is good, there's nothing to erase
+            assert(lower == lower_bound(value.first));
+            insert_hint = impl_erase_range(value.first, lower_impl, [](const auto &) { return true; });
+        }
+        auto inserted = impl_insert(insert_hint, std::forward<Value>(value));
+        return iterator(inserted);
+    }
+
+    template <typename Value>
+    iterator overwrite_range(Value &&value) {
+        auto lower = lower_bound(value.first);
+        return overwrite_range(lower, value);
+    }
+
+    bool empty() const { return impl_map_.empty(); }
+    size_type size() const { return impl_map_.size(); }
+
+    // For configuration/debug use // Use with caution...
+    ImplMap &get_implementation_map() { return impl_map_; }
+    const ImplMap &get_implementation_map() const { return impl_map_; }
+};
+
+template <typename Container>
+using const_correct_iterator = decltype(std::declval<Container>().begin());
+
+// The an array based small ordered map for range keys for use as the range map "ImplMap" as an alternate to std::map
+//
+// Assumes RangeKey::index_type is unsigned (TBD is it useful to generalize to unsigned?)
+// Assumes RangeKey implements begin, end, < and (TBD) from template range above
+template <typename Key, typename T, typename RangeKey = range<Key>, size_t N = 64, typename SmallIndex = uint8_t>
+class small_range_map {
+    using SmallRange = range<SmallIndex>;
+
+  public:
+    using mapped_type = T;
+    using key_type = RangeKey;
+    using value_type = std::pair<const key_type, mapped_type>;
+    using index_type = typename key_type::index_type;
+
+    using size_type = SmallIndex;
+    template <typename Map_, typename Value_>
+    struct IteratorImpl {
+      public:
+        using Map = Map_;
+        using Value = Value_;
+        friend Map;
+        Value *operator->() const { return map_->get_value(pos_); }
+        Value &operator*() const { return *(map_->get_value(pos_)); }
+        IteratorImpl &operator++() {
+            pos_ = map_->next_range(pos_);
+            return *this;
+        }
+        IteratorImpl &operator--() {
+            pos_ = map_->prev_range(pos_);
+            return *this;
+        }
+        IteratorImpl &operator=(const IteratorImpl &other) {
+            map_ = other.map_;
+            pos_ = other.pos_;
+            return *this;
+        }
+        bool operator==(const IteratorImpl &other) const {
+            if (at_end() && other.at_end()) {
+                return true;  // all ends are equal
+            }
+            return (map_ == other.map_) && (pos_ == other.pos_);
+        }
+        bool operator!=(const IteratorImpl &other) const { return !(*this == other); }
+
+        // At end()
+        IteratorImpl() : map_(nullptr), pos_(N) {}
+        IteratorImpl(const IteratorImpl &other) : map_(other.map_), pos_(other.pos_) {}
+
+        // Raw getters to allow for const_iterator conversion below
+        Map *get_map() const { return map_; }
+        SmallIndex get_pos() const { return pos_; }
+
+        bool at_end() const { return (map_ == nullptr) || (pos_ >= map_->get_limit()); }
+
+      protected:
+        IteratorImpl(Map *map, SmallIndex pos) : map_(map), pos_(pos) {}
+
+      private:
+        Map *map_;
+        SmallIndex pos_;  // the begin of the current small_range
+    };
+    using iterator = IteratorImpl<small_range_map, value_type>;
+
+    // The const iterator must be derived to allow the conversion from iterator, which iterator doesn't support
+    class const_iterator : public IteratorImpl<const small_range_map, const value_type> {
+        using Base = IteratorImpl<const small_range_map, const value_type>;
+        friend small_range_map;
+
+      public:
+        const_iterator(const iterator &it) : Base(it.get_map(), it.get_pos()) {}
+        const_iterator() : Base() {}
+
+      private:
+        const_iterator(const small_range_map *map, SmallIndex pos) : Base(map, pos) {}
+    };
+
+    iterator begin() {
+        // Either ranges of 0 is valid and begin is 0 and begin *or* it's invalid an points to the first valid range (or end)
+        return iterator(this, ranges_[0].begin);
+    }
+    const_iterator cbegin() const { return const_iterator(this, ranges_[0].begin); }
+    const_iterator begin() const { return cbegin(); }
+    iterator end() { return iterator(); }
+    const_iterator cend() const { return const_iterator(); }
+    const_iterator end() const { return cend(); }
+
+    void clear() {
+        const SmallRange clear_range(limit_, 0);
+        for (SmallIndex i = 0; i < limit_; ++i) {
+            auto &range = ranges_[i];
+            if (range.begin == i) {
+                // Clean up the backing store
+                destruct_value(i);
+            }
+            range = clear_range;
+        }
+        size_ = 0;
+    }
+
+    // Find entry with an exact key match (uncommon use case)
+    iterator find(const key_type &key) {
+        assert(in_bounds(key));
+        if (key.begin < limit_) {
+            const SmallIndex small_begin = static_cast<SmallIndex>(key.begin);
+            const auto &range = ranges_[small_begin];
+            if (range.begin == small_begin) {
+                const auto small_end = static_cast<SmallIndex>(key.end);
+                if (range.end == small_end) return iterator(this, small_begin);
+            }
+        }
+        return end();
+    }
+    const_iterator find(const key_type &key) const {
+        assert(in_bounds(key));
+        if (key.begin < limit_) {
+            const SmallIndex small_begin = static_cast<SmallIndex>(key.begin);
+            const auto &range = ranges_[small_begin];
+            if (range.begin == small_begin) {
+                const auto small_end = static_cast<SmallIndex>(key.end);
+                if (range.end == small_end) return const_iterator(this, small_begin);
+            }
+        }
+        return end();
+    }
+
+    iterator find(const index_type &index) {
+        if (index < get_limit()) {
+            const SmallIndex small_index = static_cast<SmallIndex>(index);
+            const auto &range = ranges_[small_index];
+            if (range.valid()) {
+                return iterator(this, range.begin);
+            }
+        }
+        return end();
+    }
+
+    const_iterator find(const index_type &index) const {
+        if (index < get_limit()) {
+            const SmallIndex small_index = static_cast<SmallIndex>(index);
+            const auto &range = ranges_[small_index];
+            if (range.valid()) {
+                return const_iterator(this, range.begin);
+            }
+        }
+        return end();
+    }
+
+    size_type size() const { return size_; }
+    bool empty() const { return 0 == size_; }
+
+    iterator erase(const_iterator pos) {
+        assert(pos.map_ == this);
+        return erase_impl(pos.get_pos());
+    }
+
+    iterator erase(iterator pos) {
+        assert(pos.map_ == this);
+        return erase_impl(pos.get_pos());
+    }
+
+    // Must be called with rvalue or lvalue of value_type
+    template <typename Value>
+    iterator emplace(Value &&value) {
+        const auto &key = value.first;
+        assert(in_bounds(key));
+        if (key.begin >= limit_) return end();  // Invalid key (end is checked in "is_open")
+        const SmallRange range(static_cast<SmallIndex>(key.begin), static_cast<SmallIndex>(key.end));
+        if (is_open(key)) {
+            // This needs to be the fast path, but I don't see how we can avoid the sanity checks above
+            for (auto i = range.begin; i < range.end; ++i) {
+                ranges_[i] = range;
+            }
+            // Update the next information for the previous unused slots (as stored in begin invalidly)
+            auto prev = range.begin;
+            while (prev > 0) {
+                --prev;
+                if (ranges_[prev].valid()) break;
+                ranges_[prev].begin = range.begin;
+            }
+            // Placement new into the storage interpreted as Value
+            construct_value(range.begin, value_type(std::forward<Value>(value)));
+            auto next = range.end;
+            // update the previous range information for the next unsed slots (as stored in end invalidly)
+            while (next < limit_) {
+                // End is exclusive... increment *after* update
+                if (ranges_[next].valid()) break;
+                ranges_[next].end = range.end;
+                ++next;
+            }
+            return iterator(this, range.begin);
+        } else {
+            // Can't insert into occupied ranges.
+            // if ranges_[key.begin] is valid then this is the collision (starting at .begin
+            // if it's invalid .begin points to the overlapping entry from is_open (or end if key was out of range)
+            return iterator(this, ranges_[range.begin].begin);
+        }
+    }
+
+    // As hint is going to be ignored, make it as lightweight as possible, by reference and no conversion construction
+    template <typename Value>
+    iterator emplace_hint([[maybe_unused]] const const_iterator &hint, Value &&value) {
+        // We have direct access so we can drop the hint
+        return emplace(std::forward<Value>(value));
+    }
+
+    template <typename Value>
+    iterator emplace_hint([[maybe_unused]] const iterator &hint, Value &&value) {
+        // We have direct access so we can drop the hint
+        return emplace(std::forward<Value>(value));
+    }
+
+    // Again, hint is going to be ignored, make it as lightweight as possible, by reference and no conversion construction
+    iterator insert([[maybe_unused]] const const_iterator &hint, const value_type &value) { return emplace(value); }
+    iterator insert([[maybe_unused]] const iterator &hint, const value_type &value) { return emplace(value); }
+
+    std::pair<iterator, bool> insert(const value_type &value) {
+        const auto &key = value.first;
+        assert(in_bounds(key));
+        if (key.begin >= limit_) return std::make_pair(end(), false);  // Invalid key, not inserted.
+        if (is_open(key)) {
+            return std::make_pair(emplace(value), true);
+        }
+        // If invalid we point to the subsequent range that collided, if valid begin is the start of the valid range
+        const auto &collision_begin = ranges_[key.begin].begin;
+        assert(ranges_[collision_begin].valid());
+        return std::make_pair(iterator(this, collision_begin), false);
+    }
+
+    template <typename SplitOp>
+    iterator split(const iterator whole_it, const index_type &index, [[maybe_unused]] const SplitOp &split_op) {
+        if (!whole_it->first.includes(index)) return whole_it;  // If we don't have a valid split point, just return the iterator
+
+        const auto &key = whole_it->first;
+        const auto small_key = make_small_range(key);
+        key_type lower_key(key.begin, index);
+        if (lower_key.empty() && SplitOp::keep_upper()) {
+            return whole_it;  // this is a noop we're keeping the upper half which is the same as whole_it;
+        }
+
+        if ((lower_key.empty() && !SplitOp::keep_upper()) || !(SplitOp::keep_lower() || SplitOp::keep_upper())) {
+            // This effectively an erase... so erase.
+            return erase(whole_it);
+        }
+
+        // Upper range cannot be empty (because the split point would be included...
+        const auto small_lower_key = make_small_range(lower_key);
+        const SmallRange small_upper_key{small_lower_key.end, small_key.end};
+        if (SplitOp::keep_upper()) {
+            // Note: create the upper section before the lower, as processing the lower may erase it
+            assert(!small_upper_key.empty());
+            const key_type upper_key{lower_key.end, key.end};
+            if (SplitOp::keep_lower()) {
+                construct_value(small_upper_key.begin, std::make_pair(upper_key, get_value(small_key.begin)->second));
+            } else {
+                // If we aren't keeping the lower, move instead of copy
+                construct_value(small_upper_key.begin, std::make_pair(upper_key, std::move(get_value(small_key.begin)->second)));
+            }
+            for (auto i = small_upper_key.begin; i < small_upper_key.end; ++i) {
+                ranges_[i] = small_upper_key;
+            }
+        } else {
+            // rewrite "end" to the next valid range (or end)
+            assert(SplitOp::keep_lower());
+            auto next = next_range(small_key.begin);
+            rerange(small_upper_key, SmallRange(next, small_lower_key.end));
+            // for any already invalid, we just rewrite the end.
+            rerange_end(small_upper_key.end, next, small_lower_key.end);
+        }
+        SmallIndex split_index;
+        if (SplitOp::keep_lower()) {
+            resize_value(small_key.begin, lower_key.end);
+            rerange_end(small_lower_key.begin, small_lower_key.end, small_lower_key.end);
+            split_index = small_lower_key.begin;
+        } else {
+            // Remove lower and rewrite empty space
+            assert(SplitOp::keep_upper());
+            destruct_value(small_key.begin);
+
+            // Rewrite prior empty space (if any)
+            auto prev = prev_range(small_key.begin);
+            SmallIndex limit = small_lower_key.end;
+            SmallIndex start = 0;
+            if (small_key.begin != 0) {
+                const auto &prev_start = ranges_[prev];
+                if (prev_start.valid()) {
+                    // If there is a previous used range, the empty space starts after it.
+                    start = prev_start.end;
+                } else {
+                    assert(prev == 0);  // prev_range only returns invalid ranges "off the front"
+                    start = prev;
+                }
+                // for the section *prior* to key begin only need to rewrite the "invalid" begin (i.e. next "in use" begin)
+                rerange_begin(start, small_lower_key.begin, limit);
+            }
+            // for the section being erased rewrite the invalid range reflecting the empty space
+            rerange(small_lower_key, SmallRange(limit, start));
+            split_index = small_lower_key.end;
+        }
+
+        return iterator(this, split_index);
+    }
+
+    // For the value.first range rewrite the range...
+    template <typename Value>
+    iterator overwrite_range(Value &&value) {
+        const auto &key = value.first;
+
+        // Small map only has a restricted range supported
+        assert(in_bounds(key));
+        if (key.end > get_limit()) {
+            return end();
+        }
+
+        const auto small_key = make_small_range(key);
+        clear_out_range(small_key, /* valid clear range */ true);
+        construct_value(small_key.begin, std::forward<Value>(value));
+        return iterator(this, small_key.begin);
+    }
+
+    // We don't need a hint...
+    template <typename Value>
+    iterator overwrite_range([[maybe_unused]] const iterator &hint, Value &&value) {
+        return overwrite_range(std::forward<Value>(value));
+    }
+
+    // For the range erase all contents within range, trimming any overlapping ranges
+    iterator erase_range(const key_type &range) {
+        // Small map only has a restricted range supported
+        assert(in_bounds(range));
+        if (range.end > get_limit() || range.empty()) {
+            return end();
+        }
+        const auto empty = clear_out_range(make_small_range(range), /* valid clear range */ false);
+        return iterator(this, empty.end);
+    }
+
+    template <typename Iterator>
+    iterator erase(const Iterator &first, const Iterator &last) {
+        assert(this == first.map_);
+        assert(this == last.map_);
+        auto first_pos = !first.at_end() ? first.pos_ : limit_;
+        auto last_pos = !last.at_end() ? last.pos_ : limit_;
+        assert(first_pos <= last_pos);
+        const SmallRange clear_me(first_pos, last_pos);
+        if (!clear_me.empty()) {
+            const SmallRange empty_range(find_empty_left(clear_me), last_pos);
+            clear_and_set_range(empty_range.begin, empty_range.end, make_invalid_range(empty_range));
+        }
+        return iterator(this, last_pos);
+    }
+
+    iterator lower_bound(const key_type &key) { return iterator(this, lower_bound_impl(this, key)); }
+    const_iterator lower_bound(const key_type &key) const { return const_iterator(this, lower_bound_impl(this, key)); }
+
+    iterator upper_bound(const key_type &key) { return iterator(this, upper_bound_impl(this, key)); }
+    const_iterator upper_bound(const key_type &key) const { return const_iterator(this, upper_bound_impl(this, key)); }
+
+    small_range_map(index_type limit = N) : size_(0), limit_(static_cast<SmallIndex>(limit)) {
+        assert(limit <= std::numeric_limits<SmallIndex>::max());
+        init_range();
+    }
+
+    // Only valid for empty maps
+    void set_limit(size_t limit) {
+        assert(size_ == 0);
+        assert(limit <= std::numeric_limits<SmallIndex>::max());
+        limit_ = static_cast<SmallIndex>(limit);
+        init_range();
+    }
+    inline index_type get_limit() const { return static_cast<index_type>(limit_); }
+
+  private:
+    inline bool in_bounds(index_type index) const { return index < get_limit(); }
+    inline bool in_bounds(const RangeKey &key) const { return key.begin < get_limit() && key.end <= get_limit(); }
+
+    inline SmallRange make_small_range(const RangeKey &key) const {
+        assert(in_bounds(key));
+        return SmallRange(static_cast<SmallIndex>(key.begin), static_cast<SmallIndex>(key.end));
+    }
+
+    inline SmallRange make_invalid_range(const SmallRange &key) const { return SmallRange(key.end, key.begin); }
+
+    bool is_open(const key_type &key) const {
+        // Remebering that invalid range.begin is the beginning the next used range.
+        const auto small_key = make_small_range(key);
+        const auto &range = ranges_[small_key.begin];
+        return range.invalid() && small_key.end <= range.begin;
+    }
+    // Only call this with a valid beginning index
+    iterator erase_impl(SmallIndex erase_index) {
+        assert(erase_index == ranges_[erase_index].begin);
+        auto &range = ranges_[erase_index];
+        destruct_value(erase_index);
+        // Need to update the ranges to accommodate the erasure
+        SmallIndex prev = 0;  // This is correct for the case erase_index is 0....
+        if (erase_index != 0) {
+            prev = prev_range(erase_index);
+            // This works if prev is valid or invalid, because the invalid end will be either 0 (and correct) or the end of the
+            // prior valid range and the valid end will be the end of the previous range (and thus correct)
+            prev = ranges_[prev].end;
+        }
+        auto next = next_range(erase_index);
+        // We have to be careful of next == limit_...
+        if (next < limit_) {
+            next = ranges_[next].begin;
+        }
+        // Rewrite both adjoining and newly empty entries
+        SmallRange infill(next, prev);
+        for (auto i = prev; i < next; ++i) {
+            ranges_[i] = infill;
+        }
+        return iterator(this, next);
+    }
+    // This implements the "range lower bound logic" directly on the ranges
+    template <typename Map>
+    static SmallIndex lower_bound_impl(Map *const that, const key_type &key) {
+        if (!that->in_bounds(key.begin)) return that->limit_;
+        // If range is invalid, then begin points to the next valid (or end) with must be the lower bound
+        // If range is valid, the begin points to a the lowest range that interects key
+        const auto lb = that->ranges_[static_cast<SmallIndex>(key.begin)].begin;
+        return lb;
+    }
+
+    template <typename Map>
+    static SmallIndex upper_bound_impl(Map *that, const key_type &key) {
+        const auto limit = that->get_limit();
+        if (key.end >= limit) return that->limit_;  //  at end
+        const auto &end_range = that->ranges_[key.end];
+        // If range is invalid, then begin points to the next valid (or end) with must be the upper bound (key < range because
+        auto ub = end_range.begin;
+        // If range is valid, the begin points to a range that may interects key, which is be upper iff range.begin == key.end
+        if (end_range.valid() && (key.end > end_range.begin)) {
+            // the ub candidate *intersects* the key, so we have to go to the next range.
+            ub = that->next_range(end_range.begin);
+        }
+        return ub;
+    }
+
+    // This is and inclusive "inuse", the entry itself
+    SmallIndex find_inuse_right(const SmallRange &range) const {
+        if (range.end >= limit_) return limit_;
+        // if range is valid, begin is the first use (== range.end), else it's the first used after the invalid range
+        return ranges_[range.end].begin;
+    }
+    // This is an exclusive "inuse", the end of the previous range
+    SmallIndex find_inuse_left(const SmallRange &range) const {
+        if (range.begin == 0) return 0;
+        // if range is valid, end is the end of the first use (== range.begin), else it's the end of the in use range before the
+        // invalid range
+        return ranges_[range.begin - 1].end;
+    }
+    SmallRange find_empty(const SmallRange &range) const { return SmallRange(find_inuse_left(range), find_inuse_right(range)); }
+
+    // Clear out the given range, trimming as needed.  The clear_range can be set as valid or invalid
+    SmallRange clear_out_range(const SmallRange &clear_range, bool valid_clear_range) {
+        // By copy to avoid reranging side affect
+        auto first_range = ranges_[clear_range.begin];
+
+        // fast path for matching ranges...
+        if (first_range == clear_range) {
+            // clobber the existing value
+            destruct_value(clear_range.begin);
+            if (valid_clear_range) {
+                return clear_range;  // This is the overwrite fastpath for matching range
+            } else {
+                const auto empty_range = find_empty(clear_range);
+                rerange(empty_range, make_invalid_range(empty_range));
+                return empty_range;
+            }
+        }
+
+        SmallRange empty_left(clear_range.begin, clear_range.begin);
+        SmallRange empty_right(clear_range.end, clear_range.end);
+
+        // The clearout is entirely within a single extant range, trim and set.
+        if (first_range.valid() && first_range.includes(clear_range)) {
+            // Shuffle around first_range, three cases...
+            if (first_range.begin < clear_range.begin) {
+                // We have a lower trimmed area to preserve.
+                resize_value(first_range.begin, clear_range.begin);
+                rerange_end(first_range.begin, clear_range.begin, clear_range.begin);
+                if (first_range.end > clear_range.end) {
+                    // And an upper portion of first that needs to copy from the lower
+                    construct_value(clear_range.end, std::make_pair(key_type(clear_range.end, first_range.end),
+                                                                    get_value(first_range.begin)->second));
+                    rerange_begin(clear_range.end, first_range.end, clear_range.end);
+                } else {
+                    assert(first_range.end == clear_range.end);
+                    empty_right.end = find_inuse_right(clear_range);
+                }
+            } else {
+                assert(first_range.end > clear_range.end);
+                assert(first_range.begin == clear_range.begin);
+                // Only an upper trimmed area to preserve, so move the first range value to the upper trim zone.
+                resize_value_right(first_range, clear_range.end);
+                rerange_begin(clear_range.end, first_range.end, clear_range.end);
+                empty_left.begin = find_inuse_left(clear_range);
+            }
+        } else {
+            if (first_range.valid()) {
+                if (first_range.begin < clear_range.begin) {
+                    // Trim left.
+                    assert(first_range.end < clear_range.end);  // we handled the "includes" case above
+                    resize_value(first_range.begin, clear_range.begin);
+                    rerange_end(first_range.begin, clear_range.begin, clear_range.begin);
+                }
+            } else {
+                empty_left.begin = find_inuse_left(clear_range);
+            }
+
+            // rewrite excluded portion of final range
+            if (clear_range.end < limit_) {
+                const auto &last_range = ranges_[clear_range.end];
+                if (last_range.valid()) {
+                    // for a valid adjoining range we don't have to change empty_right, but we may have to trim
+                    if (last_range.begin < clear_range.end) {
+                        resize_value_right(last_range, clear_range.end);
+                        rerange_begin(clear_range.end, last_range.end, clear_range.end);
+                    }
+                } else {
+                    // Note: invalid ranges "begin" and the next inuse range (or end)
+                    empty_right.end = last_range.begin;
+                }
+            }
+        }
+
+        const SmallRange empty(empty_left.begin, empty_right.end);
+        // Clear out the contents
+        for (auto i = empty.begin; i < empty.end; ++i) {
+            const auto &range = ranges_[i];
+            if (range.begin == i) {
+                assert(range.valid());
+                // Clean up the backing store
+                destruct_value(i);
+            }
+        }
+
+        // Rewrite the ranges
+        if (valid_clear_range) {
+            rerange_begin(empty_left.begin, empty_left.end, clear_range.begin);
+            rerange(clear_range, clear_range);
+            rerange_end(empty_right.begin, empty_right.end, clear_range.end);
+        } else {
+            rerange(empty, make_invalid_range(empty));
+        }
+        assert(empty.end == limit_ || ranges_[empty.end].valid());
+        assert(empty.begin == 0 || ranges_[empty.begin - 1].valid());
+        return empty;
+    }
+
+    void init_range() {
+        const SmallRange init_val(limit_, 0);
+        for (SmallIndex i = 0; i < limit_; ++i) {
+            ranges_[i] = init_val;
+            in_use_[i] = false;
+        }
+    }
+    value_type *get_value(SmallIndex index) {
+        assert(index < limit_);  // Must be inbounds
+        return reinterpret_cast<value_type *>(&(backing_store_[index]));
+    }
+    const value_type *get_value(SmallIndex index) const {
+        assert(index < limit_);                 // Must be inbounds
+        assert(index == ranges_[index].begin);  // Must be the record at begin
+        return reinterpret_cast<const value_type *>(&(backing_store_[index]));
+    }
+
+    template <typename Value>
+    void construct_value(SmallIndex index, Value &&value) {
+        assert(!in_use_[index]);
+        new (get_value(index)) value_type(std::forward<Value>(value));
+        in_use_[index] = true;
+        ++size_;
+    }
+
+    void destruct_value(SmallIndex index) {
+        // there are times when the range and destruct logic clash... allow for double attempted deletes
+        if (in_use_[index]) {
+            assert(size_ > 0);
+            --size_;
+            get_value(index)->~value_type();
+            in_use_[index] = false;
+        }
+    }
+
+    // No need to move around the value, when just the key is moving
+    // Use the destructor/placement new just in case of a complex key with range's semantics
+    // Note: Call resize before rewriting ranges_
+    void resize_value(SmallIndex current_begin, index_type new_end) {
+        // Destroy and rewrite the key in place
+        assert(ranges_[current_begin].end != new_end);
+        key_type new_key(current_begin, new_end);
+        key_type *key = const_cast<key_type *>(&get_value(current_begin)->first);
+        key->~key_type();
+        new (key) key_type(new_key);
+    }
+
+    inline void rerange_end(SmallIndex old_begin, SmallIndex new_end, SmallIndex new_end_value) {
+        for (auto i = old_begin; i < new_end; ++i) {
+            ranges_[i].end = new_end_value;
+        }
+    }
+    inline void rerange_begin(SmallIndex new_begin, SmallIndex old_end, SmallIndex new_begin_value) {
+        for (auto i = new_begin; i < old_end; ++i) {
+            ranges_[i].begin = new_begin_value;
+        }
+    }
+    inline void rerange(const SmallRange &range, const SmallRange &range_value) {
+        for (auto i = range.begin; i < range.end; ++i) {
+            ranges_[i] = range_value;
+        }
+    }
+
+    // for resize right need both begin and end...
+    void resize_value_right(const SmallRange &current_range, index_type new_begin) {
+        // Use move semantics for (potentially) heavyweight mapped_type's
+        assert(current_range.begin != new_begin);
+        // Move second from it's current location and update the first at the same time
+        construct_value(static_cast<SmallIndex>(new_begin),
+                        std::make_pair(key_type(new_begin, current_range.end), std::move(get_value(current_range.begin)->second)));
+        destruct_value(current_range.begin);
+    }
+
+    // Now we can walk a range and rewrite it cleaning up any live contents
+    void clear_and_set_range(SmallIndex rewrite_begin, SmallIndex rewrite_end, const SmallRange &new_range) {
+        for (auto i = rewrite_begin; i < rewrite_end; ++i) {
+            auto &range = ranges_[i];
+            if (i == range.begin) {
+                destruct_value(i);
+            }
+            range = new_range;
+        }
+    }
+
+    SmallIndex next_range(SmallIndex current) const {
+        SmallIndex next = ranges_[current].end;
+        // If the next range is invalid, skip to the next range, which *must* be (or be end)
+        if ((next < limit_) && ranges_[next].invalid()) {
+            // For invalid ranges, begin is the beginning of the next range
+            next = ranges_[next].begin;
+            assert(next == limit_ || ranges_[next].valid());
+        }
+        return next;
+    }
+
+    SmallIndex prev_range(SmallIndex current) const {
+        if (current == 0) {
+            return 0;
+        }
+
+        auto prev = current - 1;
+        if (ranges_[prev].valid()) {
+            // For valid ranges, the range denoted by begin (as that's where the backing store keeps values
+            prev = ranges_[prev].begin;
+        } else if (prev != 0) {
+            // Invalid but not off the front, we can recur (only once) from the end of the prev range to get the answer
+            // For invalid ranges this is the end of the previous range
+            prev = prev_range(ranges_[prev].end);
+        }
+        return prev;
+    }
+
+    friend iterator;
+    friend const_iterator;
+    // Stores range boundaries only
+    //     open ranges, stored as inverted, invalid range (begining of next, end of prev]
+    //     inuse(begin, end) for all entries  on (begin, end]
+    // Used for placement new of T for each range begin.
+    struct alignas(alignof(value_type)) BackingStore {
+        uint8_t data[sizeof(value_type)];
+    };
+
+    SmallIndex size_;
+    SmallIndex limit_;
+    std::array<SmallRange, N> ranges_;
+    std::array<BackingStore, N> backing_store_;
+    std::array<bool, N> in_use_;
+};
+
+// Forward index iterator, tracking an index value and the appropos lower bound
+// returns an index_type, lower_bound pair.  Supports ++,  offset, and seek affecting the index,
+// lower bound updates as needed. As the index may specify a range for which no entry exist, dereferenced
+// iterator includes an "valid" field, true IFF the lower_bound is not end() and contains [index, index +1)
+//
+// Must be explicitly invalidated when the underlying map is changed.
+template <typename Map>
+class cached_lower_bound_impl {
+    using plain_map_type = typename std::remove_const<Map>::type;  // Allow instatiation with const or non-const Map
+  public:
+    using iterator = const_correct_iterator<Map>;
+    using key_type = typename plain_map_type::key_type;
+    using mapped_type = typename plain_map_type::mapped_type;
+    // Both sides of the return pair are const'd because we're returning references/pointers to the *internal* state
+    // and we don't want and caller altering internal state.
+    using index_type = typename Map::index_type;
+    struct value_type {
+        const index_type &index;
+        const iterator &lower_bound;
+        const bool &valid;
+        value_type(const index_type &index_, const iterator &lower_bound_, bool &valid_)
+            : index(index_), lower_bound(lower_bound_), valid(valid_) {}
+    };
+
+  private:
+    Map *const map_;
+    const iterator end_;
+    value_type pos_;
+
+    index_type index_;
+    iterator lower_bound_;
+    bool valid_;
+
+    bool is_valid() const { return includes(index_); }
+
+    // Allow reuse of a type with const semantics
+    void set_value(const index_type &index, const iterator &it) {
+        assert(it == lower_bound(index));
+        index_ = index;
+        lower_bound_ = it;
+        valid_ = is_valid();
+    }
+
+    void update(const index_type &index) {
+        assert(lower_bound_ == lower_bound(index));
+        index_ = index;
+        valid_ = is_valid();
+    }
+
+    inline iterator lower_bound(const index_type &index) { return map_->lower_bound(key_type(index, index + 1)); }
+    inline bool at_end(const iterator &it) const { return it == end_; }
+
+    bool is_lower_than(const index_type &index, const iterator &it) { return at_end(it) || (index < it->first.end); }
+
+  public:
+    // The cached lower bound knows the parent map, and thus can tell us this...
+    inline bool at_end() const { return at_end(lower_bound_); }
+    // includes(index) is a convenience function to test if the index would be in the currently cached lower bound
+    bool includes(const index_type &index) const { return !at_end() && lower_bound_->first.includes(index); }
+
+    // The return is const because we are sharing the internal state directly.
+    const value_type &operator*() const { return pos_; }
+    const value_type *operator->() const { return &pos_; }
+
+    // Advance the cached location by 1
+    cached_lower_bound_impl &operator++() {
+        const index_type next = index_ + 1;
+        if (is_lower_than(next, lower_bound_)) {
+            update(next);
+        } else {
+            // if we're past pos_->second, next *must* be the new lower bound.
+            // NOTE: that next can't be past end, so lower_bound_ isn't end.
+            auto next_it = lower_bound_;
+            ++next_it;
+            set_value(next, next_it);
+
+            // However we *must* not be past next.
+            assert(is_lower_than(next, next_it));
+        }
+
+        return *this;
+    }
+
+    // seek(index) updates lower_bound for index, updating lower_bound_ as needed.
+    cached_lower_bound_impl &seek(const index_type &seek_to) {
+        // Optimize seeking to  forward
+        if (index_ == seek_to) {
+            // seek to self is a NOOP.  To reset lower bound after a map change, use invalidate
+        } else if (index_ < seek_to) {
+            // See if the current or next ranges are the appropriate lower_bound... should be a common use case
+            if (is_lower_than(seek_to, lower_bound_)) {
+                // lower_bound_ is still the correct lower bound
+                update(seek_to);
+            } else {
+                // Look to see if the next range is the new lower_bound (and we aren't at end)
+                auto next_it = lower_bound_;
+                ++next_it;
+                if (is_lower_than(seek_to, next_it)) {
+                    // next_it is the correct new lower bound
+                    set_value(seek_to, next_it);
+                } else {
+                    // We don't know where we are...  and we aren't going to walk the tree looking for seek_to.
+                    set_value(seek_to, lower_bound(seek_to));
+                }
+            }
+        } else {
+            // General case... this is += so we're not implmenting optimized negative offset logic
+            set_value(seek_to, lower_bound(seek_to));
+        }
+        return *this;
+    }
+
+    // Advance the cached location by offset.
+    cached_lower_bound_impl &offset(const index_type &offset) {
+        const index_type next = index_ + offset;
+        return seek(next);
+    }
+
+    // invalidate() resets the the lower_bound_ cache, needed after insert/erase/overwrite/split operations
+    // Pass index by value in case we are invalidating to index_ and set_value does a modify-in-place on index_
+    cached_lower_bound_impl &invalidate(index_type index) {
+        set_value(index, lower_bound(index));
+        return *this;
+    }
+
+    // For times when the application knows what it's done to the underlying map... (with assert in set_value)
+    cached_lower_bound_impl &invalidate(const iterator &hint, index_type index) {
+        set_value(index, hint);
+        return *this;
+    }
+
+    cached_lower_bound_impl &invalidate() { return invalidate(index_); }
+
+    // Allow a hint for a *valid* lower bound for current index
+    // TODO: if the fail-over becomes a hot-spot, the hint logic could be far more clever (looking at previous/next...)
+    cached_lower_bound_impl &invalidate(const iterator &hint) {
+        if ((hint != end_) && hint->first.includes(index_)) {
+            auto index = index_;  // by copy set modifies in place
+            set_value(index, hint);
+        } else {
+            invalidate();
+        }
+        return *this;
+    }
+
+    // The offset in index type to the next change (the end of the current range, or the transition from invalid to
+    // valid.  If invalid and at_end, returns index_type(0)
+    index_type distance_to_edge() {
+        if (valid_) {
+            // Distance to edge of
+            return lower_bound_->first.end - index_;
+        } else if (at_end()) {
+            return index_type(0);
+        } else {
+            return lower_bound_->first.begin - index_;
+        }
+    }
+
+    Map &map() { return *map_; }
+    const Map &map() const { return *map_; }
+
+    // Default constructed object reports valid (correctly) as false, but otherwise will fail (assert) under nearly any use.
+    cached_lower_bound_impl()
+        : map_(nullptr), end_(), pos_(index_, lower_bound_, valid_), index_(0), lower_bound_(), valid_(false) {}
+    cached_lower_bound_impl(Map &map, const index_type &index)
+        : map_(&map),
+          end_(map.end()),
+          pos_(index_, lower_bound_, valid_),
+          index_(index),
+          lower_bound_(lower_bound(index)),
+          valid_(is_valid()) {}
+};
+
+template <typename CachedLowerBound, typename MappedType = typename CachedLowerBound::mapped_type>
+const MappedType &evaluate(const CachedLowerBound &clb, const MappedType &default_value) {
+    if (clb->valid) {
+        return clb->lower_bound->second;
+    }
+    return default_value;
+}
+
+// Split a range into pieces bound by the intersection of the iterator's range and the supplied range
+template <typename Iterator, typename Map, typename Range>
+Iterator split(Iterator in, Map &map, const Range &range) {
+    assert(in != map.end());  // Not designed for use with invalid iterators...
+    const auto in_range = in->first;
+    const auto split_range = in_range & range;
+
+    if (split_range.empty()) return map.end();
+
+    auto pos = in;
+    if (split_range.begin != in_range.begin) {
+        pos = map.split(pos, split_range.begin, split_op_keep_both());
+        ++pos;
+    }
+    if (split_range.end != in_range.end) {
+        pos = map.split(pos, split_range.end, split_op_keep_both());
+    }
+    return pos;
+}
+
+// Apply an operation over a range map, infilling where content is absent, updating where content is present.
+// The passed pos must *either* be strictly less than range or *is* lower_bound (which may be end)
+// Trims to range boundaries.
+// infill op doesn't have to alter map, but mustn't invalidate iterators passed to it. (i.e. no erasure)
+// infill data (default mapped value or other initial value) is contained with ops.
+// update allows existing ranges to be updated (merged, whatever) based on data contained in ops.  All iterators
+// passed to update are already trimmed to fit within range.
+template <typename RangeMap, typename InfillUpdateOps, typename Iterator = typename RangeMap::iterator>
+Iterator infill_update_range(RangeMap &map, Iterator pos, const typename RangeMap::key_type &range, const InfillUpdateOps &ops) {
+    using KeyType = typename RangeMap::key_type;
+    using IndexType = typename RangeMap::index_type;
+
+    const auto end = map.end();
+    assert((pos == end) || (pos == map.lower_bound(range)) || pos->first.strictly_less(range));
+
+    if (range.empty()) return pos;
+    if (pos == end) {
+        // Only pass pos == end for range tail after last entry
+        assert(end == map.lower_bound(range));
+    } else if (pos->first.strictly_less(range)) {
+        // pos isn't lower_bound for range (it's less than range), however, if range is monotonically increasing it's likely
+        // the next entry in the map will be the lower bound.
+
+        // If the new (pos + 1) *isn't* stricly_less and pos is,
+        // (pos + 1) must be the lower_bound, otherwise we have to look for it O(log n)
+        ++pos;
+        if ((pos != end) && pos->first.strictly_less(range)) {
+            pos = map.lower_bound(range);
+        }
+        assert(pos == map.lower_bound(range));
+    }
+
+    if ((pos != end) && (range.begin > pos->first.begin)) {
+        // lower bound starts before the range, trim and advance
+        pos = map.split(pos, range.begin, split_op_keep_both());
+        ++pos;
+    }
+
+    IndexType current_begin = range.begin;
+    while ((pos != end) && (current_begin < range.end)) {
+        // The current_begin is either pointing to the next existing value to update or the beginning of a gap to infill
+        assert(pos->first.begin >= current_begin);
+
+        if (current_begin < pos->first.begin) {
+            // We have a gap to infill (we supply pos for ("insert in front of" calls)
+            ops.infill(map, pos, KeyType(current_begin, std::min(range.end, pos->first.begin)));
+            // Advance current begin, but *not* pos as it's the next valid value. (infill shall not invalidate pos)
+            current_begin = pos->first.begin;
+        } else {
+            // We need to run the update operation on the valid portion of the current value
+            if (pos->first.end > range.end) {
+                // If this entry overlaps end-of-range we need to trim it to the range
+                pos = map.split(pos, range.end, split_op_keep_both());
+            }
+
+            // We have a valid fully contained range, merge with it
+            ops.update(pos);
+
+            // Advance the current location and map entry
+            current_begin = pos->first.end;
+            ++pos;
+        }
+    }
+
+    // Fill to the end as needed
+    if (current_begin < range.end) {
+        ops.infill(map, pos, KeyType(current_begin, range.end));
+    }
+
+    return pos;
+}
+
+template <typename RangeMap, typename InfillUpdateOps>
+void infill_update_range(RangeMap &map, const typename RangeMap::key_type &range, const InfillUpdateOps &ops) {
+    if (range.empty()) return;
+    auto pos = map.lower_bound(range);
+    infill_update_range(map, pos, range, ops);
+}
+
+template <typename RangeMap, typename RangeGen, typename InfillUpdateOps>
+void infill_update_rangegen(RangeMap &map, RangeGen &range_gen, const InfillUpdateOps &ops) {
+    auto pos = map.lower_bound(*range_gen);
+    for (; range_gen->non_empty(); ++range_gen) {
+        pos = infill_update_range(map, pos, *range_gen, ops);
+    }
+}
+
+// Parallel iterator
+// Traverse to range maps over the the same range, but without assumptions of aligned ranges.
+// ++ increments to the next point where on of the two maps changes range, giving a range over which the two
+// maps do not transition ranges
+template <typename MapA, typename MapB = MapA, typename KeyType = typename MapA::key_type>
+class parallel_iterator {
+  public:
+    using key_type = KeyType;
+    using index_type = typename key_type::index_type;
+
+    // The traits keep the iterator/const_interator consistent with the constness of the map.
+    using map_type_A = MapA;
+    using plain_map_type_A = typename std::remove_const<MapA>::type;  // Allow instatiation with const or non-const Map
+    using key_type_A = typename plain_map_type_A::key_type;
+    using index_type_A = typename plain_map_type_A::index_type;
+    using iterator_A = const_correct_iterator<map_type_A>;
+    using lower_bound_A = cached_lower_bound_impl<map_type_A>;
+
+    using map_type_B = MapB;
+    using plain_map_type_B = typename std::remove_const<MapB>::type;
+    using key_type_B = typename plain_map_type_B::key_type;
+    using index_type_B = typename plain_map_type_B::index_type;
+    using iterator_B = const_correct_iterator<map_type_B>;
+    using lower_bound_B = cached_lower_bound_impl<map_type_B>;
+
+    // This is the value we'll always be returning, but the referenced object will be updated by the operations
+    struct value_type {
+        const key_type &range;
+        const lower_bound_A &pos_A;
+        const lower_bound_B &pos_B;
+        value_type(const key_type &range_, const lower_bound_A &pos_A_, const lower_bound_B &pos_B_)
+            : range(range_), pos_A(pos_A_), pos_B(pos_B_) {}
+    };
+
+  private:
+    lower_bound_A pos_A_;
+    lower_bound_B pos_B_;
+    key_type range_;
+    value_type pos_;
+    index_type compute_delta() {
+        auto delta_A = pos_A_.distance_to_edge();
+        auto delta_B = pos_B_.distance_to_edge();
+        index_type delta_min;
+
+        // If either A or B are at end, there distance is *0*, so shouldn't be considered in the "distance to edge"
+        if (delta_A == 0) {  // lower A is at end
+            delta_min = static_cast<index_type>(delta_B);
+        } else if (delta_B == 0) {  // lower B is at end
+            delta_min = static_cast<index_type>(delta_A);
+        } else {
+            // Neither are at end, use the nearest edge, s.t. over this range A and B are both constant
+            delta_min = std::min(static_cast<index_type>(delta_A), static_cast<index_type>(delta_B));
+        }
+        return delta_min;
+    }
+
+  public:
+    // Default constructed object will report range empty (for end checks), but otherwise is unsafe to use
+    parallel_iterator() : pos_A_(), pos_B_(), range_(), pos_(range_, pos_A_, pos_B_) {}
+    parallel_iterator(map_type_A &map_A, map_type_B &map_B, index_type index)
+        : pos_A_(map_A, static_cast<index_type_A>(index)),
+          pos_B_(map_B, static_cast<index_type_B>(index)),
+          range_(index, index + compute_delta()),
+          pos_(range_, pos_A_, pos_B_) {}
+
+    // Advance to the next spot one of the two maps changes
+    parallel_iterator &operator++() {
+        const auto start = range_.end;         // we computed this the last time we set range
+        const auto delta = range_.distance();  // we computed this the last time we set range
+        assert(delta != 0);                    // Trying to increment past end
+
+        pos_A_.offset(static_cast<index_type_A>(delta));
+        pos_B_.offset(static_cast<index_type_B>(delta));
+
+        range_ = key_type(start, start + compute_delta());  // find the next boundary (must be after offset)
+        assert(pos_A_->index == start);
+        assert(pos_B_->index == start);
+
+        return *this;
+    }
+
+    // Seeks to a specific index in both maps reseting range.  Cannot guarantee range.begin is on edge boundary,
+    /// but range.end will be.  Lower bound objects assumed to invalidate their cached lower bounds on seek.
+    parallel_iterator &seek(const index_type &index) {
+        pos_A_.seek(static_cast<index_type_A>(index));
+        pos_B_.seek(static_cast<index_type_B>(index));
+        range_ = key_type(index, index + compute_delta());
+        assert(pos_A_->index == index);
+        assert(pos_A_->index == pos_B_->index);
+        return *this;
+    }
+
+    // Invalidates the lower_bound caches, reseting range.  Cannot guarantee range.begin is on edge boundary,
+    // but range.end will be.
+    parallel_iterator &invalidate() {
+        const index_type start = range_.begin;
+        seek(start);
+        return *this;
+    }
+
+    parallel_iterator &invalidate_A() {
+        const index_type index = range_.begin;
+        pos_A_.invalidate(static_cast<index_type_A>(index));
+        range_ = key_type(index, index + compute_delta());
+        return *this;
+    }
+
+    parallel_iterator &invalidate_A(const iterator_A &hint) {
+        const index_type index = range_.begin;
+        pos_A_.invalidate(hint, static_cast<index_type_A>(index));
+        range_ = key_type(index, index + compute_delta());
+        return *this;
+    }
+
+    parallel_iterator &invalidate_B() {
+        const index_type index = range_.begin;
+        pos_B_.invalidate(static_cast<index_type_B>(index));
+        range_ = key_type(index, index + compute_delta());
+        return *this;
+    }
+
+    parallel_iterator &invalidate_B(const iterator_B &hint) {
+        const index_type index = range_.begin;
+        pos_B_.invalidate(hint, static_cast<index_type_B>(index));
+        range_ = key_type(index, index + compute_delta());
+        return *this;
+    }
+
+    parallel_iterator &trim_A() {
+        if (pos_A_->valid && (range_ != pos_A_->lower_bound->first)) {
+            split(pos_A_->lower_bound, pos_A_.map(), range_);
+            invalidate_A();
+        }
+        return *this;
+    }
+
+    // The return is const because we are sharing the internal state directly.
+    const value_type &operator*() const { return pos_; }
+    const value_type *operator->() const { return &pos_; }
+};
+
+template <typename DstRangeMap, typename SrcRangeMap, typename Updater,
+          typename SourceIterator = typename SrcRangeMap::const_iterator>
+bool splice(DstRangeMap &to, const SrcRangeMap &from, SourceIterator begin, SourceIterator end, const Updater &updater) {
+    if (from.empty() || (begin == end) || (begin == from.cend())) return false;  // nothing to merge.
+
+    using ParallelIterator = parallel_iterator<DstRangeMap, const SrcRangeMap>;
+    using Key = typename SrcRangeMap::key_type;
+    using CachedLowerBound = cached_lower_bound_impl<DstRangeMap>;
+    using ConstCachedLowerBound = cached_lower_bound_impl<const SrcRangeMap>;
+    ParallelIterator par_it(to, from, begin->first.begin);
+    bool updated = false;
+    while (par_it->range.non_empty() && par_it->pos_B->lower_bound != end) {
+        const Key &range = par_it->range;
+        const CachedLowerBound &to_lb = par_it->pos_A;
+        const ConstCachedLowerBound &from_lb = par_it->pos_B;
+        if (from_lb->valid) {
+            auto read_it = from_lb->lower_bound;
+            auto write_it = to_lb->lower_bound;
+            // Because of how the parallel iterator walk, "to" is valid over the whole range or it isn't (ranges don't span
+            // transitions between map entries or between valid and invalid ranges)
+            if (to_lb->valid) {
+                if (write_it->first == range) {
+                    // if the source and destination ranges match we can overwrite everything
+                    updated |= updater.update(write_it->second, read_it->second);
+                } else {
+                    // otherwise we need to split the destination range.
+                    auto value_to_update = write_it->second;  // intentional copy
+                    updated |= updater.update(value_to_update, read_it->second);
+                    auto intersected_range = write_it->first & range;
+                    to.overwrite_range(to_lb->lower_bound, std::make_pair(intersected_range, value_to_update));
+                    par_it.invalidate_A();  // we've changed map 'to' behind to_lb's back... let it know.
+                }
+            } else {
+                // Insert into the gap.
+                auto opt = updater.insert(read_it->second);
+                if (opt) {
+                    to.insert(write_it, std::make_pair(range, std::move(*opt)));
+                    updated = true;
+                    par_it.invalidate_A();  // we've changed map 'to' behind to_lb's back... let it know.
+                }
+            }
+        }
+        ++par_it;  // next range over which both 'to' and 'from' stay constant
+    }
+    return updated;
+}
+// And short hand for "from begin to end"
+template <typename DstRangeMap, typename SrcRangeMap, typename Updater>
+bool splice(DstRangeMap &to, const SrcRangeMap &from, const Updater &updater) {
+    return splice(to, from, from.cbegin(), from.cend(), updater);
+}
+
+template <typename T>
+struct update_prefer_source {
+    bool update(T &dst, const T &src) const {
+        if (dst != src) {
+            dst = src;
+            return true;
+        }
+        return false;
+    }
+
+    std::optional<T> insert(const T &src) const { return std::optional<T>(std::in_place, src); }
+};
+
+template <typename T>
+struct update_prefer_dest {
+    bool update([[maybe_unused]] T &dst, [[maybe_unused]] const T &src) const { return false; }
+
+    std::optional<T> insert(const T &src) const { return std::optional<T>(std::in_place, src); }
+};
+
+template <typename RangeMap, typename SourceIterator = typename RangeMap::const_iterator>
+bool splice(RangeMap &to, const RangeMap &from, value_precedence arbiter, [[maybe_unused]] SourceIterator begin,
+            [[maybe_unused]] SourceIterator end) {
+    if (arbiter == value_precedence::prefer_source) {
+        return splice(to, from, from.cbegin(), from.cend(), update_prefer_source<typename RangeMap::mapped_type>());
+    } else {
+        return splice(to, from, from.cbegin(), from.cend(), update_prefer_dest<typename RangeMap::mapped_type>());
+    }
+}
+
+// And short hand for "from begin to end"
+template <typename RangeMap>
+bool splice(RangeMap &to, const RangeMap &from, value_precedence arbiter) {
+    return splice(to, from, arbiter, from.cbegin(), from.cend());
+}
+
+template <typename Map, typename Range = typename Map::key_type, typename MapValue = typename Map::mapped_type>
+bool update_range_value(Map &map, const Range &range, MapValue &&value, value_precedence precedence) {
+    using CachedLowerBound = typename vku::sparse::cached_lower_bound_impl<Map>;
+    CachedLowerBound pos(map, range.begin);
+
+    bool updated = false;
+    while (range.includes(pos->index)) {
+        if (!pos->valid) {
+            if (precedence == value_precedence::prefer_source) {
+                // We can convert this into and overwrite...
+                map.overwrite_range(pos->lower_bound, std::make_pair(range, std::forward<MapValue>(value)));
+                return true;
+            }
+            // Fill in the leading space (or in the case of pos at end the trailing space
+            const auto start = pos->index;
+            auto it = pos->lower_bound;
+            const auto limit = (it != map.end()) ? std::min(it->first.begin, range.end) : range.end;
+            map.insert(it, std::make_pair(Range(start, limit), value));
+            // We inserted before pos->lower_bound, so pos->lower_bound isn't invalid, but the associated index *is* and seek
+            // will fix this (and move the state to valid)
+            pos.seek(limit);
+            updated = true;
+        }
+        // Note that after the "fill" operation pos may have become valid so we check again
+        if (pos->valid) {
+            if ((precedence == value_precedence::prefer_source) && (pos->lower_bound->second != value)) {
+                // We've found a place where we're changing the value, at this point might as well simply over write the range
+                // and be done with it. (save on later merge operations....)
+                pos.seek(range.begin);
+                map.overwrite_range(pos->lower_bound, std::make_pair(range, std::forward<MapValue>(value)));
+                return true;
+
+            } else {
+                // "prefer_dest" means don't overwrite existing values, so we'll skip this interval.
+                // Point just past the end of this section,  if it's within the given range, it will get filled next iteration
+                // ++pos could move us past the end of range (which would exit the loop) so we don't use it.
+                pos.seek(pos->lower_bound->first.end);
+            }
+        }
+    }
+    return updated;
+}
+
+//  combines directly adjacent ranges with equal RangeMap::mapped_type .
+template <typename RangeMap>
+void consolidate(RangeMap &map) {
+    using Value = typename RangeMap::value_type;
+    using Key = typename RangeMap::key_type;
+    using It = typename RangeMap::iterator;
+
+    It current = map.begin();
+    const It map_end = map.end();
+
+    // To be included in a merge range there must be no gap in the Key space, and the mapped_type values must match
+    auto can_merge = [](const It &last, const It &cur) {
+        return cur->first.begin == last->first.end && cur->second == last->second;
+    };
+
+    while (current != map_end) {
+        // Establish a trival merge range at the current location, advancing current. Merge range is inclusive of merge_last
+        const It merge_first = current;
+        It merge_last = current;
+        ++current;
+
+        // Expand the merge range as much as possible
+        while (current != map_end && can_merge(merge_last, current)) {
+            merge_last = current;
+            ++current;
+        }
+
+        // Current isn't in the active merge range. If there is a non-trivial merge range, we resolve it here.
+        if (merge_first != merge_last) {
+            // IFF there is more than one range in (merge_first, merge_last)  <- again noting the *inclusive* last
+            // Create a new Val spanning (first, last), substitute it for the multiple entries.
+            Value merged_value = std::make_pair(Key(merge_first->first.begin, merge_last->first.end), merge_last->second);
+            // Note that current points to merge_last + 1, and is valid even if at map_end for these operations
+            map.erase(merge_first, current);
+            map.insert(current, std::move(merged_value));
+        }
+    }
+}
+
+// Returns the intersection of the ranges [x, x + x_size) and [y, y + y_size)
+static inline range<int64_t> GetRangeIntersection(int64_t x, uint64_t x_size, int64_t y, uint64_t y_size) {
+    int64_t intersection_min = std::max(x, y);
+    int64_t intersection_max = std::min(x + static_cast<int64_t>(x_size), y + static_cast<int64_t>(y_size));
+
+    return {intersection_min, intersection_max};
+}
+
+}  // namespace sparse
+}  // namespace vku
diff --git a/scripts/gn/stub.cpp b/scripts/gn/stub.cpp
index a9c729d..9cac331 100644
--- a/scripts/gn/stub.cpp
+++ b/scripts/gn/stub.cpp
@@ -11,7 +11,9 @@
 #include <vulkan/utility/vk_dispatch_table.h>
 #include <vulkan/utility/vk_concurrent_unordered_map.hpp>
 #include <vulkan/utility/vk_format_utils.h>
-#include <vulkan/utility/vk_struct_helper.hpp>
 #include <vulkan/utility/vk_safe_struct.hpp>
 #include <vulkan/utility/vk_safe_struct_utils.hpp>
+#include <vulkan/utility/vk_small_containers.hpp>
+#include <vulkan/utility/vk_sparse_range_map.hpp>
+#include <vulkan/utility/vk_struct_helper.hpp>
 #include <vulkan/vk_enum_string_helper.h>
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 12b40df..b2ab765 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -1,6 +1,6 @@
-# Copyright 2023 The Khronos Group Inc.
-# Copyright 2023 Valve Corporation
-# Copyright 2023 LunarG, Inc.
+# Copyright 2023-2024 The Khronos Group Inc.
+# Copyright 2023-2024 Valve Corporation
+# Copyright 2023-2024 LunarG, Inc.
 #
 # SPDX-License-Identifier: Apache-2.0
 
@@ -17,6 +17,8 @@ target_include_directories(vul_tests PRIVATE
 
 target_sources(vul_tests PRIVATE
     safe_struct.cpp
+    small_containers.cpp
+    sparse_range_map.cpp
     struct_helper.cpp
     test_formats.cpp
     test_interface.cpp
diff --git a/tests/small_containers.cpp b/tests/small_containers.cpp
new file mode 100644
index 0000000..c9ea873
--- /dev/null
+++ b/tests/small_containers.cpp
@@ -0,0 +1,415 @@
+// Copyright 2024 The Khronos Group Inc.
+// Copyright 2024 Valve Corporation
+// Copyright 2024 LunarG, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <gtest/gtest.h>
+#include <array>
+#include <limits>
+#include <vector>
+#include <vulkan/utility/vk_small_containers.hpp>
+
+template <typename T, typename U>
+bool HaveSameElementsUpTo(const T& l1, const U& l2, size_t n) {
+    for (size_t i = 0; i < n; ++i) {
+        if (l1[static_cast<typename T::size_type>(i)] != l2[static_cast<typename U::size_type>(i)]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+template <typename T, typename U>
+bool HaveSameElements(const T& l1, const U& l2) {
+    return static_cast<size_t>(l1.size()) == static_cast<size_t>(l2.size()) && HaveSameElementsUpTo(l1, l2, l1.size());
+}
+
+TEST(small_vector, int_resize) {
+    // Resize int small vector, moving to small store
+    // ---
+    {
+        // resize to current size
+        vku::small::vector<int, 2, size_t> v1 = {1, 2, 3, 4};
+        v1.resize(v1.size());
+        std::array<int, 4> ref = {1, 2, 3, 4};
+        ASSERT_TRUE(HaveSameElements(v1, ref));
+    }
+
+    {
+        // growing resize
+        vku::small::vector<int, 2, size_t> v2 = {1, 2, 3, 4};
+        v2.resize(5);
+        std::array<int, 5> ref = {1, 2, 3, 4, 0};
+        ASSERT_TRUE(HaveSameElements(v2, ref));
+    }
+
+    {
+        // shrinking resize
+        vku::small::vector<int, 2, size_t> v3 = {1, 2, 3, 4};
+        const auto v3_cap = v3.capacity();
+        v3.resize(3);
+        ASSERT_TRUE(v3.capacity() == v3_cap);  // Resize doesn't shrink capacity
+        v3.shrink_to_fit();
+        ASSERT_TRUE(v3.capacity() == v3.size());
+        std::array<int, 3> ref = {1, 2, 3};
+        ASSERT_TRUE(HaveSameElements(v3, ref));
+    }
+
+    {
+        // shrink to 0
+        vku::small::vector<int, 2, size_t> v4 = {1, 2, 3, 4};
+        v4.resize(0);
+        ASSERT_TRUE(v4.capacity() == 4);  // Resize doesn't shrink capacity
+        v4.shrink_to_fit();
+        ASSERT_TRUE(v4.capacity() == 2);  // Small capacity is in the minimal
+        std::array<int, 0> ref = {};
+        ASSERT_TRUE(HaveSameElements(v4, ref));
+    }
+
+    {
+        // resize to size limit
+        vku::small::vector<int, 2, uint8_t> v5 = {1, 2, 3, 4};
+        v5.resize(std::numeric_limits<uint8_t>::max());
+        std::vector<int> vec = {1, 2, 3, 4};
+        vec.resize(std::numeric_limits<uint8_t>::max());
+        ASSERT_TRUE(HaveSameElements(v5, vec));
+    }
+
+    // Resize int small vector, not moving to small store
+    // ---
+    {
+        // resize to current size
+        vku::small::vector<int, 2, size_t> v6 = {1, 2, 3, 4};
+        v6.resize(v6.size());
+        std::array<int, 4> ref = {1, 2, 3, 4};
+        ASSERT_TRUE(HaveSameElements(v6, ref));
+    }
+
+    {
+        // growing resize
+        vku::small::vector<int, 2, size_t> v7 = {1, 2, 3, 4};
+        v7.resize(5);
+        std::array<int, 5> ref = {1, 2, 3, 4, 0};
+        ASSERT_TRUE(HaveSameElements(v7, ref));
+    }
+
+    {
+        // shrinking resize
+        vku::small::vector<int, 2, size_t> v8 = {1, 2, 3, 4};
+        v8.resize(3);
+        std::array<int, 3> ref = {1, 2, 3};
+        ASSERT_TRUE(HaveSameElements(v8, ref));
+    }
+
+    {
+        // shrink to 0
+        vku::small::vector<int, 2, size_t> v9 = {1, 2, 3, 4};
+        v9.resize(0);
+        std::array<int, 0> ref = {};
+        ASSERT_TRUE(HaveSameElements(v9, ref));
+    }
+
+    {
+        // resize to size limit
+        vku::small::vector<int, 2, uint8_t> v10 = {1, 2, 3, 4};
+        v10.resize(std::numeric_limits<uint8_t>::max());
+        std::vector<int> vec = {1, 2, 3, 4};
+        vec.resize(std::numeric_limits<uint8_t>::max());
+        ASSERT_TRUE(HaveSameElements(v10, vec));
+    }
+}
+
+struct NoDefaultCons {
+    NoDefaultCons(int x) : x(x) {}
+    int x;
+};
+
+bool operator!=(const NoDefaultCons& lhs, const NoDefaultCons& rhs) { return lhs.x != rhs.x; }
+
+TEST(small_vector, not_default_insertable) {
+    // Resize NoDefault small vector, moving to small store
+    // ---
+    {
+        // resize to current size
+        vku::small::vector<NoDefaultCons, 2, size_t> v1 = {1, 2, 3, 4};
+        v1.resize(v1.size());
+        std::vector<NoDefaultCons> ref = {1, 2, 3, 4};
+        ASSERT_TRUE(HaveSameElements(v1, ref));
+    }
+
+    {
+        // growing resize
+        vku::small::vector<NoDefaultCons, 2, size_t> v2 = {1, 2, 3, 4};
+        v2.resize(5);
+        std::vector<NoDefaultCons> ref = {1, 2, 3, 4};
+        ASSERT_TRUE(HaveSameElementsUpTo(v2, ref, ref.size()));
+    }
+
+    {
+        // shrinking resize
+        vku::small::vector<NoDefaultCons, 2, size_t> v3 = {1, 2, 3, 4};
+        const auto v3_cap = v3.capacity();
+        v3.resize(3);
+        ASSERT_TRUE(v3.capacity() == v3_cap);  // Resize doesn't shrink capacity
+        v3.shrink_to_fit();
+        ASSERT_TRUE(v3.capacity() == v3.size());
+
+        std::vector<NoDefaultCons> ref = {1, 2, 3};
+        ASSERT_TRUE(HaveSameElements(v3, ref));
+    }
+
+    {
+        // shrink to 0
+        vku::small::vector<NoDefaultCons, 2, size_t> v4 = {1, 2, 3, 4};
+        v4.resize(0);
+        ASSERT_TRUE(v4.capacity() == 4);  // Resize doesn't shrink capacity
+        v4.shrink_to_fit();
+        ASSERT_TRUE(v4.capacity() == 2);  // Small capacity is in the minimal
+        std::vector<NoDefaultCons> ref = {};
+        ASSERT_TRUE(HaveSameElements(v4, ref));
+    }
+
+    // Resize NoDefault small vector, not moving to small store
+    // ---
+    {
+        // resize to current size
+        vku::small::vector<NoDefaultCons, 2, size_t> v6 = {1, 2, 3, 4};
+        v6.resize(v6.size());
+        std::vector<NoDefaultCons> ref = {1, 2, 3, 4};
+        ASSERT_TRUE(HaveSameElements(v6, ref));
+    }
+
+    {
+        // growing resize
+        vku::small::vector<NoDefaultCons, 2, size_t> v7 = {1, 2, 3, 4};
+        v7.resize(5);
+        std::vector<NoDefaultCons> ref = {1, 2, 3, 4};
+        ASSERT_TRUE(HaveSameElementsUpTo(v7, ref, ref.size()));
+    }
+
+    {
+        // shrinking resize
+        vku::small::vector<NoDefaultCons, 2, size_t> v8 = {1, 2, 3, 4};
+        v8.resize(3);
+        std::vector<NoDefaultCons> ref = {1, 2, 3};
+        ASSERT_TRUE(HaveSameElements(v8, ref));
+    }
+
+    {
+        // shrink to 0
+        vku::small::vector<NoDefaultCons, 2, size_t> v9 = {1, 2, 3, 4};
+        v9.resize(0);
+        std::vector<NoDefaultCons> ref = {};
+        ASSERT_TRUE(HaveSameElements(v9, ref));
+    }
+}
+
+TEST(small_vector, not_default_insertable_default_value) {
+    // Resize NoDefault small vector, moving to small store
+    // ---
+    {
+        // resize to current size
+        vku::small::vector<NoDefaultCons, 2, size_t> v1 = {1, 2, 3, 4};
+        v1.resize(v1.size(), NoDefaultCons(0));
+        std::vector<NoDefaultCons> ref = {1, 2, 3, 4};
+        ASSERT_TRUE(HaveSameElements(v1, ref));
+    }
+
+    {
+        // growing resize
+        vku::small::vector<NoDefaultCons, 2, size_t> v2 = {1, 2, 3, 4};
+        v2.resize(5, NoDefaultCons(0));
+        std::vector<NoDefaultCons> ref = {1, 2, 3, 4, 0};
+        ASSERT_TRUE(HaveSameElements(v2, ref));
+    }
+
+    {
+        // shrinking resize
+        vku::small::vector<NoDefaultCons, 2, size_t> v3 = {1, 2, 3, 4};
+        v3.resize(3, NoDefaultCons(0));
+        v3.shrink_to_fit();
+        ASSERT_TRUE(v3.capacity() == v3.size());
+        std::vector<NoDefaultCons> ref = {1, 2, 3};
+        ASSERT_TRUE(HaveSameElements(v3, ref));
+    }
+
+    {
+        // shrink to 0
+        vku::small::vector<NoDefaultCons, 2, size_t> v4 = {1, 2, 3, 4};
+        v4.resize(0, NoDefaultCons(0));
+        ASSERT_TRUE(v4.capacity() == 4);  // Resize doesn't shrink capacity
+        v4.shrink_to_fit();
+        ASSERT_TRUE(v4.capacity() == 2);  // Small capacity is in the minimal
+        std::vector<NoDefaultCons> ref = {};
+        ASSERT_TRUE(HaveSameElements(v4, ref));
+    }
+
+    // Resize NoDefault small vector, not moving to small store
+    // ---
+    {
+        // resize to current size
+        vku::small::vector<NoDefaultCons, 2, size_t> v6 = {1, 2, 3, 4};
+        v6.resize(v6.size());
+        std::vector<NoDefaultCons> ref = {1, 2, 3, 4};
+        ASSERT_TRUE(HaveSameElements(v6, ref));
+    }
+
+    {
+        // growing resize
+        vku::small::vector<NoDefaultCons, 2, size_t> v7 = {1, 2, 3, 4};
+        v7.resize(5, NoDefaultCons(0));
+        std::vector<NoDefaultCons> ref = {1, 2, 3, 4, 0};
+        ASSERT_TRUE(HaveSameElements(v7, ref));
+    }
+
+    {
+        // shrinking resize
+        vku::small::vector<NoDefaultCons, 2, size_t> v8 = {1, 2, 3, 4};
+        v8.resize(3, NoDefaultCons(0));
+        ASSERT_TRUE(v8.capacity() == 4);  // Resize doesn't shrink capacity
+        std::vector<NoDefaultCons> ref = {1, 2, 3};
+        ASSERT_TRUE(HaveSameElements(v8, ref));
+    }
+
+    {
+        // shrink to 0
+        vku::small::vector<NoDefaultCons, 2, size_t> v9 = {1, 2, 3, 4};
+        v9.resize(0, NoDefaultCons(0));
+        ASSERT_TRUE(v9.capacity() == 4);  // Resize doesn't shrink capacity
+        std::vector<NoDefaultCons> ref = {};
+        ASSERT_TRUE(HaveSameElements(v9, ref));
+    }
+}
+TEST(small_vector, construct) {
+    using SmallVector = vku::small::vector<std::string, 5, size_t>;
+    const SmallVector ref_small = {"one", "two", "three", "four"};
+    SmallVector ref_large = {"one", "two", "three", "four", "five", "six"};
+
+    // Small construct and emplace vs. list (tests list contruction, really)
+    SmallVector v_small_emplace;
+    v_small_emplace.emplace_back("one");
+    v_small_emplace.emplace_back("two");
+    v_small_emplace.emplace_back("three");
+    v_small_emplace.emplace_back("four");
+    ASSERT_TRUE(HaveSameElements(ref_small, v_small_emplace));
+
+    // Copy construct from small_store
+    SmallVector v_small_copy(ref_small);
+    ASSERT_TRUE(HaveSameElements(ref_small, v_small_copy));
+
+    // Move construct from small_store
+    SmallVector v_small_move_src(ref_small);
+    SmallVector v_small_move_dst(std::move(v_small_move_src));
+    ASSERT_TRUE(HaveSameElements(ref_small, v_small_move_dst));
+
+    // Small construct and emplace vs. list (tests list contruction, really)
+    SmallVector v_large_emplace;
+    v_large_emplace.emplace_back("one");
+    v_large_emplace.emplace_back("two");
+    v_large_emplace.emplace_back("three");
+    v_large_emplace.emplace_back("four");
+    v_large_emplace.emplace_back("five");
+    v_large_emplace.emplace_back("six");
+    ASSERT_TRUE(HaveSameElements(ref_large, v_large_emplace));
+
+    // Copy construct from large_store
+    SmallVector v_large_copy(ref_large);
+    ASSERT_TRUE(HaveSameElements(ref_large, v_large_copy));
+
+    // Move construct from large_store
+    SmallVector v_large_move_src(ref_large);
+    SmallVector v_large_move_dst(std::move(v_large_move_src));
+    ASSERT_TRUE(HaveSameElements(ref_large, v_large_move_dst));
+}
+
+TEST(small_vector, assign) {
+    using SmallVector = vku::small::vector<std::string, 5, size_t>;
+    const SmallVector ref_xxs = {"one", "two"};
+    const SmallVector ref_xs = {"one", "two", "three"};
+    const SmallVector ref_small = {"one", "two", "three", "four"};
+
+    const SmallVector ref_large = {"one", "two", "three", "four", "five", "six"};
+    const SmallVector ref_xl = {"one", "two", "three", "four", "five", "six", "seven"};
+    const SmallVector ref_xxl = {"one", "two", "three", "four", "five", "six", "seven", "eight"};
+
+    SmallVector v_src(ref_large);
+    SmallVector v_dst(ref_small);
+
+    // Copy from large store to small store
+    v_dst = v_src;
+    ASSERT_TRUE(HaveSameElements(ref_large, v_src));
+    ASSERT_TRUE(HaveSameElements(ref_large, v_dst));
+
+    // Quick small to large check to reset...
+    v_dst = ref_small;
+    ASSERT_TRUE(HaveSameElements(ref_small, v_dst));
+
+    // Copy from large store to small store
+    v_dst = std::move(v_src);
+    // Spec doesn't require src to be empty after move *assignment*
+    ASSERT_TRUE(HaveSameElements(ref_large, v_dst));
+
+    // Same store type copy/move
+
+    // Small
+    //
+    // Copy small to small reducing
+    v_src = ref_xs;
+    v_dst = ref_small;
+    v_dst = v_src;
+    ASSERT_TRUE(HaveSameElements(ref_xs, v_src));
+    ASSERT_TRUE(HaveSameElements(ref_xs, v_dst));
+
+    // Move small to small reducing
+    v_src = ref_xs;
+    v_dst = ref_small;
+    v_dst = std::move(v_src);
+    // Small move operators don't empty source
+    ASSERT_TRUE(HaveSameElements(ref_xs, v_dst));
+
+    // Copy small to small increasing
+    v_src = ref_small;
+    v_dst = ref_xs;
+    v_dst = v_src;
+    ASSERT_TRUE(HaveSameElements(ref_small, v_src));
+    ASSERT_TRUE(HaveSameElements(ref_small, v_dst));
+
+    // Move small to small increasing
+    v_src = ref_small;
+    v_dst = ref_xs;
+    v_dst = std::move(v_src);
+    // Small move operators don't empty source
+    ASSERT_TRUE(HaveSameElements(ref_small, v_dst));
+
+    // Large
+    //
+    // Copy large to large reducing
+    v_src = ref_large;
+    v_dst = ref_xl;
+    v_dst = v_src;
+    ASSERT_TRUE(HaveSameElements(ref_large, v_src));
+    ASSERT_TRUE(HaveSameElements(ref_large, v_dst));
+
+    // Move large to large reducing
+    v_src = ref_large;
+    v_dst = ref_xl;
+    v_dst = std::move(v_src);
+    ASSERT_TRUE(v_src.empty());  // Since large moves move the large store, the source is empty, but not required by spec of vector
+    ASSERT_TRUE(HaveSameElements(ref_large, v_dst));
+
+    // Copy large to large increasing
+    v_src = ref_xxl;
+    v_dst = ref_xl;
+    v_dst = v_src;
+    ASSERT_TRUE(HaveSameElements(ref_xxl, v_src));
+    ASSERT_TRUE(HaveSameElements(ref_xxl, v_dst));
+
+    // Move large to large increasing
+    v_src = ref_xxl;
+    v_dst = ref_xl;
+    v_dst = std::move(v_src);
+    ASSERT_TRUE(v_src.empty());
+    ASSERT_TRUE(HaveSameElements(ref_xxl, v_dst));
+}
diff --git a/tests/sparse_range_map.cpp b/tests/sparse_range_map.cpp
new file mode 100644
index 0000000..fec61a9
--- /dev/null
+++ b/tests/sparse_range_map.cpp
@@ -0,0 +1,43 @@
+// Copyright 2024 The Khronos Group Inc.
+// Copyright 2024 Valve Corporation
+// Copyright 2024 LunarG, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <gtest/gtest.h>
+#include <string>
+#include <utility>
+#include <vulkan/utility/vk_sparse_range_map.hpp>
+
+TEST(sparse_range_map, basic) {
+    vku::sparse::range_map<uint32_t, std::string> map;
+
+    map.insert(std::make_pair(vku::sparse::range<uint32_t>(0, 100), "first"));
+    map.insert(std::make_pair(vku::sparse::range<uint32_t>(500, 501), "second"));
+
+    auto iter = map.find(42);
+    ASSERT_NE(iter, map.end());
+    ASSERT_EQ(0, iter->first.begin);
+    ASSERT_EQ(100, iter->first.end);
+    ASSERT_EQ("first", iter->second);
+
+    iter = map.find(501);
+    ASSERT_EQ(iter, map.end());
+}
+
+TEST(sparse_range_map, small) {
+    vku::sparse::small_range_map<uint32_t, std::string> map;
+
+    map.insert(std::make_pair(vku::sparse::range<uint32_t>(0, 10), "first"));
+    map.insert(std::make_pair(vku::sparse::range<uint32_t>(50, 51), "second"));
+
+    auto iter = map.find(4);
+    ASSERT_NE(iter, map.end());
+    ASSERT_EQ(0, iter->first.begin);
+    ASSERT_EQ(10, iter->first.end);
+    ASSERT_EQ("first", iter->second);
+
+    iter = map.find(51);
+    ASSERT_EQ(iter, map.end());
+}

From 1defcd320897dd4216f919907016ce8ac06382d8 Mon Sep 17 00:00:00 2001
From: spencer-lunarg <spencer@lunarg.com>
Date: Wed, 10 Apr 2024 17:33:48 +0900
Subject: [PATCH 012/106] scripts: Update generate_source.py to take mulitple
 targets

---
 scripts/generate_source.py | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/scripts/generate_source.py b/scripts/generate_source.py
index 8be15a0..0e1768d 100755
--- a/scripts/generate_source.py
+++ b/scripts/generate_source.py
@@ -94,12 +94,13 @@ def RunGenerators(api: str, registry: str, targetFilter: str) -> None:
         },
     }
 
-    if (targetFilter and targetFilter not in generators.keys()):
-        print(f'ERROR: No generator options for unknown target: {targetFilter}', file=sys.stderr)
-        sys.exit(1)
+    unknownTargets = [x for x in (targetFilter if targetFilter else []) if x not in generators.keys()]
+    if unknownTargets:
+        print(f'ERROR: No generator options for unknown target(s): {", ".join(unknownTargets)}', file=sys.stderr)
+        return 1
 
     # Filter if --target is passed in
-    targets = [x for x in generators.keys() if not targetFilter or x == targetFilter]
+    targets = [x for x in generators.keys() if not targetFilter or x in targetFilter]
 
     for index, target in enumerate(targets, start=1):
         print(f'[{index}|{len(targets)}] Generating {target}')
@@ -152,7 +153,7 @@ def main(argv):
                         help='Specify API name to generate')
     parser.add_argument('registry', metavar='REGISTRY_PATH', help='path to the Vulkan-Headers registry directory')
     group = parser.add_mutually_exclusive_group()
-    group.add_argument('--target', help='only generate file name passed in')
+    group.add_argument('--target', nargs='+', help='only generate file name passed in')
     args = parser.parse_args(argv)
 
     registry = os.path.abspath(os.path.join(args.registry,  'vk.xml'))

From 1135918c966a2b829b34f7f99bb088876c2ffa52 Mon Sep 17 00:00:00 2001
From: spencer-lunarg <spencer@lunarg.com>
Date: Wed, 10 Apr 2024 18:41:54 +0900
Subject: [PATCH 013/106] safestruct: Remove safe_VkDescriptorDataEXT

---
 include/vulkan/utility/vk_safe_struct.hpp   |  24 +-
 scripts/generators/safe_struct_generator.py |   8 +-
 src/vulkan/vk_safe_struct_ext.cpp           |  12 +-
 src/vulkan/vk_safe_struct_manual.cpp        | 484 --------------------
 4 files changed, 9 insertions(+), 519 deletions(-)

diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index 4efcdcf..d8dcb9a 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -13494,33 +13494,11 @@ struct safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT {
         return reinterpret_cast<VkDescriptorBufferBindingPushDescriptorBufferHandleEXT const*>(this);
     }
 };
-union safe_VkDescriptorDataEXT {
-    const VkSampler* pSampler{};
-    const VkDescriptorImageInfo* pCombinedImageSampler;
-    const VkDescriptorImageInfo* pInputAttachmentImage;
-    const VkDescriptorImageInfo* pSampledImage;
-    const VkDescriptorImageInfo* pStorageImage;
-    safe_VkDescriptorAddressInfoEXT* pUniformTexelBuffer;
-    safe_VkDescriptorAddressInfoEXT* pStorageTexelBuffer;
-    safe_VkDescriptorAddressInfoEXT* pUniformBuffer;
-    safe_VkDescriptorAddressInfoEXT* pStorageBuffer;
-    VkDeviceAddress accelerationStructure;
-    char type_at_end[sizeof(VkDescriptorDataEXT) + sizeof(VkDescriptorGetInfoEXT::type)];
-    safe_VkDescriptorDataEXT(const VkDescriptorDataEXT* in_struct, const VkDescriptorType type, PNextCopyState* copy_state = {});
-    safe_VkDescriptorDataEXT(const safe_VkDescriptorDataEXT& copy_src);
-    safe_VkDescriptorDataEXT& operator=(const safe_VkDescriptorDataEXT& copy_src);
-    safe_VkDescriptorDataEXT();
-    ~safe_VkDescriptorDataEXT();
-    void initialize(const VkDescriptorDataEXT* in_struct, const VkDescriptorType type, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkDescriptorDataEXT* copy_src, PNextCopyState* copy_state = {});
-    VkDescriptorDataEXT* ptr() { return reinterpret_cast<VkDescriptorDataEXT*>(this); }
-    VkDescriptorDataEXT const* ptr() const { return reinterpret_cast<VkDescriptorDataEXT const*>(this); }
-};
 struct safe_VkDescriptorGetInfoEXT {
     VkStructureType sType;
     const void* pNext{};
     VkDescriptorType type;
-    safe_VkDescriptorDataEXT data;
+    VkDescriptorDataEXT data;
 
     safe_VkDescriptorGetInfoEXT(const VkDescriptorGetInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
     safe_VkDescriptorGetInfoEXT(const safe_VkDescriptorGetInfoEXT& copy_src);
diff --git a/scripts/generators/safe_struct_generator.py b/scripts/generators/safe_struct_generator.py
index b9e0de4..8c93bb7 100644
--- a/scripts/generators/safe_struct_generator.py
+++ b/scripts/generators/safe_struct_generator.py
@@ -77,9 +77,6 @@ class SafeStructOutputGenerator(BaseGenerator):
             # vku::safe::AccelerationStructureGeometryKHR needs to know if we're doing a host or device build
             'VkAccelerationStructureGeometryKHR' :
                 ', const bool is_host, const VkAccelerationStructureBuildRangeInfoKHR *build_range_info',
-            # vku::safe::DescriptorDataEXT needs to know what field of union is intialized
-            'VkDescriptorDataEXT' :
-                ', const VkDescriptorType type',
         }
 
     # Determine if a structure needs a safe_struct helper function
@@ -87,6 +84,8 @@ class SafeStructOutputGenerator(BaseGenerator):
     def needSafeStruct(self, struct: Struct) -> bool:
         if struct.name in self.no_autogen:
             return False
+        if struct.name in self.union_of_pointers:
+            return False
         if 'VkBase' in struct.name:
             return False #  Ingore structs like VkBaseOutStructure
         if struct.sType is not None:
@@ -189,9 +188,6 @@ class SafeStructOutputGenerator(BaseGenerator):
                 else:
                     out.append(f'{member.cDeclaration}{initialize};\n')
 
-            if (struct.name == 'VkDescriptorDataEXT'):
-                out.append('char type_at_end[sizeof(VkDescriptorDataEXT)+sizeof(VkDescriptorGetInfoEXT::type)];')
-
             constructParam = self.custom_construct_params.get(struct.name, '')
             out.append(f'''
                 {safe_name}(const {struct.name}* in_struct{constructParam}, PNextCopyState* copy_state = {{}}{copy_pnext});
diff --git a/src/vulkan/vk_safe_struct_ext.cpp b/src/vulkan/vk_safe_struct_ext.cpp
index 0f65c58..a399902 100644
--- a/src/vulkan/vk_safe_struct_ext.cpp
+++ b/src/vulkan/vk_safe_struct_ext.cpp
@@ -9179,19 +9179,19 @@ void safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT::initialize(
 
 safe_VkDescriptorGetInfoEXT::safe_VkDescriptorGetInfoEXT(const VkDescriptorGetInfoEXT* in_struct,
                                                          [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), type(in_struct->type), data(&in_struct->data, in_struct->type) {
+    : sType(in_struct->sType), type(in_struct->type), data(in_struct->data) {
     if (copy_pnext) {
         pNext = SafePnextCopy(in_struct->pNext, copy_state);
     }
 }
 
 safe_VkDescriptorGetInfoEXT::safe_VkDescriptorGetInfoEXT()
-    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT), pNext(nullptr), type() {}
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT), pNext(nullptr), type(), data() {}
 
 safe_VkDescriptorGetInfoEXT::safe_VkDescriptorGetInfoEXT(const safe_VkDescriptorGetInfoEXT& copy_src) {
     sType = copy_src.sType;
     type = copy_src.type;
-    data.initialize(&copy_src.data);
+    data = copy_src.data;
     pNext = SafePnextCopy(copy_src.pNext);
 }
 
@@ -9202,7 +9202,7 @@ safe_VkDescriptorGetInfoEXT& safe_VkDescriptorGetInfoEXT::operator=(const safe_V
 
     sType = copy_src.sType;
     type = copy_src.type;
-    data.initialize(&copy_src.data);
+    data = copy_src.data;
     pNext = SafePnextCopy(copy_src.pNext);
 
     return *this;
@@ -9214,7 +9214,7 @@ void safe_VkDescriptorGetInfoEXT::initialize(const VkDescriptorGetInfoEXT* in_st
     FreePnextChain(pNext);
     sType = in_struct->sType;
     type = in_struct->type;
-    data.initialize(&in_struct->data, in_struct->type);
+    data = in_struct->data;
     pNext = SafePnextCopy(in_struct->pNext, copy_state);
 }
 
@@ -9222,7 +9222,7 @@ void safe_VkDescriptorGetInfoEXT::initialize(const safe_VkDescriptorGetInfoEXT*
                                              [[maybe_unused]] PNextCopyState* copy_state) {
     sType = copy_src->sType;
     type = copy_src->type;
-    data.initialize(&copy_src->data);
+    data = copy_src->data;
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
diff --git a/src/vulkan/vk_safe_struct_manual.cpp b/src/vulkan/vk_safe_struct_manual.cpp
index 4e50f8a..e20dd9b 100644
--- a/src/vulkan/vk_safe_struct_manual.cpp
+++ b/src/vulkan/vk_safe_struct_manual.cpp
@@ -303,490 +303,6 @@ void safe_VkRayTracingPipelineCreateInfoCommon::initialize(const VkRayTracingPip
     safe_VkRayTracingPipelineCreateInfoKHR::initialize(pCreateInfo);
 }
 
-safe_VkDescriptorDataEXT::safe_VkDescriptorDataEXT(const VkDescriptorDataEXT* in_struct, const VkDescriptorType type,
-                                                   [[maybe_unused]] PNextCopyState* copy_state) {
-    VkDescriptorType* pType = (VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
-
-    switch (type) {
-        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLER:
-            pSampler = new VkSampler(*in_struct->pSampler);
-            break;
-        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
-            pCombinedImageSampler = new VkDescriptorImageInfo(*in_struct->pCombinedImageSampler);
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
-            pSampledImage = in_struct->pSampledImage ? new VkDescriptorImageInfo(*in_struct->pSampledImage) : nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
-            pStorageImage = in_struct->pStorageImage ? new VkDescriptorImageInfo(*in_struct->pStorageImage) : nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
-            pInputAttachmentImage = new VkDescriptorImageInfo(*in_struct->pInputAttachmentImage);
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
-            pUniformTexelBuffer =
-                in_struct->pUniformTexelBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pUniformTexelBuffer) : nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
-            pStorageTexelBuffer =
-                in_struct->pStorageTexelBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pStorageTexelBuffer) : nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
-            pUniformBuffer = in_struct->pUniformBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pUniformBuffer) : nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
-            pStorageBuffer = in_struct->pStorageBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pStorageBuffer) : nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
-            accelerationStructure = in_struct->accelerationStructure;
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
-            accelerationStructure = in_struct->accelerationStructure;
-            break;
-        default:
-            break;
-    }
-
-    *pType = type;
-}
-
-safe_VkDescriptorDataEXT::safe_VkDescriptorDataEXT() : type_at_end{0} {
-    VkDescriptorType* pType = (VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
-    *pType = VK_DESCRIPTOR_TYPE_MAX_ENUM;
-}
-
-safe_VkDescriptorDataEXT::safe_VkDescriptorDataEXT(const safe_VkDescriptorDataEXT& copy_src) {
-    pSampler = nullptr;
-    pCombinedImageSampler = nullptr;
-    pInputAttachmentImage = nullptr;
-    pSampledImage = nullptr;
-    pStorageImage = nullptr;
-    pUniformTexelBuffer = nullptr;
-    pStorageTexelBuffer = nullptr;
-    pUniformBuffer = nullptr;
-    pStorageBuffer = nullptr;
-    accelerationStructure = copy_src.accelerationStructure;
-
-    VkDescriptorType* pType = (VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
-    VkDescriptorType type = *(VkDescriptorType*)&copy_src.type_at_end[sizeof(VkDescriptorDataEXT)];
-
-    switch (type) {
-        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLER:
-            pSampler = new VkSampler(*copy_src.pSampler);
-            break;
-        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
-            pCombinedImageSampler = new VkDescriptorImageInfo(*copy_src.pCombinedImageSampler);
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
-            pSampledImage = new VkDescriptorImageInfo(*copy_src.pSampledImage);
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
-            pStorageImage = new VkDescriptorImageInfo(*copy_src.pStorageImage);
-            break;
-        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
-            pInputAttachmentImage = new VkDescriptorImageInfo(*copy_src.pInputAttachmentImage);
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
-            pUniformTexelBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pUniformTexelBuffer);
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
-            pStorageTexelBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pStorageTexelBuffer);
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
-            pUniformBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pUniformBuffer);
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
-            pStorageBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pStorageBuffer);
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
-            accelerationStructure = copy_src.accelerationStructure;
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
-            accelerationStructure = copy_src.accelerationStructure;
-            break;
-        default:
-            break;
-    }
-
-    *pType = type;
-}
-
-safe_VkDescriptorDataEXT& safe_VkDescriptorDataEXT::operator=(const safe_VkDescriptorDataEXT& copy_src) {
-    if (&copy_src == this) return *this;
-
-    VkDescriptorType& thisType = *(VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
-
-    switch (thisType) {
-        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLER:
-            delete pSampler;
-            pSampler = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
-            delete pCombinedImageSampler;
-            pCombinedImageSampler = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
-            delete pSampledImage;
-            pSampledImage = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
-            delete pStorageImage;
-            pStorageImage = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
-            delete pInputAttachmentImage;
-            pInputAttachmentImage = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
-            delete pUniformTexelBuffer;
-            pUniformTexelBuffer = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
-            delete pStorageTexelBuffer;
-            pStorageTexelBuffer = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
-            delete pUniformBuffer;
-            pUniformBuffer = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
-            delete pStorageBuffer;
-            pStorageBuffer = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
-            accelerationStructure = 0ull;
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
-            accelerationStructure = 0ull;
-            break;
-        default:
-            break;
-    }
-
-    thisType = VK_DESCRIPTOR_TYPE_MAX_ENUM;
-
-    pSampler = nullptr;
-    pCombinedImageSampler = nullptr;
-    pInputAttachmentImage = nullptr;
-    pSampledImage = nullptr;
-    pStorageImage = nullptr;
-    pUniformTexelBuffer = nullptr;
-    pStorageTexelBuffer = nullptr;
-    pUniformBuffer = nullptr;
-    pStorageBuffer = nullptr;
-    accelerationStructure = copy_src.accelerationStructure;
-
-    VkDescriptorType* pType = (VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
-    VkDescriptorType type = *(VkDescriptorType*)&copy_src.type_at_end[sizeof(VkDescriptorDataEXT)];
-
-    switch (type) {
-        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLER:
-            pSampler = new VkSampler(*copy_src.pSampler);
-            break;
-        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
-            pCombinedImageSampler = new VkDescriptorImageInfo(*copy_src.pCombinedImageSampler);
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
-            pSampledImage = new VkDescriptorImageInfo(*copy_src.pSampledImage);
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
-            pStorageImage = new VkDescriptorImageInfo(*copy_src.pStorageImage);
-            break;
-        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
-            pInputAttachmentImage = new VkDescriptorImageInfo(*copy_src.pInputAttachmentImage);
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
-            pUniformTexelBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pUniformTexelBuffer);
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
-            pStorageTexelBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pStorageTexelBuffer);
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
-            pUniformBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pUniformBuffer);
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
-            pStorageBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pStorageBuffer);
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
-            accelerationStructure = copy_src.accelerationStructure;
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
-            accelerationStructure = copy_src.accelerationStructure;
-            break;
-        default:
-            break;
-    }
-
-    *pType = type;
-
-    return *this;
-}
-
-safe_VkDescriptorDataEXT::~safe_VkDescriptorDataEXT() {
-    VkDescriptorType& thisType = *(VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
-
-    switch (thisType) {
-        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLER:
-            delete pSampler;
-            pSampler = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
-            delete pCombinedImageSampler;
-            pCombinedImageSampler = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
-            delete pSampledImage;
-            pSampledImage = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
-            delete pStorageImage;
-            pStorageImage = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
-            delete pInputAttachmentImage;
-            pInputAttachmentImage = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
-            delete pUniformTexelBuffer;
-            pUniformTexelBuffer = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
-            delete pStorageTexelBuffer;
-            pStorageTexelBuffer = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
-            delete pUniformBuffer;
-            pUniformBuffer = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
-            delete pStorageBuffer;
-            pStorageBuffer = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
-            accelerationStructure = 0ull;
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
-            accelerationStructure = 0ull;
-            break;
-        default:
-            break;
-    }
-
-    thisType = VK_DESCRIPTOR_TYPE_MAX_ENUM;
-}
-
-void safe_VkDescriptorDataEXT::initialize(const VkDescriptorDataEXT* in_struct, const VkDescriptorType type,
-                                          [[maybe_unused]] PNextCopyState* copy_state) {
-    VkDescriptorType& thisType = *(VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
-
-    switch (thisType) {
-        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLER:
-            delete pSampler;
-            pSampler = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
-            delete pCombinedImageSampler;
-            pCombinedImageSampler = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
-            delete pSampledImage;
-            pSampledImage = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
-            delete pStorageImage;
-            pStorageImage = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
-            delete pInputAttachmentImage;
-            pInputAttachmentImage = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
-            delete pUniformTexelBuffer;
-            pUniformTexelBuffer = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
-            delete pStorageTexelBuffer;
-            pStorageTexelBuffer = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
-            delete pUniformBuffer;
-            pUniformBuffer = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
-            delete pStorageBuffer;
-            pStorageBuffer = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
-            accelerationStructure = 0ull;
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
-            accelerationStructure = 0ull;
-            break;
-        default:
-            break;
-    }
-
-    thisType = VK_DESCRIPTOR_TYPE_MAX_ENUM;
-    pSampler = nullptr;
-    pCombinedImageSampler = nullptr;
-    pInputAttachmentImage = nullptr;
-    pSampledImage = nullptr;
-    pStorageImage = nullptr;
-    pUniformTexelBuffer = nullptr;
-    pStorageTexelBuffer = nullptr;
-    pUniformBuffer = nullptr;
-    pStorageBuffer = nullptr;
-    accelerationStructure = in_struct->accelerationStructure;
-
-    VkDescriptorType* pType = (VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
-
-    switch (type) {
-        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLER:
-            pSampler = new VkSampler(*in_struct->pSampler);
-            break;
-        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
-            pCombinedImageSampler = new VkDescriptorImageInfo(*in_struct->pCombinedImageSampler);
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
-            pSampledImage = in_struct->pSampledImage ? new VkDescriptorImageInfo(*in_struct->pSampledImage) : nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
-            pStorageImage = in_struct->pStorageImage ? new VkDescriptorImageInfo(*in_struct->pStorageImage) : nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
-            pInputAttachmentImage = new VkDescriptorImageInfo(*in_struct->pInputAttachmentImage);
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
-            pUniformTexelBuffer =
-                in_struct->pUniformTexelBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pUniformTexelBuffer) : nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
-            pStorageTexelBuffer =
-                in_struct->pStorageTexelBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pStorageTexelBuffer) : nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
-            pUniformBuffer = in_struct->pUniformBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pUniformBuffer) : nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
-            pStorageBuffer = in_struct->pStorageBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pStorageBuffer) : nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
-            accelerationStructure = in_struct->accelerationStructure;
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
-            accelerationStructure = in_struct->accelerationStructure;
-            break;
-        default:
-            break;
-    }
-
-    *pType = type;
-}
-
-void safe_VkDescriptorDataEXT::initialize(const safe_VkDescriptorDataEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
-    pSampler = nullptr;
-    pCombinedImageSampler = nullptr;
-    pInputAttachmentImage = nullptr;
-    pSampledImage = nullptr;
-    pStorageImage = nullptr;
-    pUniformTexelBuffer = nullptr;
-    pStorageTexelBuffer = nullptr;
-    pUniformBuffer = nullptr;
-    pStorageBuffer = nullptr;
-    accelerationStructure = copy_src->accelerationStructure;
-
-    VkDescriptorType* pType = (VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
-    VkDescriptorType type = *(VkDescriptorType*)&copy_src->type_at_end[sizeof(VkDescriptorDataEXT)];
-
-    switch (type) {
-        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLER:
-            pSampler = new VkSampler(*copy_src->pSampler);
-            break;
-        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
-            pCombinedImageSampler = new VkDescriptorImageInfo(*copy_src->pCombinedImageSampler);
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
-            pSampledImage = new VkDescriptorImageInfo(*copy_src->pSampledImage);
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
-            pStorageImage = new VkDescriptorImageInfo(*copy_src->pStorageImage);
-            break;
-        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
-            pInputAttachmentImage = new VkDescriptorImageInfo(*copy_src->pInputAttachmentImage);
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
-            pUniformTexelBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src->pUniformTexelBuffer);
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
-            pStorageTexelBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src->pStorageTexelBuffer);
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
-            pUniformBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src->pUniformBuffer);
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
-            pStorageBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src->pStorageBuffer);
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
-            accelerationStructure = copy_src->accelerationStructure;
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
-            accelerationStructure = copy_src->accelerationStructure;
-            break;
-        default:
-            break;
-    }
-
-    *pType = type;
-}
-
 safe_VkGraphicsPipelineCreateInfo::safe_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo* in_struct,
                                                                      const bool uses_color_attachment,
                                                                      const bool uses_depthstencil_attachment,

From 72696f278218d39171678e41d8f43cff9905c513 Mon Sep 17 00:00:00 2001
From: Aaron Ruby <aruby@blackberry.com>
Date: Thu, 11 Apr 2024 14:35:36 -0400
Subject: [PATCH 014/106] safestruct: Add QNX platform types to abstract_types
 list

---
 scripts/generators/safe_struct_generator.py |   3 +
 src/vulkan/vk_safe_struct_vendor.cpp        | 102 ++++----------------
 2 files changed, 20 insertions(+), 85 deletions(-)

diff --git a/scripts/generators/safe_struct_generator.py b/scripts/generators/safe_struct_generator.py
index 8c93bb7..b893877 100644
--- a/scripts/generators/safe_struct_generator.py
+++ b/scripts/generators/safe_struct_generator.py
@@ -53,6 +53,9 @@ class SafeStructOutputGenerator(BaseGenerator):
         # since we cannot make a copy.
         self.abstract_types = [
             'AHardwareBuffer',
+            '_screen_context',
+            '_screen_window',
+            '_screen_buffer'
         ]
 
         # These 'data' union are decided by the 'type' in the same parent struct
diff --git a/src/vulkan/vk_safe_struct_vendor.cpp b/src/vulkan/vk_safe_struct_vendor.cpp
index 6054229..7896c22 100644
--- a/src/vulkan/vk_safe_struct_vendor.cpp
+++ b/src/vulkan/vk_safe_struct_vendor.cpp
@@ -10040,13 +10040,8 @@ safe_VkScreenSurfaceCreateInfoQNX::safe_VkScreenSurfaceCreateInfoQNX(const VkScr
     if (copy_pnext) {
         pNext = SafePnextCopy(in_struct->pNext, copy_state);
     }
-    if (in_struct->context) {
-        context = new _screen_context(*in_struct->context);
-    }
-
-    if (in_struct->window) {
-        window = new _screen_window(*in_struct->window);
-    }
+    context = in_struct->context;
+    window = in_struct->window;
 }
 
 safe_VkScreenSurfaceCreateInfoQNX::safe_VkScreenSurfaceCreateInfoQNX()
@@ -10055,84 +10050,44 @@ safe_VkScreenSurfaceCreateInfoQNX::safe_VkScreenSurfaceCreateInfoQNX()
 safe_VkScreenSurfaceCreateInfoQNX::safe_VkScreenSurfaceCreateInfoQNX(const safe_VkScreenSurfaceCreateInfoQNX& copy_src) {
     sType = copy_src.sType;
     flags = copy_src.flags;
-    context = nullptr;
-    window = nullptr;
     pNext = SafePnextCopy(copy_src.pNext);
-
-    if (copy_src.context) {
-        context = new _screen_context(*copy_src.context);
-    }
-
-    if (copy_src.window) {
-        window = new _screen_window(*copy_src.window);
-    }
+    context = copy_src.context;
+    window = copy_src.window;
 }
 
 safe_VkScreenSurfaceCreateInfoQNX& safe_VkScreenSurfaceCreateInfoQNX::operator=(const safe_VkScreenSurfaceCreateInfoQNX& copy_src) {
     if (&copy_src == this) return *this;
 
-    if (context) delete context;
-    if (window) delete window;
     FreePnextChain(pNext);
 
     sType = copy_src.sType;
     flags = copy_src.flags;
-    context = nullptr;
-    window = nullptr;
     pNext = SafePnextCopy(copy_src.pNext);
-
-    if (copy_src.context) {
-        context = new _screen_context(*copy_src.context);
-    }
-
-    if (copy_src.window) {
-        window = new _screen_window(*copy_src.window);
-    }
+    context = copy_src.context;
+    window = copy_src.window;
 
     return *this;
 }
 
-safe_VkScreenSurfaceCreateInfoQNX::~safe_VkScreenSurfaceCreateInfoQNX() {
-    if (context) delete context;
-    if (window) delete window;
-    FreePnextChain(pNext);
-}
+safe_VkScreenSurfaceCreateInfoQNX::~safe_VkScreenSurfaceCreateInfoQNX() { FreePnextChain(pNext); }
 
 void safe_VkScreenSurfaceCreateInfoQNX::initialize(const VkScreenSurfaceCreateInfoQNX* in_struct,
                                                    [[maybe_unused]] PNextCopyState* copy_state) {
-    if (context) delete context;
-    if (window) delete window;
     FreePnextChain(pNext);
     sType = in_struct->sType;
     flags = in_struct->flags;
-    context = nullptr;
-    window = nullptr;
     pNext = SafePnextCopy(in_struct->pNext, copy_state);
-
-    if (in_struct->context) {
-        context = new _screen_context(*in_struct->context);
-    }
-
-    if (in_struct->window) {
-        window = new _screen_window(*in_struct->window);
-    }
+    context = in_struct->context;
+    window = in_struct->window;
 }
 
 void safe_VkScreenSurfaceCreateInfoQNX::initialize(const safe_VkScreenSurfaceCreateInfoQNX* copy_src,
                                                    [[maybe_unused]] PNextCopyState* copy_state) {
     sType = copy_src->sType;
     flags = copy_src->flags;
-    context = nullptr;
-    window = nullptr;
     pNext = SafePnextCopy(copy_src->pNext);
-
-    if (copy_src->context) {
-        context = new _screen_context(*copy_src->context);
-    }
-
-    if (copy_src->window) {
-        window = new _screen_window(*copy_src->window);
-    }
+    context = copy_src->context;
+    window = copy_src->window;
 }
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
 #ifdef VK_ENABLE_BETA_EXTENSIONS
@@ -14774,9 +14729,7 @@ safe_VkImportScreenBufferInfoQNX::safe_VkImportScreenBufferInfoQNX(const VkImpor
     if (copy_pnext) {
         pNext = SafePnextCopy(in_struct->pNext, copy_state);
     }
-    if (in_struct->buffer) {
-        buffer = new _screen_buffer(*in_struct->buffer);
-    }
+    buffer = in_struct->buffer;
 }
 
 safe_VkImportScreenBufferInfoQNX::safe_VkImportScreenBufferInfoQNX()
@@ -14784,58 +14737,37 @@ safe_VkImportScreenBufferInfoQNX::safe_VkImportScreenBufferInfoQNX()
 
 safe_VkImportScreenBufferInfoQNX::safe_VkImportScreenBufferInfoQNX(const safe_VkImportScreenBufferInfoQNX& copy_src) {
     sType = copy_src.sType;
-    buffer = nullptr;
     pNext = SafePnextCopy(copy_src.pNext);
-
-    if (copy_src.buffer) {
-        buffer = new _screen_buffer(*copy_src.buffer);
-    }
+    buffer = copy_src.buffer;
 }
 
 safe_VkImportScreenBufferInfoQNX& safe_VkImportScreenBufferInfoQNX::operator=(const safe_VkImportScreenBufferInfoQNX& copy_src) {
     if (&copy_src == this) return *this;
 
-    if (buffer) delete buffer;
     FreePnextChain(pNext);
 
     sType = copy_src.sType;
-    buffer = nullptr;
     pNext = SafePnextCopy(copy_src.pNext);
-
-    if (copy_src.buffer) {
-        buffer = new _screen_buffer(*copy_src.buffer);
-    }
+    buffer = copy_src.buffer;
 
     return *this;
 }
 
-safe_VkImportScreenBufferInfoQNX::~safe_VkImportScreenBufferInfoQNX() {
-    if (buffer) delete buffer;
-    FreePnextChain(pNext);
-}
+safe_VkImportScreenBufferInfoQNX::~safe_VkImportScreenBufferInfoQNX() { FreePnextChain(pNext); }
 
 void safe_VkImportScreenBufferInfoQNX::initialize(const VkImportScreenBufferInfoQNX* in_struct,
                                                   [[maybe_unused]] PNextCopyState* copy_state) {
-    if (buffer) delete buffer;
     FreePnextChain(pNext);
     sType = in_struct->sType;
-    buffer = nullptr;
     pNext = SafePnextCopy(in_struct->pNext, copy_state);
-
-    if (in_struct->buffer) {
-        buffer = new _screen_buffer(*in_struct->buffer);
-    }
+    buffer = in_struct->buffer;
 }
 
 void safe_VkImportScreenBufferInfoQNX::initialize(const safe_VkImportScreenBufferInfoQNX* copy_src,
                                                   [[maybe_unused]] PNextCopyState* copy_state) {
     sType = copy_src->sType;
-    buffer = nullptr;
     pNext = SafePnextCopy(copy_src->pNext);
-
-    if (copy_src->buffer) {
-        buffer = new _screen_buffer(*copy_src->buffer);
-    }
+    buffer = copy_src->buffer;
 }
 
 safe_VkExternalFormatQNX::safe_VkExternalFormatQNX(const VkExternalFormatQNX* in_struct,

From a78460f66b69285ec3c2e5abf794163ef61d1782 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Sun, 14 Apr 2024 05:08:48 +0200
Subject: [PATCH 015/106] Fix update_deps.py script to handle Windows Arm64.

---
 scripts/update_deps.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/scripts/update_deps.py b/scripts/update_deps.py
index 2eb6b3f..57f0ef5 100755
--- a/scripts/update_deps.py
+++ b/scripts/update_deps.py
@@ -492,11 +492,12 @@ class GoodRepo(object):
         # Use the CMake -A option to select the platform architecture
         # without needing a Visual Studio generator.
         if platform.system() == 'Windows' and self._args.generator != "Ninja":
+            cmake_cmd.append('-A')
             if self._args.arch.lower() == '64' or self._args.arch == 'x64' or self._args.arch == 'win64':
-                cmake_cmd.append('-A')
                 cmake_cmd.append('x64')
+            elif self._args.arch == 'arm64':
+                cmake_cmd.append('arm64')
             else:
-                cmake_cmd.append('-A')
                 cmake_cmd.append('Win32')
 
         # Apply a generator, if one is specified.  This can be used to supply
@@ -677,7 +678,7 @@ def main():
     parser.add_argument(
         '--arch',
         dest='arch',
-        choices=['32', '64', 'x86', 'x64', 'win32', 'win64'],
+        choices=['32', '64', 'x86', 'x64', 'win32', 'win64', 'arm64'],
         type=str.lower,
         help="Set build files architecture (Visual Studio Generator Only)",
         default='64')

From d0670f9ff0da1a2f7596d4861f601dc4c8810aea Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Tue, 16 Apr 2024 11:46:19 -0700
Subject: [PATCH 016/106] build: Update to header 1.3.282

---
 include/vulkan/utility/vk_format_utils.h | 20 +++++++++++++++++---
 include/vulkan/vk_enum_string_helper.h   |  4 ++--
 scripts/known_good.json                  |  2 +-
 3 files changed, 20 insertions(+), 6 deletions(-)

diff --git a/include/vulkan/utility/vk_format_utils.h b/include/vulkan/utility/vk_format_utils.h
index 317aab0..1b0ea3f 100644
--- a/include/vulkan/utility/vk_format_utils.h
+++ b/include/vulkan/utility/vk_format_utils.h
@@ -24,6 +24,7 @@ extern "C" {
 
 enum VKU_FORMAT_NUMERICAL_TYPE {
     VKU_FORMAT_NUMERICAL_TYPE_NONE = 0,
+    VKU_FORMAT_NUMERICAL_TYPE_SFIXED5,
     VKU_FORMAT_NUMERICAL_TYPE_SFLOAT,
     VKU_FORMAT_NUMERICAL_TYPE_SINT,
     VKU_FORMAT_NUMERICAL_TYPE_SNORM,
@@ -128,6 +129,10 @@ enum VKU_FORMAT_COMPATIBILITY_CLASS {
 //     <any other value> -> VKU_FORMAT_INVALID_INDEX
 inline uint32_t vkuGetPlaneIndex(VkImageAspectFlagBits aspect);
 
+// Returns whether a VkFormat is of the numerical format SFIXED5
+// Format must only contain one numerical format, so formats like D16_UNORM_S8_UINT always return false
+inline bool vkuFormatIsSFIXED5(VkFormat format);
+
 // Returns whether a VkFormat is of the numerical format SFLOAT
 // Format must only contain one numerical format, so formats like D16_UNORM_S8_UINT always return false
 inline bool vkuFormatIsSFLOAT(VkFormat format);
@@ -1096,7 +1101,7 @@ inline const struct VKU_FORMAT_INFO vkuGetFormatInfo(VkFormat format) {
         case VK_FORMAT_A4B4G4R4_UNORM_PACK16: {
             struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 4}, {VKU_FORMAT_COMPONENT_TYPE_B, 4}, {VKU_FORMAT_COMPONENT_TYPE_G, 4}, {VKU_FORMAT_COMPONENT_TYPE_R, 4}}};
             return out; }
-        case VK_FORMAT_R16G16_S10_5_NV: {
+        case VK_FORMAT_R16G16_SFIXED5_NV: {
             struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}}};
             return out; }
 
@@ -1200,6 +1205,16 @@ inline const struct VKU_FORMAT_MULTIPLANE_COMPATIBILITY vkuGetFormatCompatibilit
     };
 }
 
+// Return true if all components in a format are an SFIXED5
+bool vkuFormatIsSFIXED5(VkFormat format) {
+    switch (format) {
+        case VK_FORMAT_R16G16_SFIXED5_NV:
+            return true;
+        default:
+            return false;
+    }
+}
+
 // Return true if all components in a format are an SFLOAT
 bool vkuFormatIsSFLOAT(VkFormat format) {
     switch (format) {
@@ -1261,7 +1276,6 @@ bool vkuFormatIsSINT(VkFormat format) {
         case VK_FORMAT_R64G64_SINT:
         case VK_FORMAT_R64G64B64_SINT:
         case VK_FORMAT_R64G64B64A64_SINT:
-        case VK_FORMAT_R16G16_S10_5_NV:
             return true;
         default:
             return false;
@@ -2169,7 +2183,7 @@ inline bool vkuFormatIs16bit(VkFormat format) {
         case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
         case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM:
         case VK_FORMAT_G16_B16R16_2PLANE_444_UNORM:
-        case VK_FORMAT_R16G16_S10_5_NV:
+        case VK_FORMAT_R16G16_SFIXED5_NV:
             return true;
         default:
             return false;
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index 6f4fe4c..bc41047 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -2634,8 +2634,8 @@ static inline const char* string_VkFormat(VkFormat input_value) {
             return "VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG";
         case VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG:
             return "VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG";
-        case VK_FORMAT_R16G16_S10_5_NV:
-            return "VK_FORMAT_R16G16_S10_5_NV";
+        case VK_FORMAT_R16G16_SFIXED5_NV:
+            return "VK_FORMAT_R16G16_SFIXED5_NV";
         case VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR:
             return "VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR";
         case VK_FORMAT_A8_UNORM_KHR:
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 68dfd38..18d3a26 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.3.281"
+            "commit": "v1.3.282"
         },
         {
             "name": "googletest",

From 6e6a4e05bf48db1f302b9988e50b1c723e46dc5a Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Fri, 19 Apr 2024 08:47:18 -0700
Subject: [PATCH 017/106] build: Update to header 1.3.283

---
 include/vulkan/vk_enum_string_helper.h | 1 +
 scripts/known_good.json                | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index bc41047..8026787 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -8229,6 +8229,7 @@ static inline const char* string_VkPipelineCreateFlagBits2KHR(uint64_t input_val
     if (input_value == VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR) return "VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR";
     if (input_value == VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR) return "VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR";
     if (input_value == VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR) return "VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR";
+    if (input_value == VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT) return "VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT";
     if (input_value == VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR) return "VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR";
     if (input_value == VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR) return "VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR";
     if (input_value == VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV) return "VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV";
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 18d3a26..58987c8 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.3.282"
+            "commit": "v1.3.283"
         },
         {
             "name": "googletest",

From d0ffc68fe796ffd5752b7a2cba7c4f1d80ed7283 Mon Sep 17 00:00:00 2001
From: ziga-lunarg <ziga@lunarg.com>
Date: Sat, 20 Apr 2024 20:01:23 +0200
Subject: [PATCH 018/106] Revert "safestruct: Remove safe_VkDescriptorDataEXT"

This reverts commit 1135918c966a2b829b34f7f99bb088876c2ffa52.
---
 include/vulkan/utility/vk_safe_struct.hpp   |  24 +-
 scripts/generators/safe_struct_generator.py |   8 +-
 src/vulkan/vk_safe_struct_ext.cpp           |  12 +-
 src/vulkan/vk_safe_struct_manual.cpp        | 484 ++++++++++++++++++++
 4 files changed, 519 insertions(+), 9 deletions(-)

diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index d8dcb9a..4efcdcf 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -13494,11 +13494,33 @@ struct safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT {
         return reinterpret_cast<VkDescriptorBufferBindingPushDescriptorBufferHandleEXT const*>(this);
     }
 };
+union safe_VkDescriptorDataEXT {
+    const VkSampler* pSampler{};
+    const VkDescriptorImageInfo* pCombinedImageSampler;
+    const VkDescriptorImageInfo* pInputAttachmentImage;
+    const VkDescriptorImageInfo* pSampledImage;
+    const VkDescriptorImageInfo* pStorageImage;
+    safe_VkDescriptorAddressInfoEXT* pUniformTexelBuffer;
+    safe_VkDescriptorAddressInfoEXT* pStorageTexelBuffer;
+    safe_VkDescriptorAddressInfoEXT* pUniformBuffer;
+    safe_VkDescriptorAddressInfoEXT* pStorageBuffer;
+    VkDeviceAddress accelerationStructure;
+    char type_at_end[sizeof(VkDescriptorDataEXT) + sizeof(VkDescriptorGetInfoEXT::type)];
+    safe_VkDescriptorDataEXT(const VkDescriptorDataEXT* in_struct, const VkDescriptorType type, PNextCopyState* copy_state = {});
+    safe_VkDescriptorDataEXT(const safe_VkDescriptorDataEXT& copy_src);
+    safe_VkDescriptorDataEXT& operator=(const safe_VkDescriptorDataEXT& copy_src);
+    safe_VkDescriptorDataEXT();
+    ~safe_VkDescriptorDataEXT();
+    void initialize(const VkDescriptorDataEXT* in_struct, const VkDescriptorType type, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDescriptorDataEXT* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorDataEXT* ptr() { return reinterpret_cast<VkDescriptorDataEXT*>(this); }
+    VkDescriptorDataEXT const* ptr() const { return reinterpret_cast<VkDescriptorDataEXT const*>(this); }
+};
 struct safe_VkDescriptorGetInfoEXT {
     VkStructureType sType;
     const void* pNext{};
     VkDescriptorType type;
-    VkDescriptorDataEXT data;
+    safe_VkDescriptorDataEXT data;
 
     safe_VkDescriptorGetInfoEXT(const VkDescriptorGetInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
     safe_VkDescriptorGetInfoEXT(const safe_VkDescriptorGetInfoEXT& copy_src);
diff --git a/scripts/generators/safe_struct_generator.py b/scripts/generators/safe_struct_generator.py
index b893877..8ce9a2a 100644
--- a/scripts/generators/safe_struct_generator.py
+++ b/scripts/generators/safe_struct_generator.py
@@ -80,6 +80,9 @@ class SafeStructOutputGenerator(BaseGenerator):
             # vku::safe::AccelerationStructureGeometryKHR needs to know if we're doing a host or device build
             'VkAccelerationStructureGeometryKHR' :
                 ', const bool is_host, const VkAccelerationStructureBuildRangeInfoKHR *build_range_info',
+            # vku::safe::DescriptorDataEXT needs to know what field of union is intialized
+            'VkDescriptorDataEXT' :
+                ', const VkDescriptorType type',
         }
 
     # Determine if a structure needs a safe_struct helper function
@@ -87,8 +90,6 @@ class SafeStructOutputGenerator(BaseGenerator):
     def needSafeStruct(self, struct: Struct) -> bool:
         if struct.name in self.no_autogen:
             return False
-        if struct.name in self.union_of_pointers:
-            return False
         if 'VkBase' in struct.name:
             return False #  Ingore structs like VkBaseOutStructure
         if struct.sType is not None:
@@ -191,6 +192,9 @@ class SafeStructOutputGenerator(BaseGenerator):
                 else:
                     out.append(f'{member.cDeclaration}{initialize};\n')
 
+            if (struct.name == 'VkDescriptorDataEXT'):
+                out.append('char type_at_end[sizeof(VkDescriptorDataEXT)+sizeof(VkDescriptorGetInfoEXT::type)];')
+
             constructParam = self.custom_construct_params.get(struct.name, '')
             out.append(f'''
                 {safe_name}(const {struct.name}* in_struct{constructParam}, PNextCopyState* copy_state = {{}}{copy_pnext});
diff --git a/src/vulkan/vk_safe_struct_ext.cpp b/src/vulkan/vk_safe_struct_ext.cpp
index a399902..0f65c58 100644
--- a/src/vulkan/vk_safe_struct_ext.cpp
+++ b/src/vulkan/vk_safe_struct_ext.cpp
@@ -9179,19 +9179,19 @@ void safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT::initialize(
 
 safe_VkDescriptorGetInfoEXT::safe_VkDescriptorGetInfoEXT(const VkDescriptorGetInfoEXT* in_struct,
                                                          [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), type(in_struct->type), data(in_struct->data) {
+    : sType(in_struct->sType), type(in_struct->type), data(&in_struct->data, in_struct->type) {
     if (copy_pnext) {
         pNext = SafePnextCopy(in_struct->pNext, copy_state);
     }
 }
 
 safe_VkDescriptorGetInfoEXT::safe_VkDescriptorGetInfoEXT()
-    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT), pNext(nullptr), type(), data() {}
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT), pNext(nullptr), type() {}
 
 safe_VkDescriptorGetInfoEXT::safe_VkDescriptorGetInfoEXT(const safe_VkDescriptorGetInfoEXT& copy_src) {
     sType = copy_src.sType;
     type = copy_src.type;
-    data = copy_src.data;
+    data.initialize(&copy_src.data);
     pNext = SafePnextCopy(copy_src.pNext);
 }
 
@@ -9202,7 +9202,7 @@ safe_VkDescriptorGetInfoEXT& safe_VkDescriptorGetInfoEXT::operator=(const safe_V
 
     sType = copy_src.sType;
     type = copy_src.type;
-    data = copy_src.data;
+    data.initialize(&copy_src.data);
     pNext = SafePnextCopy(copy_src.pNext);
 
     return *this;
@@ -9214,7 +9214,7 @@ void safe_VkDescriptorGetInfoEXT::initialize(const VkDescriptorGetInfoEXT* in_st
     FreePnextChain(pNext);
     sType = in_struct->sType;
     type = in_struct->type;
-    data = in_struct->data;
+    data.initialize(&in_struct->data, in_struct->type);
     pNext = SafePnextCopy(in_struct->pNext, copy_state);
 }
 
@@ -9222,7 +9222,7 @@ void safe_VkDescriptorGetInfoEXT::initialize(const safe_VkDescriptorGetInfoEXT*
                                              [[maybe_unused]] PNextCopyState* copy_state) {
     sType = copy_src->sType;
     type = copy_src->type;
-    data = copy_src->data;
+    data.initialize(&copy_src->data);
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
diff --git a/src/vulkan/vk_safe_struct_manual.cpp b/src/vulkan/vk_safe_struct_manual.cpp
index e20dd9b..4e50f8a 100644
--- a/src/vulkan/vk_safe_struct_manual.cpp
+++ b/src/vulkan/vk_safe_struct_manual.cpp
@@ -303,6 +303,490 @@ void safe_VkRayTracingPipelineCreateInfoCommon::initialize(const VkRayTracingPip
     safe_VkRayTracingPipelineCreateInfoKHR::initialize(pCreateInfo);
 }
 
+safe_VkDescriptorDataEXT::safe_VkDescriptorDataEXT(const VkDescriptorDataEXT* in_struct, const VkDescriptorType type,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    VkDescriptorType* pType = (VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
+
+    switch (type) {
+        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLER:
+            pSampler = new VkSampler(*in_struct->pSampler);
+            break;
+        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+            pCombinedImageSampler = new VkDescriptorImageInfo(*in_struct->pCombinedImageSampler);
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+            pSampledImage = in_struct->pSampledImage ? new VkDescriptorImageInfo(*in_struct->pSampledImage) : nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+            pStorageImage = in_struct->pStorageImage ? new VkDescriptorImageInfo(*in_struct->pStorageImage) : nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+            pInputAttachmentImage = new VkDescriptorImageInfo(*in_struct->pInputAttachmentImage);
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+            pUniformTexelBuffer =
+                in_struct->pUniformTexelBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pUniformTexelBuffer) : nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+            pStorageTexelBuffer =
+                in_struct->pStorageTexelBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pStorageTexelBuffer) : nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+            pUniformBuffer = in_struct->pUniformBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pUniformBuffer) : nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+            pStorageBuffer = in_struct->pStorageBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pStorageBuffer) : nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
+            accelerationStructure = in_struct->accelerationStructure;
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
+            accelerationStructure = in_struct->accelerationStructure;
+            break;
+        default:
+            break;
+    }
+
+    *pType = type;
+}
+
+safe_VkDescriptorDataEXT::safe_VkDescriptorDataEXT() : type_at_end{0} {
+    VkDescriptorType* pType = (VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
+    *pType = VK_DESCRIPTOR_TYPE_MAX_ENUM;
+}
+
+safe_VkDescriptorDataEXT::safe_VkDescriptorDataEXT(const safe_VkDescriptorDataEXT& copy_src) {
+    pSampler = nullptr;
+    pCombinedImageSampler = nullptr;
+    pInputAttachmentImage = nullptr;
+    pSampledImage = nullptr;
+    pStorageImage = nullptr;
+    pUniformTexelBuffer = nullptr;
+    pStorageTexelBuffer = nullptr;
+    pUniformBuffer = nullptr;
+    pStorageBuffer = nullptr;
+    accelerationStructure = copy_src.accelerationStructure;
+
+    VkDescriptorType* pType = (VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
+    VkDescriptorType type = *(VkDescriptorType*)&copy_src.type_at_end[sizeof(VkDescriptorDataEXT)];
+
+    switch (type) {
+        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLER:
+            pSampler = new VkSampler(*copy_src.pSampler);
+            break;
+        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+            pCombinedImageSampler = new VkDescriptorImageInfo(*copy_src.pCombinedImageSampler);
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+            pSampledImage = new VkDescriptorImageInfo(*copy_src.pSampledImage);
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+            pStorageImage = new VkDescriptorImageInfo(*copy_src.pStorageImage);
+            break;
+        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+            pInputAttachmentImage = new VkDescriptorImageInfo(*copy_src.pInputAttachmentImage);
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+            pUniformTexelBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pUniformTexelBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+            pStorageTexelBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pStorageTexelBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+            pUniformBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pUniformBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+            pStorageBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pStorageBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
+            accelerationStructure = copy_src.accelerationStructure;
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
+            accelerationStructure = copy_src.accelerationStructure;
+            break;
+        default:
+            break;
+    }
+
+    *pType = type;
+}
+
+safe_VkDescriptorDataEXT& safe_VkDescriptorDataEXT::operator=(const safe_VkDescriptorDataEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    VkDescriptorType& thisType = *(VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
+
+    switch (thisType) {
+        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLER:
+            delete pSampler;
+            pSampler = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+            delete pCombinedImageSampler;
+            pCombinedImageSampler = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+            delete pSampledImage;
+            pSampledImage = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+            delete pStorageImage;
+            pStorageImage = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+            delete pInputAttachmentImage;
+            pInputAttachmentImage = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+            delete pUniformTexelBuffer;
+            pUniformTexelBuffer = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+            delete pStorageTexelBuffer;
+            pStorageTexelBuffer = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+            delete pUniformBuffer;
+            pUniformBuffer = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+            delete pStorageBuffer;
+            pStorageBuffer = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
+            accelerationStructure = 0ull;
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
+            accelerationStructure = 0ull;
+            break;
+        default:
+            break;
+    }
+
+    thisType = VK_DESCRIPTOR_TYPE_MAX_ENUM;
+
+    pSampler = nullptr;
+    pCombinedImageSampler = nullptr;
+    pInputAttachmentImage = nullptr;
+    pSampledImage = nullptr;
+    pStorageImage = nullptr;
+    pUniformTexelBuffer = nullptr;
+    pStorageTexelBuffer = nullptr;
+    pUniformBuffer = nullptr;
+    pStorageBuffer = nullptr;
+    accelerationStructure = copy_src.accelerationStructure;
+
+    VkDescriptorType* pType = (VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
+    VkDescriptorType type = *(VkDescriptorType*)&copy_src.type_at_end[sizeof(VkDescriptorDataEXT)];
+
+    switch (type) {
+        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLER:
+            pSampler = new VkSampler(*copy_src.pSampler);
+            break;
+        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+            pCombinedImageSampler = new VkDescriptorImageInfo(*copy_src.pCombinedImageSampler);
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+            pSampledImage = new VkDescriptorImageInfo(*copy_src.pSampledImage);
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+            pStorageImage = new VkDescriptorImageInfo(*copy_src.pStorageImage);
+            break;
+        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+            pInputAttachmentImage = new VkDescriptorImageInfo(*copy_src.pInputAttachmentImage);
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+            pUniformTexelBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pUniformTexelBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+            pStorageTexelBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pStorageTexelBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+            pUniformBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pUniformBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+            pStorageBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pStorageBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
+            accelerationStructure = copy_src.accelerationStructure;
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
+            accelerationStructure = copy_src.accelerationStructure;
+            break;
+        default:
+            break;
+    }
+
+    *pType = type;
+
+    return *this;
+}
+
+safe_VkDescriptorDataEXT::~safe_VkDescriptorDataEXT() {
+    VkDescriptorType& thisType = *(VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
+
+    switch (thisType) {
+        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLER:
+            delete pSampler;
+            pSampler = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+            delete pCombinedImageSampler;
+            pCombinedImageSampler = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+            delete pSampledImage;
+            pSampledImage = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+            delete pStorageImage;
+            pStorageImage = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+            delete pInputAttachmentImage;
+            pInputAttachmentImage = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+            delete pUniformTexelBuffer;
+            pUniformTexelBuffer = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+            delete pStorageTexelBuffer;
+            pStorageTexelBuffer = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+            delete pUniformBuffer;
+            pUniformBuffer = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+            delete pStorageBuffer;
+            pStorageBuffer = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
+            accelerationStructure = 0ull;
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
+            accelerationStructure = 0ull;
+            break;
+        default:
+            break;
+    }
+
+    thisType = VK_DESCRIPTOR_TYPE_MAX_ENUM;
+}
+
+void safe_VkDescriptorDataEXT::initialize(const VkDescriptorDataEXT* in_struct, const VkDescriptorType type,
+                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    VkDescriptorType& thisType = *(VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
+
+    switch (thisType) {
+        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLER:
+            delete pSampler;
+            pSampler = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+            delete pCombinedImageSampler;
+            pCombinedImageSampler = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+            delete pSampledImage;
+            pSampledImage = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+            delete pStorageImage;
+            pStorageImage = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+            delete pInputAttachmentImage;
+            pInputAttachmentImage = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+            delete pUniformTexelBuffer;
+            pUniformTexelBuffer = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+            delete pStorageTexelBuffer;
+            pStorageTexelBuffer = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+            delete pUniformBuffer;
+            pUniformBuffer = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+            delete pStorageBuffer;
+            pStorageBuffer = nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
+            accelerationStructure = 0ull;
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
+            accelerationStructure = 0ull;
+            break;
+        default:
+            break;
+    }
+
+    thisType = VK_DESCRIPTOR_TYPE_MAX_ENUM;
+    pSampler = nullptr;
+    pCombinedImageSampler = nullptr;
+    pInputAttachmentImage = nullptr;
+    pSampledImage = nullptr;
+    pStorageImage = nullptr;
+    pUniformTexelBuffer = nullptr;
+    pStorageTexelBuffer = nullptr;
+    pUniformBuffer = nullptr;
+    pStorageBuffer = nullptr;
+    accelerationStructure = in_struct->accelerationStructure;
+
+    VkDescriptorType* pType = (VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
+
+    switch (type) {
+        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLER:
+            pSampler = new VkSampler(*in_struct->pSampler);
+            break;
+        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+            pCombinedImageSampler = new VkDescriptorImageInfo(*in_struct->pCombinedImageSampler);
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+            pSampledImage = in_struct->pSampledImage ? new VkDescriptorImageInfo(*in_struct->pSampledImage) : nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+            pStorageImage = in_struct->pStorageImage ? new VkDescriptorImageInfo(*in_struct->pStorageImage) : nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+            pInputAttachmentImage = new VkDescriptorImageInfo(*in_struct->pInputAttachmentImage);
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+            pUniformTexelBuffer =
+                in_struct->pUniformTexelBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pUniformTexelBuffer) : nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+            pStorageTexelBuffer =
+                in_struct->pStorageTexelBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pStorageTexelBuffer) : nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+            pUniformBuffer = in_struct->pUniformBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pUniformBuffer) : nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+            pStorageBuffer = in_struct->pStorageBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pStorageBuffer) : nullptr;
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
+            accelerationStructure = in_struct->accelerationStructure;
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
+            accelerationStructure = in_struct->accelerationStructure;
+            break;
+        default:
+            break;
+    }
+
+    *pType = type;
+}
+
+void safe_VkDescriptorDataEXT::initialize(const safe_VkDescriptorDataEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    pSampler = nullptr;
+    pCombinedImageSampler = nullptr;
+    pInputAttachmentImage = nullptr;
+    pSampledImage = nullptr;
+    pStorageImage = nullptr;
+    pUniformTexelBuffer = nullptr;
+    pStorageTexelBuffer = nullptr;
+    pUniformBuffer = nullptr;
+    pStorageBuffer = nullptr;
+    accelerationStructure = copy_src->accelerationStructure;
+
+    VkDescriptorType* pType = (VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
+    VkDescriptorType type = *(VkDescriptorType*)&copy_src->type_at_end[sizeof(VkDescriptorDataEXT)];
+
+    switch (type) {
+        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLER:
+            pSampler = new VkSampler(*copy_src->pSampler);
+            break;
+        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+            pCombinedImageSampler = new VkDescriptorImageInfo(*copy_src->pCombinedImageSampler);
+            break;
+        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+            pSampledImage = new VkDescriptorImageInfo(*copy_src->pSampledImage);
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+            pStorageImage = new VkDescriptorImageInfo(*copy_src->pStorageImage);
+            break;
+        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+            pInputAttachmentImage = new VkDescriptorImageInfo(*copy_src->pInputAttachmentImage);
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+            pUniformTexelBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src->pUniformTexelBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+            pStorageTexelBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src->pStorageTexelBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+            pUniformBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src->pUniformBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+            pStorageBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src->pStorageBuffer);
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
+            accelerationStructure = copy_src->accelerationStructure;
+            break;
+        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
+            accelerationStructure = copy_src->accelerationStructure;
+            break;
+        default:
+            break;
+    }
+
+    *pType = type;
+}
+
 safe_VkGraphicsPipelineCreateInfo::safe_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo* in_struct,
                                                                      const bool uses_color_attachment,
                                                                      const bool uses_depthstencil_attachment,

From d5ada53a10dd2da9b777d9a1a852163905bb058f Mon Sep 17 00:00:00 2001
From: Spencer Fricke <115671160+spencer-lunarg@users.noreply.github.com>
Date: Thu, 25 Apr 2024 15:06:38 +0900
Subject: [PATCH 019/106] github: Use newer version of Python for MacOS Arm

---
 .github/workflows/ci.yml | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 13969d7..1a7efcc 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -21,9 +21,17 @@ jobs:
         os: [ ubuntu-20.04, ubuntu-22.04, windows-latest, macos-latest ]
     steps:
       - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
+      - name: Set up Python 3.8
+        if: matrix.os != 'macos-latest'
+        uses: actions/setup-python@v5
         with:
-          python-version: '3.8'
+          python-version: '3.8'      
+      # MacOS machine can run on arm64 and it doesn't support 3.8
+      - name: Set up Python 3.10.11
+        if: matrix.os == 'macos-latest'
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.10.11'
       - name: Test CMake Minimum
         if: matrix.os == 'ubuntu-20.04'
         uses: lukka/get-cmake@latest

From bbd4b7752f0a9e5f486fa55c9f2b80071ef99d01 Mon Sep 17 00:00:00 2001
From: "lauren n. liberda" <lauren@selfisekai.rocks>
Date: Thu, 25 Apr 2024 04:24:47 +0200
Subject: [PATCH 020/106] iwyu: missing #include <memory> for std::unique_ptr

---
 include/vulkan/utility/vk_small_containers.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/include/vulkan/utility/vk_small_containers.hpp b/include/vulkan/utility/vk_small_containers.hpp
index 0c0786d..71cae2f 100644
--- a/include/vulkan/utility/vk_small_containers.hpp
+++ b/include/vulkan/utility/vk_small_containers.hpp
@@ -9,6 +9,7 @@
 #pragma once
 
 #include <cassert>
+#include <memory>
 #include <unordered_map>
 #include <unordered_set>
 

From 8d8986262dd23bb55e0e4770f08818546c4393b1 Mon Sep 17 00:00:00 2001
From: spencer-lunarg <spencer@lunarg.com>
Date: Thu, 25 Apr 2024 05:49:14 +0900
Subject: [PATCH 021/106] safestruct: Remove safe_VkDescriptorDataEXT

---
 include/vulkan/utility/vk_safe_struct.hpp   |  24 +-
 scripts/generators/safe_struct_generator.py |   8 +-
 src/vulkan/vk_safe_struct_ext.cpp           |  12 +-
 src/vulkan/vk_safe_struct_manual.cpp        | 484 --------------------
 4 files changed, 9 insertions(+), 519 deletions(-)

diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index 4efcdcf..d8dcb9a 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -13494,33 +13494,11 @@ struct safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT {
         return reinterpret_cast<VkDescriptorBufferBindingPushDescriptorBufferHandleEXT const*>(this);
     }
 };
-union safe_VkDescriptorDataEXT {
-    const VkSampler* pSampler{};
-    const VkDescriptorImageInfo* pCombinedImageSampler;
-    const VkDescriptorImageInfo* pInputAttachmentImage;
-    const VkDescriptorImageInfo* pSampledImage;
-    const VkDescriptorImageInfo* pStorageImage;
-    safe_VkDescriptorAddressInfoEXT* pUniformTexelBuffer;
-    safe_VkDescriptorAddressInfoEXT* pStorageTexelBuffer;
-    safe_VkDescriptorAddressInfoEXT* pUniformBuffer;
-    safe_VkDescriptorAddressInfoEXT* pStorageBuffer;
-    VkDeviceAddress accelerationStructure;
-    char type_at_end[sizeof(VkDescriptorDataEXT) + sizeof(VkDescriptorGetInfoEXT::type)];
-    safe_VkDescriptorDataEXT(const VkDescriptorDataEXT* in_struct, const VkDescriptorType type, PNextCopyState* copy_state = {});
-    safe_VkDescriptorDataEXT(const safe_VkDescriptorDataEXT& copy_src);
-    safe_VkDescriptorDataEXT& operator=(const safe_VkDescriptorDataEXT& copy_src);
-    safe_VkDescriptorDataEXT();
-    ~safe_VkDescriptorDataEXT();
-    void initialize(const VkDescriptorDataEXT* in_struct, const VkDescriptorType type, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkDescriptorDataEXT* copy_src, PNextCopyState* copy_state = {});
-    VkDescriptorDataEXT* ptr() { return reinterpret_cast<VkDescriptorDataEXT*>(this); }
-    VkDescriptorDataEXT const* ptr() const { return reinterpret_cast<VkDescriptorDataEXT const*>(this); }
-};
 struct safe_VkDescriptorGetInfoEXT {
     VkStructureType sType;
     const void* pNext{};
     VkDescriptorType type;
-    safe_VkDescriptorDataEXT data;
+    VkDescriptorDataEXT data;
 
     safe_VkDescriptorGetInfoEXT(const VkDescriptorGetInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
     safe_VkDescriptorGetInfoEXT(const safe_VkDescriptorGetInfoEXT& copy_src);
diff --git a/scripts/generators/safe_struct_generator.py b/scripts/generators/safe_struct_generator.py
index 8ce9a2a..b893877 100644
--- a/scripts/generators/safe_struct_generator.py
+++ b/scripts/generators/safe_struct_generator.py
@@ -80,9 +80,6 @@ class SafeStructOutputGenerator(BaseGenerator):
             # vku::safe::AccelerationStructureGeometryKHR needs to know if we're doing a host or device build
             'VkAccelerationStructureGeometryKHR' :
                 ', const bool is_host, const VkAccelerationStructureBuildRangeInfoKHR *build_range_info',
-            # vku::safe::DescriptorDataEXT needs to know what field of union is intialized
-            'VkDescriptorDataEXT' :
-                ', const VkDescriptorType type',
         }
 
     # Determine if a structure needs a safe_struct helper function
@@ -90,6 +87,8 @@ class SafeStructOutputGenerator(BaseGenerator):
     def needSafeStruct(self, struct: Struct) -> bool:
         if struct.name in self.no_autogen:
             return False
+        if struct.name in self.union_of_pointers:
+            return False
         if 'VkBase' in struct.name:
             return False #  Ingore structs like VkBaseOutStructure
         if struct.sType is not None:
@@ -192,9 +191,6 @@ class SafeStructOutputGenerator(BaseGenerator):
                 else:
                     out.append(f'{member.cDeclaration}{initialize};\n')
 
-            if (struct.name == 'VkDescriptorDataEXT'):
-                out.append('char type_at_end[sizeof(VkDescriptorDataEXT)+sizeof(VkDescriptorGetInfoEXT::type)];')
-
             constructParam = self.custom_construct_params.get(struct.name, '')
             out.append(f'''
                 {safe_name}(const {struct.name}* in_struct{constructParam}, PNextCopyState* copy_state = {{}}{copy_pnext});
diff --git a/src/vulkan/vk_safe_struct_ext.cpp b/src/vulkan/vk_safe_struct_ext.cpp
index 0f65c58..a399902 100644
--- a/src/vulkan/vk_safe_struct_ext.cpp
+++ b/src/vulkan/vk_safe_struct_ext.cpp
@@ -9179,19 +9179,19 @@ void safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT::initialize(
 
 safe_VkDescriptorGetInfoEXT::safe_VkDescriptorGetInfoEXT(const VkDescriptorGetInfoEXT* in_struct,
                                                          [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), type(in_struct->type), data(&in_struct->data, in_struct->type) {
+    : sType(in_struct->sType), type(in_struct->type), data(in_struct->data) {
     if (copy_pnext) {
         pNext = SafePnextCopy(in_struct->pNext, copy_state);
     }
 }
 
 safe_VkDescriptorGetInfoEXT::safe_VkDescriptorGetInfoEXT()
-    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT), pNext(nullptr), type() {}
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT), pNext(nullptr), type(), data() {}
 
 safe_VkDescriptorGetInfoEXT::safe_VkDescriptorGetInfoEXT(const safe_VkDescriptorGetInfoEXT& copy_src) {
     sType = copy_src.sType;
     type = copy_src.type;
-    data.initialize(&copy_src.data);
+    data = copy_src.data;
     pNext = SafePnextCopy(copy_src.pNext);
 }
 
@@ -9202,7 +9202,7 @@ safe_VkDescriptorGetInfoEXT& safe_VkDescriptorGetInfoEXT::operator=(const safe_V
 
     sType = copy_src.sType;
     type = copy_src.type;
-    data.initialize(&copy_src.data);
+    data = copy_src.data;
     pNext = SafePnextCopy(copy_src.pNext);
 
     return *this;
@@ -9214,7 +9214,7 @@ void safe_VkDescriptorGetInfoEXT::initialize(const VkDescriptorGetInfoEXT* in_st
     FreePnextChain(pNext);
     sType = in_struct->sType;
     type = in_struct->type;
-    data.initialize(&in_struct->data, in_struct->type);
+    data = in_struct->data;
     pNext = SafePnextCopy(in_struct->pNext, copy_state);
 }
 
@@ -9222,7 +9222,7 @@ void safe_VkDescriptorGetInfoEXT::initialize(const safe_VkDescriptorGetInfoEXT*
                                              [[maybe_unused]] PNextCopyState* copy_state) {
     sType = copy_src->sType;
     type = copy_src->type;
-    data.initialize(&copy_src->data);
+    data = copy_src->data;
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
diff --git a/src/vulkan/vk_safe_struct_manual.cpp b/src/vulkan/vk_safe_struct_manual.cpp
index 4e50f8a..e20dd9b 100644
--- a/src/vulkan/vk_safe_struct_manual.cpp
+++ b/src/vulkan/vk_safe_struct_manual.cpp
@@ -303,490 +303,6 @@ void safe_VkRayTracingPipelineCreateInfoCommon::initialize(const VkRayTracingPip
     safe_VkRayTracingPipelineCreateInfoKHR::initialize(pCreateInfo);
 }
 
-safe_VkDescriptorDataEXT::safe_VkDescriptorDataEXT(const VkDescriptorDataEXT* in_struct, const VkDescriptorType type,
-                                                   [[maybe_unused]] PNextCopyState* copy_state) {
-    VkDescriptorType* pType = (VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
-
-    switch (type) {
-        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLER:
-            pSampler = new VkSampler(*in_struct->pSampler);
-            break;
-        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
-            pCombinedImageSampler = new VkDescriptorImageInfo(*in_struct->pCombinedImageSampler);
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
-            pSampledImage = in_struct->pSampledImage ? new VkDescriptorImageInfo(*in_struct->pSampledImage) : nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
-            pStorageImage = in_struct->pStorageImage ? new VkDescriptorImageInfo(*in_struct->pStorageImage) : nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
-            pInputAttachmentImage = new VkDescriptorImageInfo(*in_struct->pInputAttachmentImage);
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
-            pUniformTexelBuffer =
-                in_struct->pUniformTexelBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pUniformTexelBuffer) : nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
-            pStorageTexelBuffer =
-                in_struct->pStorageTexelBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pStorageTexelBuffer) : nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
-            pUniformBuffer = in_struct->pUniformBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pUniformBuffer) : nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
-            pStorageBuffer = in_struct->pStorageBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pStorageBuffer) : nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
-            accelerationStructure = in_struct->accelerationStructure;
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
-            accelerationStructure = in_struct->accelerationStructure;
-            break;
-        default:
-            break;
-    }
-
-    *pType = type;
-}
-
-safe_VkDescriptorDataEXT::safe_VkDescriptorDataEXT() : type_at_end{0} {
-    VkDescriptorType* pType = (VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
-    *pType = VK_DESCRIPTOR_TYPE_MAX_ENUM;
-}
-
-safe_VkDescriptorDataEXT::safe_VkDescriptorDataEXT(const safe_VkDescriptorDataEXT& copy_src) {
-    pSampler = nullptr;
-    pCombinedImageSampler = nullptr;
-    pInputAttachmentImage = nullptr;
-    pSampledImage = nullptr;
-    pStorageImage = nullptr;
-    pUniformTexelBuffer = nullptr;
-    pStorageTexelBuffer = nullptr;
-    pUniformBuffer = nullptr;
-    pStorageBuffer = nullptr;
-    accelerationStructure = copy_src.accelerationStructure;
-
-    VkDescriptorType* pType = (VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
-    VkDescriptorType type = *(VkDescriptorType*)&copy_src.type_at_end[sizeof(VkDescriptorDataEXT)];
-
-    switch (type) {
-        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLER:
-            pSampler = new VkSampler(*copy_src.pSampler);
-            break;
-        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
-            pCombinedImageSampler = new VkDescriptorImageInfo(*copy_src.pCombinedImageSampler);
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
-            pSampledImage = new VkDescriptorImageInfo(*copy_src.pSampledImage);
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
-            pStorageImage = new VkDescriptorImageInfo(*copy_src.pStorageImage);
-            break;
-        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
-            pInputAttachmentImage = new VkDescriptorImageInfo(*copy_src.pInputAttachmentImage);
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
-            pUniformTexelBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pUniformTexelBuffer);
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
-            pStorageTexelBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pStorageTexelBuffer);
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
-            pUniformBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pUniformBuffer);
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
-            pStorageBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pStorageBuffer);
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
-            accelerationStructure = copy_src.accelerationStructure;
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
-            accelerationStructure = copy_src.accelerationStructure;
-            break;
-        default:
-            break;
-    }
-
-    *pType = type;
-}
-
-safe_VkDescriptorDataEXT& safe_VkDescriptorDataEXT::operator=(const safe_VkDescriptorDataEXT& copy_src) {
-    if (&copy_src == this) return *this;
-
-    VkDescriptorType& thisType = *(VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
-
-    switch (thisType) {
-        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLER:
-            delete pSampler;
-            pSampler = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
-            delete pCombinedImageSampler;
-            pCombinedImageSampler = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
-            delete pSampledImage;
-            pSampledImage = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
-            delete pStorageImage;
-            pStorageImage = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
-            delete pInputAttachmentImage;
-            pInputAttachmentImage = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
-            delete pUniformTexelBuffer;
-            pUniformTexelBuffer = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
-            delete pStorageTexelBuffer;
-            pStorageTexelBuffer = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
-            delete pUniformBuffer;
-            pUniformBuffer = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
-            delete pStorageBuffer;
-            pStorageBuffer = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
-            accelerationStructure = 0ull;
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
-            accelerationStructure = 0ull;
-            break;
-        default:
-            break;
-    }
-
-    thisType = VK_DESCRIPTOR_TYPE_MAX_ENUM;
-
-    pSampler = nullptr;
-    pCombinedImageSampler = nullptr;
-    pInputAttachmentImage = nullptr;
-    pSampledImage = nullptr;
-    pStorageImage = nullptr;
-    pUniformTexelBuffer = nullptr;
-    pStorageTexelBuffer = nullptr;
-    pUniformBuffer = nullptr;
-    pStorageBuffer = nullptr;
-    accelerationStructure = copy_src.accelerationStructure;
-
-    VkDescriptorType* pType = (VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
-    VkDescriptorType type = *(VkDescriptorType*)&copy_src.type_at_end[sizeof(VkDescriptorDataEXT)];
-
-    switch (type) {
-        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLER:
-            pSampler = new VkSampler(*copy_src.pSampler);
-            break;
-        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
-            pCombinedImageSampler = new VkDescriptorImageInfo(*copy_src.pCombinedImageSampler);
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
-            pSampledImage = new VkDescriptorImageInfo(*copy_src.pSampledImage);
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
-            pStorageImage = new VkDescriptorImageInfo(*copy_src.pStorageImage);
-            break;
-        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
-            pInputAttachmentImage = new VkDescriptorImageInfo(*copy_src.pInputAttachmentImage);
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
-            pUniformTexelBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pUniformTexelBuffer);
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
-            pStorageTexelBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pStorageTexelBuffer);
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
-            pUniformBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pUniformBuffer);
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
-            pStorageBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src.pStorageBuffer);
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
-            accelerationStructure = copy_src.accelerationStructure;
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
-            accelerationStructure = copy_src.accelerationStructure;
-            break;
-        default:
-            break;
-    }
-
-    *pType = type;
-
-    return *this;
-}
-
-safe_VkDescriptorDataEXT::~safe_VkDescriptorDataEXT() {
-    VkDescriptorType& thisType = *(VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
-
-    switch (thisType) {
-        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLER:
-            delete pSampler;
-            pSampler = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
-            delete pCombinedImageSampler;
-            pCombinedImageSampler = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
-            delete pSampledImage;
-            pSampledImage = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
-            delete pStorageImage;
-            pStorageImage = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
-            delete pInputAttachmentImage;
-            pInputAttachmentImage = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
-            delete pUniformTexelBuffer;
-            pUniformTexelBuffer = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
-            delete pStorageTexelBuffer;
-            pStorageTexelBuffer = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
-            delete pUniformBuffer;
-            pUniformBuffer = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
-            delete pStorageBuffer;
-            pStorageBuffer = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
-            accelerationStructure = 0ull;
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
-            accelerationStructure = 0ull;
-            break;
-        default:
-            break;
-    }
-
-    thisType = VK_DESCRIPTOR_TYPE_MAX_ENUM;
-}
-
-void safe_VkDescriptorDataEXT::initialize(const VkDescriptorDataEXT* in_struct, const VkDescriptorType type,
-                                          [[maybe_unused]] PNextCopyState* copy_state) {
-    VkDescriptorType& thisType = *(VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
-
-    switch (thisType) {
-        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLER:
-            delete pSampler;
-            pSampler = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
-            delete pCombinedImageSampler;
-            pCombinedImageSampler = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
-            delete pSampledImage;
-            pSampledImage = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
-            delete pStorageImage;
-            pStorageImage = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
-            delete pInputAttachmentImage;
-            pInputAttachmentImage = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
-            delete pUniformTexelBuffer;
-            pUniformTexelBuffer = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
-            delete pStorageTexelBuffer;
-            pStorageTexelBuffer = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
-            delete pUniformBuffer;
-            pUniformBuffer = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
-            delete pStorageBuffer;
-            pStorageBuffer = nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
-            accelerationStructure = 0ull;
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
-            accelerationStructure = 0ull;
-            break;
-        default:
-            break;
-    }
-
-    thisType = VK_DESCRIPTOR_TYPE_MAX_ENUM;
-    pSampler = nullptr;
-    pCombinedImageSampler = nullptr;
-    pInputAttachmentImage = nullptr;
-    pSampledImage = nullptr;
-    pStorageImage = nullptr;
-    pUniformTexelBuffer = nullptr;
-    pStorageTexelBuffer = nullptr;
-    pUniformBuffer = nullptr;
-    pStorageBuffer = nullptr;
-    accelerationStructure = in_struct->accelerationStructure;
-
-    VkDescriptorType* pType = (VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
-
-    switch (type) {
-        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLER:
-            pSampler = new VkSampler(*in_struct->pSampler);
-            break;
-        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
-            pCombinedImageSampler = new VkDescriptorImageInfo(*in_struct->pCombinedImageSampler);
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
-            pSampledImage = in_struct->pSampledImage ? new VkDescriptorImageInfo(*in_struct->pSampledImage) : nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
-            pStorageImage = in_struct->pStorageImage ? new VkDescriptorImageInfo(*in_struct->pStorageImage) : nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
-            pInputAttachmentImage = new VkDescriptorImageInfo(*in_struct->pInputAttachmentImage);
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
-            pUniformTexelBuffer =
-                in_struct->pUniformTexelBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pUniformTexelBuffer) : nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
-            pStorageTexelBuffer =
-                in_struct->pStorageTexelBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pStorageTexelBuffer) : nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
-            pUniformBuffer = in_struct->pUniformBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pUniformBuffer) : nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
-            pStorageBuffer = in_struct->pStorageBuffer ? new safe_VkDescriptorAddressInfoEXT(in_struct->pStorageBuffer) : nullptr;
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
-            accelerationStructure = in_struct->accelerationStructure;
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
-            accelerationStructure = in_struct->accelerationStructure;
-            break;
-        default:
-            break;
-    }
-
-    *pType = type;
-}
-
-void safe_VkDescriptorDataEXT::initialize(const safe_VkDescriptorDataEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
-    pSampler = nullptr;
-    pCombinedImageSampler = nullptr;
-    pInputAttachmentImage = nullptr;
-    pSampledImage = nullptr;
-    pStorageImage = nullptr;
-    pUniformTexelBuffer = nullptr;
-    pStorageTexelBuffer = nullptr;
-    pUniformBuffer = nullptr;
-    pStorageBuffer = nullptr;
-    accelerationStructure = copy_src->accelerationStructure;
-
-    VkDescriptorType* pType = (VkDescriptorType*)&type_at_end[sizeof(VkDescriptorDataEXT)];
-    VkDescriptorType type = *(VkDescriptorType*)&copy_src->type_at_end[sizeof(VkDescriptorDataEXT)];
-
-    switch (type) {
-        case VK_DESCRIPTOR_TYPE_MAX_ENUM:
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLER:
-            pSampler = new VkSampler(*copy_src->pSampler);
-            break;
-        case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
-            pCombinedImageSampler = new VkDescriptorImageInfo(*copy_src->pCombinedImageSampler);
-            break;
-        case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
-            pSampledImage = new VkDescriptorImageInfo(*copy_src->pSampledImage);
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
-            pStorageImage = new VkDescriptorImageInfo(*copy_src->pStorageImage);
-            break;
-        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
-            pInputAttachmentImage = new VkDescriptorImageInfo(*copy_src->pInputAttachmentImage);
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
-            pUniformTexelBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src->pUniformTexelBuffer);
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
-            pStorageTexelBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src->pStorageTexelBuffer);
-            break;
-        case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
-            pUniformBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src->pUniformBuffer);
-            break;
-        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
-            pStorageBuffer = new safe_VkDescriptorAddressInfoEXT(*copy_src->pStorageBuffer);
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
-            accelerationStructure = copy_src->accelerationStructure;
-            break;
-        case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
-            accelerationStructure = copy_src->accelerationStructure;
-            break;
-        default:
-            break;
-    }
-
-    *pType = type;
-}
-
 safe_VkGraphicsPipelineCreateInfo::safe_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo* in_struct,
                                                                      const bool uses_color_attachment,
                                                                      const bool uses_depthstencil_attachment,

From 68780d9b8c4dd256e55a3df60969970cb29911ce Mon Sep 17 00:00:00 2001
From: spencer-lunarg <spencer@lunarg.com>
Date: Mon, 29 Apr 2024 09:39:14 +0900
Subject: [PATCH 022/106] scripts: Fix Pipeline dynamic rasterization discard
 logic

---
 src/vulkan/vk_safe_struct_manual.cpp | 25 ++++++++++---------------
 1 file changed, 10 insertions(+), 15 deletions(-)

diff --git a/src/vulkan/vk_safe_struct_manual.cpp b/src/vulkan/vk_safe_struct_manual.cpp
index e20dd9b..e585088 100644
--- a/src/vulkan/vk_safe_struct_manual.cpp
+++ b/src/vulkan/vk_safe_struct_manual.cpp
@@ -360,9 +360,8 @@ safe_VkGraphicsPipelineCreateInfo::safe_VkGraphicsPipelineCreateInfo(const VkGra
             if (in_struct->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT)
                 is_dynamic_has_rasterization = true;
     }
-    const bool has_rasterization = in_struct->pRasterizationState
-                                       ? (is_dynamic_has_rasterization || !in_struct->pRasterizationState->rasterizerDiscardEnable)
-                                       : false;
+    const bool has_rasterization = is_dynamic_has_rasterization ||
+                                   (in_struct->pRasterizationState && !in_struct->pRasterizationState->rasterizerDiscardEnable);
     if (in_struct->pViewportState && (has_rasterization || is_graphics_library)) {
         bool is_dynamic_viewports = false;
         bool is_dynamic_scissors = false;
@@ -473,9 +472,8 @@ safe_VkGraphicsPipelineCreateInfo::safe_VkGraphicsPipelineCreateInfo(const safe_
             if (copy_src.pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT)
                 is_dynamic_has_rasterization = true;
     }
-    const bool has_rasterization = copy_src.pRasterizationState
-                                       ? (is_dynamic_has_rasterization || !copy_src.pRasterizationState->rasterizerDiscardEnable)
-                                       : false;
+    const bool has_rasterization =
+        is_dynamic_has_rasterization || (copy_src.pRasterizationState && !copy_src.pRasterizationState->rasterizerDiscardEnable);
     if (copy_src.pViewportState && (has_rasterization || is_graphics_library)) {
         pViewportState = new safe_VkPipelineViewportStateCreateInfo(*copy_src.pViewportState);
     } else
@@ -568,9 +566,8 @@ safe_VkGraphicsPipelineCreateInfo& safe_VkGraphicsPipelineCreateInfo::operator=(
             if (copy_src.pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT)
                 is_dynamic_has_rasterization = true;
     }
-    const bool has_rasterization = copy_src.pRasterizationState
-                                       ? (is_dynamic_has_rasterization || !copy_src.pRasterizationState->rasterizerDiscardEnable)
-                                       : false;
+    const bool has_rasterization =
+        is_dynamic_has_rasterization || (copy_src.pRasterizationState && !copy_src.pRasterizationState->rasterizerDiscardEnable);
     if (copy_src.pViewportState && (has_rasterization || is_graphics_library)) {
         pViewportState = new safe_VkPipelineViewportStateCreateInfo(*copy_src.pViewportState);
     } else
@@ -679,9 +676,8 @@ void safe_VkGraphicsPipelineCreateInfo::initialize(const VkGraphicsPipelineCreat
             if (in_struct->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT)
                 is_dynamic_has_rasterization = true;
     }
-    const bool has_rasterization = in_struct->pRasterizationState
-                                       ? (is_dynamic_has_rasterization || !in_struct->pRasterizationState->rasterizerDiscardEnable)
-                                       : false;
+    const bool has_rasterization = is_dynamic_has_rasterization ||
+                                   (in_struct->pRasterizationState && !in_struct->pRasterizationState->rasterizerDiscardEnable);
     if (in_struct->pViewportState && (has_rasterization || is_graphics_library)) {
         bool is_dynamic_viewports = false;
         bool is_dynamic_scissors = false;
@@ -772,9 +768,8 @@ void safe_VkGraphicsPipelineCreateInfo::initialize(const safe_VkGraphicsPipeline
             if (copy_src->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT)
                 is_dynamic_has_rasterization = true;
     }
-    const bool has_rasterization = copy_src->pRasterizationState
-                                       ? (is_dynamic_has_rasterization || !copy_src->pRasterizationState->rasterizerDiscardEnable)
-                                       : false;
+    const bool has_rasterization =
+        is_dynamic_has_rasterization || (copy_src->pRasterizationState && !copy_src->pRasterizationState->rasterizerDiscardEnable);
     if (copy_src->pViewportState && (has_rasterization || is_graphics_library)) {
         pViewportState = new safe_VkPipelineViewportStateCreateInfo(*copy_src->pViewportState);
     } else

From ad7f699a7b2b5deb66eb3de19f24aa33597ed65b Mon Sep 17 00:00:00 2001
From: spencer-lunarg <spencer@lunarg.com>
Date: Tue, 30 Apr 2024 17:01:35 +0900
Subject: [PATCH 023/106] scripts: Fix logic for ignoring pipe state

---
 src/vulkan/vk_safe_struct_manual.cpp | 22 ++++++++++++++++------
 1 file changed, 16 insertions(+), 6 deletions(-)

diff --git a/src/vulkan/vk_safe_struct_manual.cpp b/src/vulkan/vk_safe_struct_manual.cpp
index e585088..f7478a3 100644
--- a/src/vulkan/vk_safe_struct_manual.cpp
+++ b/src/vulkan/vk_safe_struct_manual.cpp
@@ -345,11 +345,15 @@ safe_VkGraphicsPipelineCreateInfo::safe_VkGraphicsPipelineCreateInfo(const VkGra
     else
         pInputAssemblyState = nullptr;
     bool has_tessellation_stage = false;
-    if (stageCount && pStages)
-        for (uint32_t i = 0; i < stageCount && !has_tessellation_stage; ++i)
+    bool has_fragment_stage = false;
+    if (stageCount && pStages) {
+        for (uint32_t i = 0; i < stageCount; ++i) {
             if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT ||
                 pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)
                 has_tessellation_stage = true;
+            if (pStages[i].stage == VK_SHADER_STAGE_FRAGMENT_BIT) has_fragment_stage = true;
+        }
+    }
     if (in_struct->pTessellationState && has_tessellation_stage)
         pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(in_struct->pTessellationState);
     else
@@ -379,7 +383,8 @@ safe_VkGraphicsPipelineCreateInfo::safe_VkGraphicsPipelineCreateInfo(const VkGra
         pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(in_struct->pRasterizationState);
     else
         pRasterizationState = nullptr;
-    if (in_struct->pMultisampleState && (renderPass != VK_NULL_HANDLE || has_rasterization || is_graphics_library))
+    if (in_struct->pMultisampleState &&
+        ((has_rasterization && (renderPass != VK_NULL_HANDLE || has_fragment_stage)) || is_graphics_library))
         pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(in_struct->pMultisampleState);
     else
         pMultisampleState = nullptr;  // original pMultisampleState pointer ignored
@@ -661,11 +666,15 @@ void safe_VkGraphicsPipelineCreateInfo::initialize(const VkGraphicsPipelineCreat
     else
         pInputAssemblyState = nullptr;
     bool has_tessellation_stage = false;
-    if (stageCount && pStages)
-        for (uint32_t i = 0; i < stageCount && !has_tessellation_stage; ++i)
+    bool has_fragment_stage = false;
+    if (stageCount && pStages) {
+        for (uint32_t i = 0; i < stageCount; ++i) {
             if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT ||
                 pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)
                 has_tessellation_stage = true;
+            if (pStages[i].stage == VK_SHADER_STAGE_FRAGMENT_BIT) has_fragment_stage = true;
+        }
+    }
     if (in_struct->pTessellationState && has_tessellation_stage)
         pTessellationState = new safe_VkPipelineTessellationStateCreateInfo(in_struct->pTessellationState);
     else
@@ -695,7 +704,8 @@ void safe_VkGraphicsPipelineCreateInfo::initialize(const VkGraphicsPipelineCreat
         pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(in_struct->pRasterizationState);
     else
         pRasterizationState = nullptr;
-    if (in_struct->pMultisampleState && (renderPass != VK_NULL_HANDLE || has_rasterization || is_graphics_library))
+    if (in_struct->pMultisampleState &&
+        ((has_rasterization && (renderPass != VK_NULL_HANDLE || has_fragment_stage)) || is_graphics_library))
         pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(in_struct->pMultisampleState);
     else
         pMultisampleState = nullptr;  // original pMultisampleState pointer ignored

From 358a107a6ff284906dcccbabe5b0183c03fd85b6 Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Wed, 8 May 2024 08:24:08 -0700
Subject: [PATCH 024/106] build: Update to header 1.3.284

---
 include/vulkan/utility/vk_safe_struct.hpp   |  43 ++++++++
 include/vulkan/utility/vk_struct_helper.hpp |   2 +
 include/vulkan/vk_enum_string_helper.h      |   4 +
 scripts/known_good.json                     |   2 +-
 src/vulkan/vk_safe_struct_ext.cpp           | 104 ++++++++++++++++++++
 src/vulkan/vk_safe_struct_utils.cpp         |  12 +++
 6 files changed, 166 insertions(+), 1 deletion(-)

diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index d8dcb9a..50df585 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -17118,6 +17118,49 @@ struct safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV {
         return reinterpret_cast<VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV const*>(this);
     }
 };
+struct safe_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 legacyVertexAttributes;
+
+    safe_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT(const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT* in_struct,
+                                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT(const safe_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT();
+    ~safe_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT();
+    void initialize(const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 nativeUnalignedPerformance;
+
+    safe_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT(const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT* in_struct,
+                                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT(
+        const safe_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT& operator=(
+        const safe_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT();
+    ~safe_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT();
+    void initialize(const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT const*>(this);
+    }
+};
 struct safe_VkLayerSettingEXT {
     const char* pLayerName{};
     const char* pSettingName{};
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index 55dda0e..b0083a3 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -902,6 +902,8 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingInvocation
 template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT; }
 template <> inline VkStructureType GetSType<VkLayerSettingsCreateInfoEXT>() { return VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index 8026787..e1f9bd7 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -1778,6 +1778,10 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT";
         case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT:
             return "VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT";
         case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT:
             return "VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 58987c8..2fac837 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.3.283"
+            "commit": "v1.3.284"
         },
         {
             "name": "googletest",
diff --git a/src/vulkan/vk_safe_struct_ext.cpp b/src/vulkan/vk_safe_struct_ext.cpp
index a399902..0c682ec 100644
--- a/src/vulkan/vk_safe_struct_ext.cpp
+++ b/src/vulkan/vk_safe_struct_ext.cpp
@@ -14788,6 +14788,110 @@ void safe_VkShaderCreateInfoEXT::initialize(const safe_VkShaderCreateInfoEXT* co
     if (copy_src->pSpecializationInfo) pSpecializationInfo = new safe_VkSpecializationInfo(*copy_src->pSpecializationInfo);
 }
 
+safe_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT::safe_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT(
+    const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), legacyVertexAttributes(in_struct->legacyVertexAttributes) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT::safe_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT), pNext(nullptr), legacyVertexAttributes() {}
+
+safe_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT::safe_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT(
+    const safe_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    legacyVertexAttributes = copy_src.legacyVertexAttributes;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT& safe_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    legacyVertexAttributes = copy_src.legacyVertexAttributes;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT::~safe_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT::initialize(
+    const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    legacyVertexAttributes = in_struct->legacyVertexAttributes;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    legacyVertexAttributes = copy_src->legacyVertexAttributes;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT::safe_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT(
+    const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), nativeUnalignedPerformance(in_struct->nativeUnalignedPerformance) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT::safe_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT),
+      pNext(nullptr),
+      nativeUnalignedPerformance() {}
+
+safe_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT::safe_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT(
+    const safe_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    nativeUnalignedPerformance = copy_src.nativeUnalignedPerformance;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT& safe_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT::operator=(
+    const safe_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    nativeUnalignedPerformance = copy_src.nativeUnalignedPerformance;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT::~safe_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT::initialize(
+    const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    nativeUnalignedPerformance = in_struct->nativeUnalignedPerformance;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT::initialize(
+    const safe_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    nativeUnalignedPerformance = copy_src->nativeUnalignedPerformance;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkLayerSettingEXT::safe_VkLayerSettingEXT(const VkLayerSettingEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state)
     : type(in_struct->type), valueCount(in_struct->valueCount), pValues(in_struct->pValues) {
     pLayerName = SafeStringCopy(in_struct->pLayerName);
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index 063c311..7c45d7d 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -1696,6 +1696,12 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV:
                 safe_pNext = new safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV(reinterpret_cast<const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT:
                 safe_pNext = new safe_VkLayerSettingsCreateInfoEXT(reinterpret_cast<const VkLayerSettingsCreateInfoEXT *>(pNext), copy_state, false);
                 break;
@@ -3492,6 +3498,12 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV:
             delete reinterpret_cast<const safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT *>(header);
+            break;
         case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT:
             delete reinterpret_cast<const safe_VkLayerSettingsCreateInfoEXT *>(header);
             break;

From 777358fdad21132866be4a835327fbc28eabc1a4 Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Mon, 13 May 2024 10:25:37 -0700
Subject: [PATCH 025/106] build: Update to header 1.3.285

---
 include/vulkan/utility/vk_safe_struct.hpp   |  61 ++++++++
 include/vulkan/utility/vk_struct_helper.hpp |   3 +
 include/vulkan/vk_enum_string_helper.h      |   6 +
 scripts/known_good.json                     |   2 +-
 src/vulkan/vk_safe_struct_utils.cpp         |  18 +++
 src/vulkan/vk_safe_struct_vendor.cpp        | 152 ++++++++++++++++++++
 6 files changed, 241 insertions(+), 1 deletion(-)

diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index 50df585..5a1f559 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -17915,6 +17915,67 @@ struct safe_VkPhysicalDeviceRayTracingValidationFeaturesNV {
         return reinterpret_cast<VkPhysicalDeviceRayTracingValidationFeaturesNV const*>(this);
     }
 };
+struct safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 imageAlignmentControl;
+
+    safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA(const VkPhysicalDeviceImageAlignmentControlFeaturesMESA* in_struct,
+                                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA(const safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA& copy_src);
+    safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA& operator=(
+        const safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA& copy_src);
+    safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA();
+    ~safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA();
+    void initialize(const VkPhysicalDeviceImageAlignmentControlFeaturesMESA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceImageAlignmentControlFeaturesMESA* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceImageAlignmentControlFeaturesMESA*>(this);
+    }
+    VkPhysicalDeviceImageAlignmentControlFeaturesMESA const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceImageAlignmentControlFeaturesMESA const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t supportedImageAlignmentMask;
+
+    safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA(const VkPhysicalDeviceImageAlignmentControlPropertiesMESA* in_struct,
+                                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA(
+        const safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA& copy_src);
+    safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA& operator=(
+        const safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA& copy_src);
+    safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA();
+    ~safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA();
+    void initialize(const VkPhysicalDeviceImageAlignmentControlPropertiesMESA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceImageAlignmentControlPropertiesMESA* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceImageAlignmentControlPropertiesMESA*>(this);
+    }
+    VkPhysicalDeviceImageAlignmentControlPropertiesMESA const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceImageAlignmentControlPropertiesMESA const*>(this);
+    }
+};
+struct safe_VkImageAlignmentControlCreateInfoMESA {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t maximumRequestedAlignment;
+
+    safe_VkImageAlignmentControlCreateInfoMESA(const VkImageAlignmentControlCreateInfoMESA* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkImageAlignmentControlCreateInfoMESA(const safe_VkImageAlignmentControlCreateInfoMESA& copy_src);
+    safe_VkImageAlignmentControlCreateInfoMESA& operator=(const safe_VkImageAlignmentControlCreateInfoMESA& copy_src);
+    safe_VkImageAlignmentControlCreateInfoMESA();
+    ~safe_VkImageAlignmentControlCreateInfoMESA();
+    void initialize(const VkImageAlignmentControlCreateInfoMESA* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageAlignmentControlCreateInfoMESA* copy_src, PNextCopyState* copy_state = {});
+    VkImageAlignmentControlCreateInfoMESA* ptr() { return reinterpret_cast<VkImageAlignmentControlCreateInfoMESA*>(this); }
+    VkImageAlignmentControlCreateInfoMESA const* ptr() const {
+        return reinterpret_cast<VkImageAlignmentControlCreateInfoMESA const*>(this);
+    }
+};
 struct safe_VkAccelerationStructureGeometryTrianglesDataKHR {
     VkStructureType sType;
     const void* pNext{};
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index b0083a3..65f0958 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -943,6 +943,9 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceDescriptorPoolOveral
 template <> inline VkStructureType GetSType<VkPhysicalDeviceRawAccessChainsFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingValidationFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceImageAlignmentControlFeaturesMESA>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceImageAlignmentControlPropertiesMESA>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA; }
+template <> inline VkStructureType GetSType<VkImageAlignmentControlCreateInfoMESA>() { return VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryTrianglesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryAabbsDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryInstancesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index e1f9bd7..b7f3425 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -1914,6 +1914,12 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA";
+        case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA:
+            return "VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA";
         default:
             return "Unhandled VkStructureType";
     }
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 2fac837..0035e0d 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.3.284"
+            "commit": "v1.3.285"
         },
         {
             "name": "googletest",
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index 7c45d7d..5406ced 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -1794,6 +1794,15 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
                 safe_pNext = new safe_VkPhysicalDeviceRayTracingValidationFeaturesNV(reinterpret_cast<const VkPhysicalDeviceRayTracingValidationFeaturesNV *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA:
+                safe_pNext = new safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA(reinterpret_cast<const VkPhysicalDeviceImageAlignmentControlFeaturesMESA *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA:
+                safe_pNext = new safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA(reinterpret_cast<const VkPhysicalDeviceImageAlignmentControlPropertiesMESA *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA:
+                safe_pNext = new safe_VkImageAlignmentControlCreateInfoMESA(reinterpret_cast<const VkImageAlignmentControlCreateInfoMESA *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
                 safe_pNext = new safe_VkWriteDescriptorSetAccelerationStructureKHR(reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR *>(pNext), copy_state, false);
                 break;
@@ -3596,6 +3605,15 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
             delete reinterpret_cast<const safe_VkPhysicalDeviceRayTracingValidationFeaturesNV *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA:
+            delete reinterpret_cast<const safe_VkImageAlignmentControlCreateInfoMESA *>(header);
+            break;
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
             delete reinterpret_cast<const safe_VkWriteDescriptorSetAccelerationStructureKHR *>(header);
             break;
diff --git a/src/vulkan/vk_safe_struct_vendor.cpp b/src/vulkan/vk_safe_struct_vendor.cpp
index 7896c22..e7b54d6 100644
--- a/src/vulkan/vk_safe_struct_vendor.cpp
+++ b/src/vulkan/vk_safe_struct_vendor.cpp
@@ -15118,6 +15118,158 @@ void safe_VkPhysicalDeviceRayTracingValidationFeaturesNV::initialize(
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA::safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA(
+    const VkPhysicalDeviceImageAlignmentControlFeaturesMESA* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), imageAlignmentControl(in_struct->imageAlignmentControl) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA::safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA), pNext(nullptr), imageAlignmentControl() {}
+
+safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA::safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA(
+    const safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA& copy_src) {
+    sType = copy_src.sType;
+    imageAlignmentControl = copy_src.imageAlignmentControl;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA& safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA::operator=(
+    const safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    imageAlignmentControl = copy_src.imageAlignmentControl;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA::~safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA::initialize(
+    const VkPhysicalDeviceImageAlignmentControlFeaturesMESA* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    imageAlignmentControl = in_struct->imageAlignmentControl;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA::initialize(
+    const safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imageAlignmentControl = copy_src->imageAlignmentControl;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA::safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA(
+    const VkPhysicalDeviceImageAlignmentControlPropertiesMESA* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), supportedImageAlignmentMask(in_struct->supportedImageAlignmentMask) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA::safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA),
+      pNext(nullptr),
+      supportedImageAlignmentMask() {}
+
+safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA::safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA(
+    const safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA& copy_src) {
+    sType = copy_src.sType;
+    supportedImageAlignmentMask = copy_src.supportedImageAlignmentMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA& safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA::operator=(
+    const safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    supportedImageAlignmentMask = copy_src.supportedImageAlignmentMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA::~safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA::initialize(
+    const VkPhysicalDeviceImageAlignmentControlPropertiesMESA* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    supportedImageAlignmentMask = in_struct->supportedImageAlignmentMask;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA::initialize(
+    const safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    supportedImageAlignmentMask = copy_src->supportedImageAlignmentMask;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkImageAlignmentControlCreateInfoMESA::safe_VkImageAlignmentControlCreateInfoMESA(
+    const VkImageAlignmentControlCreateInfoMESA* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), maximumRequestedAlignment(in_struct->maximumRequestedAlignment) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImageAlignmentControlCreateInfoMESA::safe_VkImageAlignmentControlCreateInfoMESA()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA), pNext(nullptr), maximumRequestedAlignment() {}
+
+safe_VkImageAlignmentControlCreateInfoMESA::safe_VkImageAlignmentControlCreateInfoMESA(
+    const safe_VkImageAlignmentControlCreateInfoMESA& copy_src) {
+    sType = copy_src.sType;
+    maximumRequestedAlignment = copy_src.maximumRequestedAlignment;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImageAlignmentControlCreateInfoMESA& safe_VkImageAlignmentControlCreateInfoMESA::operator=(
+    const safe_VkImageAlignmentControlCreateInfoMESA& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maximumRequestedAlignment = copy_src.maximumRequestedAlignment;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImageAlignmentControlCreateInfoMESA::~safe_VkImageAlignmentControlCreateInfoMESA() { FreePnextChain(pNext); }
+
+void safe_VkImageAlignmentControlCreateInfoMESA::initialize(const VkImageAlignmentControlCreateInfoMESA* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maximumRequestedAlignment = in_struct->maximumRequestedAlignment;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImageAlignmentControlCreateInfoMESA::initialize(const safe_VkImageAlignmentControlCreateInfoMESA* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maximumRequestedAlignment = copy_src->maximumRequestedAlignment;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 }  // namespace vku
 
 // NOLINTEND

From 810074ebb68dfec81dee79f279b78f88d6c5c24f Mon Sep 17 00:00:00 2001
From: spencer-lunarg <spencer@lunarg.com>
Date: Thu, 16 May 2024 12:53:18 +0900
Subject: [PATCH 026/106] safestruct: Fix pMultisampleState

---
 src/vulkan/vk_safe_struct_manual.cpp | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/src/vulkan/vk_safe_struct_manual.cpp b/src/vulkan/vk_safe_struct_manual.cpp
index f7478a3..ecbbb0f 100644
--- a/src/vulkan/vk_safe_struct_manual.cpp
+++ b/src/vulkan/vk_safe_struct_manual.cpp
@@ -345,13 +345,11 @@ safe_VkGraphicsPipelineCreateInfo::safe_VkGraphicsPipelineCreateInfo(const VkGra
     else
         pInputAssemblyState = nullptr;
     bool has_tessellation_stage = false;
-    bool has_fragment_stage = false;
     if (stageCount && pStages) {
         for (uint32_t i = 0; i < stageCount; ++i) {
             if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT ||
                 pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)
                 has_tessellation_stage = true;
-            if (pStages[i].stage == VK_SHADER_STAGE_FRAGMENT_BIT) has_fragment_stage = true;
         }
     }
     if (in_struct->pTessellationState && has_tessellation_stage)
@@ -383,8 +381,7 @@ safe_VkGraphicsPipelineCreateInfo::safe_VkGraphicsPipelineCreateInfo(const VkGra
         pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(in_struct->pRasterizationState);
     else
         pRasterizationState = nullptr;
-    if (in_struct->pMultisampleState &&
-        ((has_rasterization && (renderPass != VK_NULL_HANDLE || has_fragment_stage)) || is_graphics_library))
+    if (in_struct->pMultisampleState && (has_rasterization || is_graphics_library))
         pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(in_struct->pMultisampleState);
     else
         pMultisampleState = nullptr;  // original pMultisampleState pointer ignored
@@ -666,13 +663,11 @@ void safe_VkGraphicsPipelineCreateInfo::initialize(const VkGraphicsPipelineCreat
     else
         pInputAssemblyState = nullptr;
     bool has_tessellation_stage = false;
-    bool has_fragment_stage = false;
     if (stageCount && pStages) {
         for (uint32_t i = 0; i < stageCount; ++i) {
             if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT ||
                 pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)
                 has_tessellation_stage = true;
-            if (pStages[i].stage == VK_SHADER_STAGE_FRAGMENT_BIT) has_fragment_stage = true;
         }
     }
     if (in_struct->pTessellationState && has_tessellation_stage)
@@ -704,8 +699,7 @@ void safe_VkGraphicsPipelineCreateInfo::initialize(const VkGraphicsPipelineCreat
         pRasterizationState = new safe_VkPipelineRasterizationStateCreateInfo(in_struct->pRasterizationState);
     else
         pRasterizationState = nullptr;
-    if (in_struct->pMultisampleState &&
-        ((has_rasterization && (renderPass != VK_NULL_HANDLE || has_fragment_stage)) || is_graphics_library))
+    if (in_struct->pMultisampleState && (has_rasterization || is_graphics_library))
         pMultisampleState = new safe_VkPipelineMultisampleStateCreateInfo(in_struct->pMultisampleState);
     else
         pMultisampleState = nullptr;  // original pMultisampleState pointer ignored

From f6c54531066c6d28ef403b50ff9cff3ea195d28a Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 20 May 2024 15:16:13 +0000
Subject: [PATCH 027/106] build(deps): Bump jidicula/clang-format-action from
 4.11.0 to 4.12.0

Bumps [jidicula/clang-format-action](https://github.com/jidicula/clang-format-action) from 4.11.0 to 4.12.0.
- [Release notes](https://github.com/jidicula/clang-format-action/releases)
- [Commits](https://github.com/jidicula/clang-format-action/compare/v4.11.0...v4.12.0)

---
updated-dependencies:
- dependency-name: jidicula/clang-format-action
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 .github/workflows/format.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/format.yml b/.github/workflows/format.yml
index a20f0e3..9aa3182 100644
--- a/.github/workflows/format.yml
+++ b/.github/workflows/format.yml
@@ -28,7 +28,7 @@ jobs:
     steps:
     - uses: actions/checkout@v4
     - name: Run clang-format
-      uses: jidicula/clang-format-action@v4.11.0
+      uses: jidicula/clang-format-action@v4.12.0
       with:
         clang-format-version: '14'
         check-path: ${{ matrix.path }}

From 8bc338928b5c92489d953e049018eab2359d437a Mon Sep 17 00:00:00 2001
From: spencer-lunarg <spencer@lunarg.com>
Date: Sat, 25 May 2024 14:57:41 +0900
Subject: [PATCH 028/106] safestruct: Fix null pRasterizationState

---
 src/vulkan/vk_safe_struct_manual.cpp | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/src/vulkan/vk_safe_struct_manual.cpp b/src/vulkan/vk_safe_struct_manual.cpp
index ecbbb0f..76f13e5 100644
--- a/src/vulkan/vk_safe_struct_manual.cpp
+++ b/src/vulkan/vk_safe_struct_manual.cpp
@@ -362,8 +362,9 @@ safe_VkGraphicsPipelineCreateInfo::safe_VkGraphicsPipelineCreateInfo(const VkGra
             if (in_struct->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT)
                 is_dynamic_has_rasterization = true;
     }
+    // No pRasterizationState is same as dynamic, we assume rasterizerDiscardEnable is false
     const bool has_rasterization = is_dynamic_has_rasterization ||
-                                   (in_struct->pRasterizationState && !in_struct->pRasterizationState->rasterizerDiscardEnable);
+                                   (!in_struct->pRasterizationState || !in_struct->pRasterizationState->rasterizerDiscardEnable);
     if (in_struct->pViewportState && (has_rasterization || is_graphics_library)) {
         bool is_dynamic_viewports = false;
         bool is_dynamic_scissors = false;
@@ -474,8 +475,9 @@ safe_VkGraphicsPipelineCreateInfo::safe_VkGraphicsPipelineCreateInfo(const safe_
             if (copy_src.pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT)
                 is_dynamic_has_rasterization = true;
     }
+    // No pRasterizationState is same as dynamic, we assume rasterizerDiscardEnable is false
     const bool has_rasterization =
-        is_dynamic_has_rasterization || (copy_src.pRasterizationState && !copy_src.pRasterizationState->rasterizerDiscardEnable);
+        is_dynamic_has_rasterization || (!copy_src.pRasterizationState || !copy_src.pRasterizationState->rasterizerDiscardEnable);
     if (copy_src.pViewportState && (has_rasterization || is_graphics_library)) {
         pViewportState = new safe_VkPipelineViewportStateCreateInfo(*copy_src.pViewportState);
     } else
@@ -568,8 +570,9 @@ safe_VkGraphicsPipelineCreateInfo& safe_VkGraphicsPipelineCreateInfo::operator=(
             if (copy_src.pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT)
                 is_dynamic_has_rasterization = true;
     }
+    // No pRasterizationState is same as dynamic, we assume rasterizerDiscardEnable is false
     const bool has_rasterization =
-        is_dynamic_has_rasterization || (copy_src.pRasterizationState && !copy_src.pRasterizationState->rasterizerDiscardEnable);
+        is_dynamic_has_rasterization || (!copy_src.pRasterizationState || !copy_src.pRasterizationState->rasterizerDiscardEnable);
     if (copy_src.pViewportState && (has_rasterization || is_graphics_library)) {
         pViewportState = new safe_VkPipelineViewportStateCreateInfo(*copy_src.pViewportState);
     } else
@@ -680,8 +683,9 @@ void safe_VkGraphicsPipelineCreateInfo::initialize(const VkGraphicsPipelineCreat
             if (in_struct->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT)
                 is_dynamic_has_rasterization = true;
     }
+    // No pRasterizationState is same as dynamic, we assume rasterizerDiscardEnable is false
     const bool has_rasterization = is_dynamic_has_rasterization ||
-                                   (in_struct->pRasterizationState && !in_struct->pRasterizationState->rasterizerDiscardEnable);
+                                   (!in_struct->pRasterizationState || !in_struct->pRasterizationState->rasterizerDiscardEnable);
     if (in_struct->pViewportState && (has_rasterization || is_graphics_library)) {
         bool is_dynamic_viewports = false;
         bool is_dynamic_scissors = false;
@@ -772,8 +776,9 @@ void safe_VkGraphicsPipelineCreateInfo::initialize(const safe_VkGraphicsPipeline
             if (copy_src->pDynamicState->pDynamicStates[i] == VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT)
                 is_dynamic_has_rasterization = true;
     }
+    // No pRasterizationState is same as dynamic, we assume rasterizerDiscardEnable is false
     const bool has_rasterization =
-        is_dynamic_has_rasterization || (copy_src->pRasterizationState && !copy_src->pRasterizationState->rasterizerDiscardEnable);
+        is_dynamic_has_rasterization || (!copy_src->pRasterizationState || !copy_src->pRasterizationState->rasterizerDiscardEnable);
     if (copy_src->pViewportState && (has_rasterization || is_graphics_library)) {
         pViewportState = new safe_VkPipelineViewportStateCreateInfo(*copy_src->pViewportState);
     } else

From 6bc92daa125da7aed037b46513845ebc67bc96e6 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 27 May 2024 15:55:56 +0000
Subject: [PATCH 029/106] build(deps): Bump jidicula/clang-format-action from
 4.12.0 to 4.13.0

Bumps [jidicula/clang-format-action](https://github.com/jidicula/clang-format-action) from 4.12.0 to 4.13.0.
- [Release notes](https://github.com/jidicula/clang-format-action/releases)
- [Commits](https://github.com/jidicula/clang-format-action/compare/v4.12.0...v4.13.0)

---
updated-dependencies:
- dependency-name: jidicula/clang-format-action
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 .github/workflows/format.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/format.yml b/.github/workflows/format.yml
index 9aa3182..1540cc0 100644
--- a/.github/workflows/format.yml
+++ b/.github/workflows/format.yml
@@ -28,7 +28,7 @@ jobs:
     steps:
     - uses: actions/checkout@v4
     - name: Run clang-format
-      uses: jidicula/clang-format-action@v4.12.0
+      uses: jidicula/clang-format-action@v4.13.0
       with:
         clang-format-version: '14'
         check-path: ${{ matrix.path }}

From 252879e8958afc0c250ed460dbecf43c206fca04 Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Mon, 3 Jun 2024 09:40:52 -0700
Subject: [PATCH 030/106] build: Update to header 1.3.286

---
 include/vulkan/utility/vk_safe_struct.hpp   | 23 +++++++++
 include/vulkan/utility/vk_struct_helper.hpp |  1 +
 include/vulkan/vk_enum_string_helper.h      |  6 +++
 scripts/known_good.json                     |  2 +-
 src/vulkan/vk_safe_struct_ext.cpp           | 53 +++++++++++++++++++++
 src/vulkan/vk_safe_struct_utils.cpp         |  6 +++
 6 files changed, 90 insertions(+), 1 deletion(-)

diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index 5a1f559..d994cdb 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -17894,6 +17894,29 @@ struct safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV {
         return reinterpret_cast<VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const*>(this);
     }
 };
+struct safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderReplicatedComposites;
+
+    safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT(
+        const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT(
+        const safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT();
+    ~safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT();
+    void initialize(const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT const*>(this);
+    }
+};
 struct safe_VkPhysicalDeviceRayTracingValidationFeaturesNV {
     VkStructureType sType;
     void* pNext{};
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index 65f0958..f893bdf 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -942,6 +942,7 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceLayeredDriverPropert
 template <> inline VkStructureType GetSType<VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceRawAccessChainsFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingValidationFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceImageAlignmentControlFeaturesMESA>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceImageAlignmentControlPropertiesMESA>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index b7f3425..fe863e1 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -1912,6 +1912,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA:
@@ -2106,6 +2108,8 @@ static inline const char* string_VkObjectType(VkObjectType input_value) {
 }
 static inline const char* string_VkVendorId(VkVendorId input_value) {
     switch (input_value) {
+        case VK_VENDOR_ID_KHRONOS:
+            return "VK_VENDOR_ID_KHRONOS";
         case VK_VENDOR_ID_VIV:
             return "VK_VENDOR_ID_VIV";
         case VK_VENDOR_ID_VSI:
@@ -3530,6 +3534,8 @@ static inline const char* string_VkDriverId(VkDriverId input_value) {
             return "VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA";
         case VK_DRIVER_ID_MESA_AGXV:
             return "VK_DRIVER_ID_MESA_AGXV";
+        case VK_DRIVER_ID_RESERVED_27:
+            return "VK_DRIVER_ID_RESERVED_27";
         default:
             return "Unhandled VkDriverId";
     }
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 0035e0d..f2af918 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.3.285"
+            "commit": "v1.3.286"
         },
         {
             "name": "googletest",
diff --git a/src/vulkan/vk_safe_struct_ext.cpp b/src/vulkan/vk_safe_struct_ext.cpp
index 0c682ec..a31a813 100644
--- a/src/vulkan/vk_safe_struct_ext.cpp
+++ b/src/vulkan/vk_safe_struct_ext.cpp
@@ -15203,6 +15203,59 @@ void safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT::initial
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT::safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT(
+    const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), shaderReplicatedComposites(in_struct->shaderReplicatedComposites) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT::safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT),
+      pNext(nullptr),
+      shaderReplicatedComposites() {}
+
+safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT::safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT(
+    const safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    shaderReplicatedComposites = copy_src.shaderReplicatedComposites;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT& safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderReplicatedComposites = copy_src.shaderReplicatedComposites;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT::~safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT::initialize(
+    const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderReplicatedComposites = in_struct->shaderReplicatedComposites;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderReplicatedComposites = copy_src->shaderReplicatedComposites;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkPhysicalDeviceMeshShaderFeaturesEXT::safe_VkPhysicalDeviceMeshShaderFeaturesEXT(
     const VkPhysicalDeviceMeshShaderFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType),
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index 5406ced..9036c69 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -1791,6 +1791,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV:
                 safe_pNext = new safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV(reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
                 safe_pNext = new safe_VkPhysicalDeviceRayTracingValidationFeaturesNV(reinterpret_cast<const VkPhysicalDeviceRayTracingValidationFeaturesNV *>(pNext), copy_state, false);
                 break;
@@ -3602,6 +3605,9 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV:
             delete reinterpret_cast<const safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
             delete reinterpret_cast<const safe_VkPhysicalDeviceRayTracingValidationFeaturesNV *>(header);
             break;

From 741921e408442b0370047b5eaf16cbc2b5d381e5 Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Fri, 7 Jun 2024 09:03:07 -0700
Subject: [PATCH 031/106] build: Update to header 1.3.287

---
 include/vulkan/vk_enum_string_helper.h | 4 ++--
 scripts/known_good.json                | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index fe863e1..f56ba03 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -3532,8 +3532,8 @@ static inline const char* string_VkDriverId(VkDriverId input_value) {
             return "VK_DRIVER_ID_MESA_NVK";
         case VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA:
             return "VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA";
-        case VK_DRIVER_ID_MESA_AGXV:
-            return "VK_DRIVER_ID_MESA_AGXV";
+        case VK_DRIVER_ID_MESA_HONEYKRISP:
+            return "VK_DRIVER_ID_MESA_HONEYKRISP";
         case VK_DRIVER_ID_RESERVED_27:
             return "VK_DRIVER_ID_RESERVED_27";
         default:
diff --git a/scripts/known_good.json b/scripts/known_good.json
index f2af918..dc54022 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.3.286"
+            "commit": "v1.3.287"
         },
         {
             "name": "googletest",

From 07759f04791dc3fbb390174f0d24d4a792e0d357 Mon Sep 17 00:00:00 2001
From: Jeremy Gebben <jeremyg@lunarg.com>
Date: Mon, 10 Jun 2024 10:00:52 -0600
Subject: [PATCH 032/106] safe_struct: Make FreePnextChain() non-recursive

---
 scripts/generators/safe_struct_generator.py |   34 +-
 src/vulkan/vk_safe_struct_utils.cpp         | 1194 +++++++++----------
 2 files changed, 612 insertions(+), 616 deletions(-)

diff --git a/scripts/generators/safe_struct_generator.py b/scripts/generators/safe_struct_generator.py
index b893877..8b4fae8 100644
--- a/scripts/generators/safe_struct_generator.py
+++ b/scripts/generators/safe_struct_generator.py
@@ -330,20 +330,23 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
 }
 
 void FreePnextChain(const void *pNext) {
-    if (!pNext) return;
+    // The pNext parameter is const for convenience, since it is called by code
+    // for many structures where the pNext field is const.
+    void *current = const_cast<void*>(pNext);
+    while (current) {
+        auto header = reinterpret_cast<VkBaseOutStructure *>(current);
+        void *next = header->pNext;
+        // prevent destructors from recursing behind our backs.
+        header->pNext = nullptr;
 
-    auto header = reinterpret_cast<const VkBaseOutStructure *>(pNext);
-
-    switch (header->sType) {
-        // Special-case Loader Instance Struct passed to/from layer in pNext chain
+        switch (header->sType) {
+            // Special-case Loader Instance Struct passed to/from layer in pNext chain
         case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:
-            FreePnextChain(header->pNext);
-            delete reinterpret_cast<const VkLayerInstanceCreateInfo *>(pNext);
+            delete reinterpret_cast<VkLayerInstanceCreateInfo *>(current);
             break;
         // Special-case Loader Device Struct passed to/from layer in pNext chain
         case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:
-            FreePnextChain(header->pNext);
-            delete reinterpret_cast<const VkLayerDeviceCreateInfo *>(pNext);
+            delete reinterpret_cast<VkLayerDeviceCreateInfo *>(current);
             break;
 ''')
 
@@ -351,7 +354,7 @@ void FreePnextChain(const void *pNext) {
             safe_name = self.convertName(struct.name)
             out.extend(guard_helper.add_guard(struct.protect))
             out.append(f'        case {struct.sType}:\n')
-            out.append(f'            delete reinterpret_cast<const {safe_name} *>(header);\n')
+            out.append(f'            delete reinterpret_cast<{safe_name} *>(header);\n')
             out.append('            break;\n')
         out.extend(guard_helper.add_guard(None))
 
@@ -360,18 +363,13 @@ void FreePnextChain(const void *pNext) {
             // If sType is in custom list, free custom struct memory and clean up
             for (auto item : custom_stype_info) {
                 if (item.first == static_cast<uint32_t>(header->sType)) {
-                    if (header->pNext) {
-                        FreePnextChain(header->pNext);
-                    }
-                    free(const_cast<void *>(pNext));
-                    pNext = nullptr;
+                    free(current);
                     break;
                 }
             }
-            if (pNext) {
-                FreePnextChain(header->pNext);
-            }
             break;
+        }
+        current = next;
     }
 }''')
         out.append('// clang-format on\n')
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index 9036c69..b443381 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -1858,1809 +1858,1807 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
 }
 
 void FreePnextChain(const void *pNext) {
-    if (!pNext) return;
+    // The pNext parameter is const for convenience, since it is called by code
+    // for many structures where the pNext field is const.
+    void *current = const_cast<void*>(pNext);
+    while (current) {
+        auto header = reinterpret_cast<VkBaseOutStructure *>(current);
+        void *next = header->pNext;
+        // prevent destructors from recursing behind our backs.
+        header->pNext = nullptr;
 
-    auto header = reinterpret_cast<const VkBaseOutStructure *>(pNext);
-
-    switch (header->sType) {
-        // Special-case Loader Instance Struct passed to/from layer in pNext chain
+        switch (header->sType) {
+            // Special-case Loader Instance Struct passed to/from layer in pNext chain
         case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:
-            FreePnextChain(header->pNext);
-            delete reinterpret_cast<const VkLayerInstanceCreateInfo *>(pNext);
+            delete reinterpret_cast<VkLayerInstanceCreateInfo *>(current);
             break;
         // Special-case Loader Device Struct passed to/from layer in pNext chain
         case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:
-            FreePnextChain(header->pNext);
-            delete reinterpret_cast<const VkLayerDeviceCreateInfo *>(pNext);
+            delete reinterpret_cast<VkLayerDeviceCreateInfo *>(current);
             break;
         case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
-            delete reinterpret_cast<const safe_VkShaderModuleCreateInfo *>(header);
+            delete reinterpret_cast<safe_VkShaderModuleCreateInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:
-            delete reinterpret_cast<const safe_VkPipelineLayoutCreateInfo *>(header);
+            delete reinterpret_cast<safe_VkPipelineLayoutCreateInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceSubgroupProperties *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceSubgroupProperties *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDevice16BitStorageFeatures *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDevice16BitStorageFeatures *>(header);
             break;
         case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
-            delete reinterpret_cast<const safe_VkMemoryDedicatedRequirements *>(header);
+            delete reinterpret_cast<safe_VkMemoryDedicatedRequirements *>(header);
             break;
         case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
-            delete reinterpret_cast<const safe_VkMemoryDedicatedAllocateInfo *>(header);
+            delete reinterpret_cast<safe_VkMemoryDedicatedAllocateInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
-            delete reinterpret_cast<const safe_VkMemoryAllocateFlagsInfo *>(header);
+            delete reinterpret_cast<safe_VkMemoryAllocateFlagsInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
-            delete reinterpret_cast<const safe_VkDeviceGroupRenderPassBeginInfo *>(header);
+            delete reinterpret_cast<safe_VkDeviceGroupRenderPassBeginInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
-            delete reinterpret_cast<const safe_VkDeviceGroupCommandBufferBeginInfo *>(header);
+            delete reinterpret_cast<safe_VkDeviceGroupCommandBufferBeginInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
-            delete reinterpret_cast<const safe_VkDeviceGroupSubmitInfo *>(header);
+            delete reinterpret_cast<safe_VkDeviceGroupSubmitInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
-            delete reinterpret_cast<const safe_VkDeviceGroupBindSparseInfo *>(header);
+            delete reinterpret_cast<safe_VkDeviceGroupBindSparseInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
-            delete reinterpret_cast<const safe_VkBindBufferMemoryDeviceGroupInfo *>(header);
+            delete reinterpret_cast<safe_VkBindBufferMemoryDeviceGroupInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
-            delete reinterpret_cast<const safe_VkBindImageMemoryDeviceGroupInfo *>(header);
+            delete reinterpret_cast<safe_VkBindImageMemoryDeviceGroupInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
-            delete reinterpret_cast<const safe_VkDeviceGroupDeviceCreateInfo *>(header);
+            delete reinterpret_cast<safe_VkDeviceGroupDeviceCreateInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceFeatures2 *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceFeatures2 *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
-            delete reinterpret_cast<const safe_VkPhysicalDevicePointClippingProperties *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDevicePointClippingProperties *>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
-            delete reinterpret_cast<const safe_VkRenderPassInputAttachmentAspectCreateInfo *>(header);
+            delete reinterpret_cast<safe_VkRenderPassInputAttachmentAspectCreateInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
-            delete reinterpret_cast<const safe_VkImageViewUsageCreateInfo *>(header);
+            delete reinterpret_cast<safe_VkImageViewUsageCreateInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
-            delete reinterpret_cast<const safe_VkPipelineTessellationDomainOriginStateCreateInfo *>(header);
+            delete reinterpret_cast<safe_VkPipelineTessellationDomainOriginStateCreateInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
-            delete reinterpret_cast<const safe_VkRenderPassMultiviewCreateInfo *>(header);
+            delete reinterpret_cast<safe_VkRenderPassMultiviewCreateInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceMultiviewFeatures *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceMultiviewFeatures *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceMultiviewProperties *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceMultiviewProperties *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceVariablePointersFeatures *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceVariablePointersFeatures *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceProtectedMemoryFeatures *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceProtectedMemoryFeatures *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceProtectedMemoryProperties *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceProtectedMemoryProperties *>(header);
             break;
         case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
-            delete reinterpret_cast<const safe_VkProtectedSubmitInfo *>(header);
+            delete reinterpret_cast<safe_VkProtectedSubmitInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
-            delete reinterpret_cast<const safe_VkSamplerYcbcrConversionInfo *>(header);
+            delete reinterpret_cast<safe_VkSamplerYcbcrConversionInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
-            delete reinterpret_cast<const safe_VkBindImagePlaneMemoryInfo *>(header);
+            delete reinterpret_cast<safe_VkBindImagePlaneMemoryInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
-            delete reinterpret_cast<const safe_VkImagePlaneMemoryRequirementsInfo *>(header);
+            delete reinterpret_cast<safe_VkImagePlaneMemoryRequirementsInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures *>(header);
             break;
         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
-            delete reinterpret_cast<const safe_VkSamplerYcbcrConversionImageFormatProperties *>(header);
+            delete reinterpret_cast<safe_VkSamplerYcbcrConversionImageFormatProperties *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceExternalImageFormatInfo *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceExternalImageFormatInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
-            delete reinterpret_cast<const safe_VkExternalImageFormatProperties *>(header);
+            delete reinterpret_cast<safe_VkExternalImageFormatProperties *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceIDProperties *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceIDProperties *>(header);
             break;
         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
-            delete reinterpret_cast<const safe_VkExternalMemoryImageCreateInfo *>(header);
+            delete reinterpret_cast<safe_VkExternalMemoryImageCreateInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
-            delete reinterpret_cast<const safe_VkExternalMemoryBufferCreateInfo *>(header);
+            delete reinterpret_cast<safe_VkExternalMemoryBufferCreateInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
-            delete reinterpret_cast<const safe_VkExportMemoryAllocateInfo *>(header);
+            delete reinterpret_cast<safe_VkExportMemoryAllocateInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
-            delete reinterpret_cast<const safe_VkExportFenceCreateInfo *>(header);
+            delete reinterpret_cast<safe_VkExportFenceCreateInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
-            delete reinterpret_cast<const safe_VkExportSemaphoreCreateInfo *>(header);
+            delete reinterpret_cast<safe_VkExportSemaphoreCreateInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceMaintenance3Properties *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceMaintenance3Properties *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderDrawParametersFeatures *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderDrawParametersFeatures *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceVulkan11Features *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceVulkan11Features *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceVulkan11Properties *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceVulkan11Properties *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceVulkan12Features *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceVulkan12Features *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceVulkan12Properties *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceVulkan12Properties *>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
-            delete reinterpret_cast<const safe_VkImageFormatListCreateInfo *>(header);
+            delete reinterpret_cast<safe_VkImageFormatListCreateInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDevice8BitStorageFeatures *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDevice8BitStorageFeatures *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceDriverProperties *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceDriverProperties *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderAtomicInt64Features *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderAtomicInt64Features *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderFloat16Int8Features *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderFloat16Int8Features *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceFloatControlsProperties *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceFloatControlsProperties *>(header);
             break;
         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
-            delete reinterpret_cast<const safe_VkDescriptorSetLayoutBindingFlagsCreateInfo *>(header);
+            delete reinterpret_cast<safe_VkDescriptorSetLayoutBindingFlagsCreateInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceDescriptorIndexingFeatures *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceDescriptorIndexingFeatures *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceDescriptorIndexingProperties *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceDescriptorIndexingProperties *>(header);
             break;
         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
-            delete reinterpret_cast<const safe_VkDescriptorSetVariableDescriptorCountAllocateInfo *>(header);
+            delete reinterpret_cast<safe_VkDescriptorSetVariableDescriptorCountAllocateInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
-            delete reinterpret_cast<const safe_VkDescriptorSetVariableDescriptorCountLayoutSupport *>(header);
+            delete reinterpret_cast<safe_VkDescriptorSetVariableDescriptorCountLayoutSupport *>(header);
             break;
         case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
-            delete reinterpret_cast<const safe_VkSubpassDescriptionDepthStencilResolve *>(header);
+            delete reinterpret_cast<safe_VkSubpassDescriptionDepthStencilResolve *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceDepthStencilResolveProperties *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceDepthStencilResolveProperties *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceScalarBlockLayoutFeatures *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceScalarBlockLayoutFeatures *>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
-            delete reinterpret_cast<const safe_VkImageStencilUsageCreateInfo *>(header);
+            delete reinterpret_cast<safe_VkImageStencilUsageCreateInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
-            delete reinterpret_cast<const safe_VkSamplerReductionModeCreateInfo *>(header);
+            delete reinterpret_cast<safe_VkSamplerReductionModeCreateInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceSamplerFilterMinmaxProperties *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceSamplerFilterMinmaxProperties *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceVulkanMemoryModelFeatures *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceVulkanMemoryModelFeatures *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceImagelessFramebufferFeatures *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceImagelessFramebufferFeatures *>(header);
             break;
         case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
-            delete reinterpret_cast<const safe_VkFramebufferAttachmentsCreateInfo *>(header);
+            delete reinterpret_cast<safe_VkFramebufferAttachmentsCreateInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
-            delete reinterpret_cast<const safe_VkRenderPassAttachmentBeginInfo *>(header);
+            delete reinterpret_cast<safe_VkRenderPassAttachmentBeginInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceUniformBufferStandardLayoutFeatures *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *>(header);
             break;
         case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
-            delete reinterpret_cast<const safe_VkAttachmentReferenceStencilLayout *>(header);
+            delete reinterpret_cast<safe_VkAttachmentReferenceStencilLayout *>(header);
             break;
         case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
-            delete reinterpret_cast<const safe_VkAttachmentDescriptionStencilLayout *>(header);
+            delete reinterpret_cast<safe_VkAttachmentDescriptionStencilLayout *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceHostQueryResetFeatures *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceHostQueryResetFeatures *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceTimelineSemaphoreFeatures *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceTimelineSemaphoreFeatures *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceTimelineSemaphoreProperties *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceTimelineSemaphoreProperties *>(header);
             break;
         case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
-            delete reinterpret_cast<const safe_VkSemaphoreTypeCreateInfo *>(header);
+            delete reinterpret_cast<safe_VkSemaphoreTypeCreateInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
-            delete reinterpret_cast<const safe_VkTimelineSemaphoreSubmitInfo *>(header);
+            delete reinterpret_cast<safe_VkTimelineSemaphoreSubmitInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceBufferDeviceAddressFeatures *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceBufferDeviceAddressFeatures *>(header);
             break;
         case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
-            delete reinterpret_cast<const safe_VkBufferOpaqueCaptureAddressCreateInfo *>(header);
+            delete reinterpret_cast<safe_VkBufferOpaqueCaptureAddressCreateInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
-            delete reinterpret_cast<const safe_VkMemoryOpaqueCaptureAddressAllocateInfo *>(header);
+            delete reinterpret_cast<safe_VkMemoryOpaqueCaptureAddressAllocateInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceVulkan13Features *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceVulkan13Features *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceVulkan13Properties *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceVulkan13Properties *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
-            delete reinterpret_cast<const safe_VkPipelineCreationFeedbackCreateInfo *>(header);
+            delete reinterpret_cast<safe_VkPipelineCreationFeedbackCreateInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderTerminateInvocationFeatures *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderTerminateInvocationFeatures *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDevicePrivateDataFeatures *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDevicePrivateDataFeatures *>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
-            delete reinterpret_cast<const safe_VkDevicePrivateDataCreateInfo *>(header);
+            delete reinterpret_cast<safe_VkDevicePrivateDataCreateInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDevicePipelineCreationCacheControlFeatures *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDevicePipelineCreationCacheControlFeatures *>(header);
             break;
         case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2:
-            delete reinterpret_cast<const safe_VkMemoryBarrier2 *>(header);
+            delete reinterpret_cast<safe_VkMemoryBarrier2 *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceSynchronization2Features *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceSynchronization2Features *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceImageRobustnessFeatures *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceImageRobustnessFeatures *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceSubgroupSizeControlFeatures *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceSubgroupSizeControlFeatures *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceSubgroupSizeControlProperties *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceSubgroupSizeControlProperties *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
-            delete reinterpret_cast<const safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *>(header);
+            delete reinterpret_cast<safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceInlineUniformBlockFeatures *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceInlineUniformBlockFeatures *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceInlineUniformBlockProperties *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceInlineUniformBlockProperties *>(header);
             break;
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK:
-            delete reinterpret_cast<const safe_VkWriteDescriptorSetInlineUniformBlock *>(header);
+            delete reinterpret_cast<safe_VkWriteDescriptorSetInlineUniformBlock *>(header);
             break;
         case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO:
-            delete reinterpret_cast<const safe_VkDescriptorPoolInlineUniformBlockCreateInfo *>(header);
+            delete reinterpret_cast<safe_VkDescriptorPoolInlineUniformBlockCreateInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceTextureCompressionASTCHDRFeatures *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
-            delete reinterpret_cast<const safe_VkPipelineRenderingCreateInfo *>(header);
+            delete reinterpret_cast<safe_VkPipelineRenderingCreateInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceDynamicRenderingFeatures *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceDynamicRenderingFeatures *>(header);
             break;
         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO:
-            delete reinterpret_cast<const safe_VkCommandBufferInheritanceRenderingInfo *>(header);
+            delete reinterpret_cast<safe_VkCommandBufferInheritanceRenderingInfo *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderIntegerDotProductFeatures *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderIntegerDotProductFeatures *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderIntegerDotProductProperties *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderIntegerDotProductProperties *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceTexelBufferAlignmentProperties *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceTexelBufferAlignmentProperties *>(header);
             break;
         case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
-            delete reinterpret_cast<const safe_VkFormatProperties3 *>(header);
+            delete reinterpret_cast<safe_VkFormatProperties3 *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceMaintenance4Features *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceMaintenance4Features *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceMaintenance4Properties *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceMaintenance4Properties *>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkImageSwapchainCreateInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkImageSwapchainCreateInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
-            delete reinterpret_cast<const safe_VkBindImageMemorySwapchainInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkBindImageMemorySwapchainInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
-            delete reinterpret_cast<const safe_VkDeviceGroupPresentInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkDeviceGroupPresentInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkDeviceGroupSwapchainCreateInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkDeviceGroupSwapchainCreateInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
-            delete reinterpret_cast<const safe_VkDisplayPresentInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkDisplayPresentInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR:
-            delete reinterpret_cast<const safe_VkQueueFamilyQueryResultStatusPropertiesKHR *>(header);
+            delete reinterpret_cast<safe_VkQueueFamilyQueryResultStatusPropertiesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR:
-            delete reinterpret_cast<const safe_VkQueueFamilyVideoPropertiesKHR *>(header);
+            delete reinterpret_cast<safe_VkQueueFamilyVideoPropertiesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoProfileInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoProfileInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoProfileListInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoProfileListInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR:
-            delete reinterpret_cast<const safe_VkVideoDecodeCapabilitiesKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoDecodeCapabilitiesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoDecodeUsageInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoDecodeUsageInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR:
-            delete reinterpret_cast<const safe_VkVideoEncodeH264CapabilitiesKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoEncodeH264CapabilitiesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR:
-            delete reinterpret_cast<const safe_VkVideoEncodeH264QualityLevelPropertiesKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoEncodeH264QualityLevelPropertiesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoEncodeH264SessionCreateInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoEncodeH264SessionCreateInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoEncodeH264SessionParametersAddInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoEncodeH264SessionParametersAddInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoEncodeH264SessionParametersCreateInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoEncodeH264SessionParametersCreateInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoEncodeH264SessionParametersGetInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoEncodeH264SessionParametersGetInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoEncodeH264SessionParametersFeedbackInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoEncodeH264PictureInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoEncodeH264PictureInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoEncodeH264DpbSlotInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoEncodeH264DpbSlotInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoEncodeH264ProfileInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoEncodeH264ProfileInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoEncodeH264RateControlInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoEncodeH264RateControlInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoEncodeH264RateControlLayerInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoEncodeH264RateControlLayerInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoEncodeH264GopRemainingFrameInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoEncodeH264GopRemainingFrameInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR:
-            delete reinterpret_cast<const safe_VkVideoEncodeH265CapabilitiesKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoEncodeH265CapabilitiesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoEncodeH265SessionCreateInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoEncodeH265SessionCreateInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR:
-            delete reinterpret_cast<const safe_VkVideoEncodeH265QualityLevelPropertiesKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoEncodeH265QualityLevelPropertiesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoEncodeH265SessionParametersAddInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoEncodeH265SessionParametersAddInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoEncodeH265SessionParametersCreateInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoEncodeH265SessionParametersCreateInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoEncodeH265SessionParametersGetInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoEncodeH265SessionParametersGetInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoEncodeH265SessionParametersFeedbackInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoEncodeH265PictureInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoEncodeH265PictureInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoEncodeH265DpbSlotInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoEncodeH265DpbSlotInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoEncodeH265ProfileInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoEncodeH265ProfileInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoEncodeH265RateControlInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoEncodeH265RateControlInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoEncodeH265RateControlLayerInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoEncodeH265RateControlLayerInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoEncodeH265GopRemainingFrameInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoEncodeH265GopRemainingFrameInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoDecodeH264ProfileInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoDecodeH264ProfileInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR:
-            delete reinterpret_cast<const safe_VkVideoDecodeH264CapabilitiesKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoDecodeH264CapabilitiesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoDecodeH264SessionParametersAddInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoDecodeH264SessionParametersAddInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoDecodeH264SessionParametersCreateInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoDecodeH264SessionParametersCreateInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoDecodeH264PictureInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoDecodeH264PictureInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoDecodeH264DpbSlotInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoDecodeH264DpbSlotInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
-            delete reinterpret_cast<const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkRenderingFragmentShadingRateAttachmentInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
-            delete reinterpret_cast<const safe_VkRenderingFragmentDensityMapAttachmentInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkRenderingFragmentDensityMapAttachmentInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
-            delete reinterpret_cast<const safe_VkAttachmentSampleCountInfoAMD *>(header);
+            delete reinterpret_cast<safe_VkAttachmentSampleCountInfoAMD *>(header);
             break;
         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
-            delete reinterpret_cast<const safe_VkMultiviewPerViewAttributesInfoNVX *>(header);
+            delete reinterpret_cast<safe_VkMultiviewPerViewAttributesInfoNVX *>(header);
             break;
 #ifdef VK_USE_PLATFORM_WIN32_KHR
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkImportMemoryWin32HandleInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkImportMemoryWin32HandleInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkExportMemoryWin32HandleInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkExportMemoryWin32HandleInfoKHR *>(header);
             break;
 #endif  // VK_USE_PLATFORM_WIN32_KHR
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
-            delete reinterpret_cast<const safe_VkImportMemoryFdInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkImportMemoryFdInfoKHR *>(header);
             break;
 #ifdef VK_USE_PLATFORM_WIN32_KHR
         case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkWin32KeyedMutexAcquireReleaseInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkExportSemaphoreWin32HandleInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkExportSemaphoreWin32HandleInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
-            delete reinterpret_cast<const safe_VkD3D12FenceSubmitInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkD3D12FenceSubmitInfoKHR *>(header);
             break;
 #endif  // VK_USE_PLATFORM_WIN32_KHR
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDevicePushDescriptorPropertiesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDevicePushDescriptorPropertiesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
-            delete reinterpret_cast<const safe_VkPresentRegionsKHR *>(header);
+            delete reinterpret_cast<safe_VkPresentRegionsKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
-            delete reinterpret_cast<const safe_VkSharedPresentSurfaceCapabilitiesKHR *>(header);
+            delete reinterpret_cast<safe_VkSharedPresentSurfaceCapabilitiesKHR *>(header);
             break;
 #ifdef VK_USE_PLATFORM_WIN32_KHR
         case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkExportFenceWin32HandleInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkExportFenceWin32HandleInfoKHR *>(header);
             break;
 #endif  // VK_USE_PLATFORM_WIN32_KHR
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDevicePerformanceQueryFeaturesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDevicePerformanceQueryFeaturesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDevicePerformanceQueryPropertiesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDevicePerformanceQueryPropertiesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkQueryPoolPerformanceCreateInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkQueryPoolPerformanceCreateInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
-            delete reinterpret_cast<const safe_VkPerformanceQuerySubmitInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkPerformanceQuerySubmitInfoKHR *>(header);
             break;
 #ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDevicePortabilitySubsetPropertiesKHR *>(header);
             break;
 #endif  // VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderClockFeaturesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderClockFeaturesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoDecodeH265ProfileInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoDecodeH265ProfileInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR:
-            delete reinterpret_cast<const safe_VkVideoDecodeH265CapabilitiesKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoDecodeH265CapabilitiesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoDecodeH265SessionParametersAddInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoDecodeH265SessionParametersAddInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoDecodeH265SessionParametersCreateInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoDecodeH265SessionParametersCreateInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoDecodeH265PictureInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoDecodeH265PictureInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoDecodeH265DpbSlotInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoDecodeH265DpbSlotInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkDeviceQueueGlobalPriorityCreateInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkDeviceQueueGlobalPriorityCreateInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR:
-            delete reinterpret_cast<const safe_VkQueueFamilyGlobalPriorityPropertiesKHR *>(header);
+            delete reinterpret_cast<safe_VkQueueFamilyGlobalPriorityPropertiesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
-            delete reinterpret_cast<const safe_VkFragmentShadingRateAttachmentInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkFragmentShadingRateAttachmentInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkPipelineFragmentShadingRateStateCreateInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkPipelineFragmentShadingRateStateCreateInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceFragmentShadingRateFeaturesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR:
-            delete reinterpret_cast<const safe_VkRenderingAttachmentLocationInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkRenderingAttachmentLocationInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR:
-            delete reinterpret_cast<const safe_VkRenderingInputAttachmentIndexInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkRenderingInputAttachmentIndexInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:
-            delete reinterpret_cast<const safe_VkSurfaceProtectedCapabilitiesKHR *>(header);
+            delete reinterpret_cast<safe_VkSurfaceProtectedCapabilitiesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDevicePresentWaitFeaturesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDevicePresentWaitFeaturesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkPipelineLibraryCreateInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkPipelineLibraryCreateInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PRESENT_ID_KHR:
-            delete reinterpret_cast<const safe_VkPresentIdKHR *>(header);
+            delete reinterpret_cast<safe_VkPresentIdKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDevicePresentIdFeaturesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDevicePresentIdFeaturesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR:
-            delete reinterpret_cast<const safe_VkVideoEncodeCapabilitiesKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoEncodeCapabilitiesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoEncodeUsageInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoEncodeUsageInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoEncodeRateControlInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoEncodeRateControlInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoEncodeQualityLevelInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoEncodeQualityLevelInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
-            delete reinterpret_cast<const safe_VkQueueFamilyCheckpointProperties2NV *>(header);
+            delete reinterpret_cast<safe_VkQueueFamilyCheckpointProperties2NV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceMaintenance5FeaturesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceMaintenance5FeaturesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceMaintenance5PropertiesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceMaintenance5PropertiesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkPipelineCreateFlags2CreateInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkPipelineCreateFlags2CreateInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkBufferUsageFlags2CreateInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkBufferUsageFlags2CreateInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoDecodeAV1ProfileInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoDecodeAV1ProfileInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR:
-            delete reinterpret_cast<const safe_VkVideoDecodeAV1CapabilitiesKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoDecodeAV1CapabilitiesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoDecodeAV1SessionParametersCreateInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoDecodeAV1PictureInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoDecodeAV1PictureInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoDecodeAV1DpbSlotInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoDecodeAV1DpbSlotInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR:
-            delete reinterpret_cast<const safe_VkVideoInlineQueryInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkVideoInlineQueryInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkPipelineVertexInputDivisorStateCreateInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceLineRasterizationFeaturesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceLineRasterizationFeaturesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceLineRasterizationPropertiesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceLineRasterizationPropertiesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR:
-            delete reinterpret_cast<const safe_VkPipelineRasterizationLineStateCreateInfoKHR *>(header);
+            delete reinterpret_cast<safe_VkPipelineRasterizationLineStateCreateInfoKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceMaintenance6FeaturesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceMaintenance6FeaturesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceMaintenance6PropertiesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceMaintenance6PropertiesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR:
-            delete reinterpret_cast<const safe_VkBindMemoryStatusKHR *>(header);
+            delete reinterpret_cast<safe_VkBindMemoryStatusKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkDebugReportCallbackCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkDebugReportCallbackCreateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
-            delete reinterpret_cast<const safe_VkPipelineRasterizationStateRasterizationOrderAMD *>(header);
+            delete reinterpret_cast<safe_VkPipelineRasterizationStateRasterizationOrderAMD *>(header);
             break;
         case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
-            delete reinterpret_cast<const safe_VkDedicatedAllocationImageCreateInfoNV *>(header);
+            delete reinterpret_cast<safe_VkDedicatedAllocationImageCreateInfoNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
-            delete reinterpret_cast<const safe_VkDedicatedAllocationBufferCreateInfoNV *>(header);
+            delete reinterpret_cast<safe_VkDedicatedAllocationBufferCreateInfoNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
-            delete reinterpret_cast<const safe_VkDedicatedAllocationMemoryAllocateInfoNV *>(header);
+            delete reinterpret_cast<safe_VkDedicatedAllocationMemoryAllocateInfoNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkPipelineRasterizationStateStreamCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkPipelineRasterizationStateStreamCreateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
-            delete reinterpret_cast<const safe_VkTextureLODGatherFormatPropertiesAMD *>(header);
+            delete reinterpret_cast<safe_VkTextureLODGatherFormatPropertiesAMD *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceCornerSampledImageFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceCornerSampledImageFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
-            delete reinterpret_cast<const safe_VkExternalMemoryImageCreateInfoNV *>(header);
+            delete reinterpret_cast<safe_VkExternalMemoryImageCreateInfoNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
-            delete reinterpret_cast<const safe_VkExportMemoryAllocateInfoNV *>(header);
+            delete reinterpret_cast<safe_VkExportMemoryAllocateInfoNV *>(header);
             break;
 #ifdef VK_USE_PLATFORM_WIN32_KHR
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
-            delete reinterpret_cast<const safe_VkImportMemoryWin32HandleInfoNV *>(header);
+            delete reinterpret_cast<safe_VkImportMemoryWin32HandleInfoNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
-            delete reinterpret_cast<const safe_VkExportMemoryWin32HandleInfoNV *>(header);
+            delete reinterpret_cast<safe_VkExportMemoryWin32HandleInfoNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
-            delete reinterpret_cast<const safe_VkWin32KeyedMutexAcquireReleaseInfoNV *>(header);
+            delete reinterpret_cast<safe_VkWin32KeyedMutexAcquireReleaseInfoNV *>(header);
             break;
 #endif  // VK_USE_PLATFORM_WIN32_KHR
         case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
-            delete reinterpret_cast<const safe_VkValidationFlagsEXT *>(header);
+            delete reinterpret_cast<safe_VkValidationFlagsEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
-            delete reinterpret_cast<const safe_VkImageViewASTCDecodeModeEXT *>(header);
+            delete reinterpret_cast<safe_VkImageViewASTCDecodeModeEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceASTCDecodeFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceASTCDecodeFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkPipelineRobustnessCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkPipelineRobustnessCreateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
-            delete reinterpret_cast<const safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
-            delete reinterpret_cast<const safe_VkPipelineViewportWScalingStateCreateInfoNV *>(header);
+            delete reinterpret_cast<safe_VkPipelineViewportWScalingStateCreateInfoNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkSwapchainCounterCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkSwapchainCounterCreateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
-            delete reinterpret_cast<const safe_VkPresentTimesInfoGOOGLE *>(header);
+            delete reinterpret_cast<safe_VkPresentTimesInfoGOOGLE *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
-            delete reinterpret_cast<const safe_VkPipelineViewportSwizzleStateCreateInfoNV *>(header);
+            delete reinterpret_cast<safe_VkPipelineViewportSwizzleStateCreateInfoNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkPipelineDiscardRectangleStateCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkPipelineDiscardRectangleStateCreateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkPipelineRasterizationConservativeStateCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkPipelineRasterizationConservativeStateCreateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *>(header);
             break;
         case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
-            delete reinterpret_cast<const safe_VkDebugUtilsObjectNameInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkDebugUtilsObjectNameInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkDebugUtilsMessengerCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkDebugUtilsMessengerCreateInfoEXT *>(header);
             break;
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
         case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
-            delete reinterpret_cast<const safe_VkAndroidHardwareBufferUsageANDROID *>(header);
+            delete reinterpret_cast<safe_VkAndroidHardwareBufferUsageANDROID *>(header);
             break;
         case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
-            delete reinterpret_cast<const safe_VkAndroidHardwareBufferFormatPropertiesANDROID *>(header);
+            delete reinterpret_cast<safe_VkAndroidHardwareBufferFormatPropertiesANDROID *>(header);
             break;
         case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
-            delete reinterpret_cast<const safe_VkImportAndroidHardwareBufferInfoANDROID *>(header);
+            delete reinterpret_cast<safe_VkImportAndroidHardwareBufferInfoANDROID *>(header);
             break;
         case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
-            delete reinterpret_cast<const safe_VkExternalFormatANDROID *>(header);
+            delete reinterpret_cast<safe_VkExternalFormatANDROID *>(header);
             break;
         case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID:
-            delete reinterpret_cast<const safe_VkAndroidHardwareBufferFormatProperties2ANDROID *>(header);
+            delete reinterpret_cast<safe_VkAndroidHardwareBufferFormatProperties2ANDROID *>(header);
             break;
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
 #ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX:
-            delete reinterpret_cast<const safe_VkPipelineShaderStageNodeCreateInfoAMDX *>(header);
+            delete reinterpret_cast<safe_VkPipelineShaderStageNodeCreateInfoAMDX *>(header);
             break;
 #endif  // VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
-            delete reinterpret_cast<const safe_VkSampleLocationsInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkSampleLocationsInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
-            delete reinterpret_cast<const safe_VkRenderPassSampleLocationsBeginInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkRenderPassSampleLocationsBeginInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkPipelineSampleLocationsStateCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkPipelineSampleLocationsStateCreateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceSampleLocationsPropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceSampleLocationsPropertiesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
-            delete reinterpret_cast<const safe_VkPipelineCoverageToColorStateCreateInfoNV *>(header);
+            delete reinterpret_cast<safe_VkPipelineCoverageToColorStateCreateInfoNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
-            delete reinterpret_cast<const safe_VkPipelineCoverageModulationStateCreateInfoNV *>(header);
+            delete reinterpret_cast<safe_VkPipelineCoverageModulationStateCreateInfoNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
-            delete reinterpret_cast<const safe_VkDrmFormatModifierPropertiesListEXT *>(header);
+            delete reinterpret_cast<safe_VkDrmFormatModifierPropertiesListEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkImageDrmFormatModifierListCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkImageDrmFormatModifierListCreateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkImageDrmFormatModifierExplicitCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkImageDrmFormatModifierExplicitCreateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
-            delete reinterpret_cast<const safe_VkDrmFormatModifierPropertiesList2EXT *>(header);
+            delete reinterpret_cast<safe_VkDrmFormatModifierPropertiesList2EXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkShaderModuleValidationCacheCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkShaderModuleValidationCacheCreateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
-            delete reinterpret_cast<const safe_VkPipelineViewportShadingRateImageStateCreateInfoNV *>(header);
+            delete reinterpret_cast<safe_VkPipelineViewportShadingRateImageStateCreateInfoNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShadingRateImageFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShadingRateImageFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShadingRateImagePropertiesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShadingRateImagePropertiesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
-            delete reinterpret_cast<const safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *>(header);
+            delete reinterpret_cast<safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
-            delete reinterpret_cast<const safe_VkWriteDescriptorSetAccelerationStructureNV *>(header);
+            delete reinterpret_cast<safe_VkWriteDescriptorSetAccelerationStructureNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceRayTracingPropertiesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingPropertiesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
-            delete reinterpret_cast<const safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV *>(header);
+            delete reinterpret_cast<safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceImageViewImageFormatInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceImageViewImageFormatInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkFilterCubicImageViewImageFormatPropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkFilterCubicImageViewImageFormatPropertiesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
-            delete reinterpret_cast<const safe_VkImportMemoryHostPointerInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkImportMemoryHostPointerInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
-            delete reinterpret_cast<const safe_VkPipelineCompilerControlCreateInfoAMD *>(header);
+            delete reinterpret_cast<safe_VkPipelineCompilerControlCreateInfoAMD *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderCorePropertiesAMD *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderCorePropertiesAMD *>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
-            delete reinterpret_cast<const safe_VkDeviceMemoryOverallocationCreateInfoAMD *>(header);
+            delete reinterpret_cast<safe_VkDeviceMemoryOverallocationCreateInfoAMD *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *>(header);
             break;
 #ifdef VK_USE_PLATFORM_GGP
         case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
-            delete reinterpret_cast<const safe_VkPresentFrameTokenGGP *>(header);
+            delete reinterpret_cast<safe_VkPresentFrameTokenGGP *>(header);
             break;
 #endif  // VK_USE_PLATFORM_GGP
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceMeshShaderFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceMeshShaderFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceMeshShaderPropertiesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceMeshShaderPropertiesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
-            delete reinterpret_cast<const safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV *>(header);
+            delete reinterpret_cast<safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceExclusiveScissorFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceExclusiveScissorFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
-            delete reinterpret_cast<const safe_VkQueueFamilyCheckpointPropertiesNV *>(header);
+            delete reinterpret_cast<safe_VkQueueFamilyCheckpointPropertiesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *>(header);
             break;
         case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
-            delete reinterpret_cast<const safe_VkQueryPoolPerformanceQueryCreateInfoINTEL *>(header);
+            delete reinterpret_cast<safe_VkQueryPoolPerformanceQueryCreateInfoINTEL *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDevicePCIBusInfoPropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDevicePCIBusInfoPropertiesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD:
-            delete reinterpret_cast<const safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD *>(header);
+            delete reinterpret_cast<safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD *>(header);
             break;
         case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
-            delete reinterpret_cast<const safe_VkSwapchainDisplayNativeHdrCreateInfoAMD *>(header);
+            delete reinterpret_cast<safe_VkSwapchainDisplayNativeHdrCreateInfoAMD *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkRenderPassFragmentDensityMapCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkRenderPassFragmentDensityMapCreateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderCoreProperties2AMD *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderCoreProperties2AMD *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkMemoryPriorityAllocateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkMemoryPriorityAllocateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkBufferDeviceAddressCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkBufferDeviceAddressCreateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkValidationFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkValidationFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
-            delete reinterpret_cast<const safe_VkPipelineCoverageReductionStateCreateInfoNV *>(header);
+            delete reinterpret_cast<safe_VkPipelineCoverageReductionStateCreateInfoNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceProvokingVertexFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceProvokingVertexFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceProvokingVertexPropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceProvokingVertexPropertiesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *>(header);
             break;
 #ifdef VK_USE_PLATFORM_WIN32_KHR
         case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkSurfaceFullScreenExclusiveInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkSurfaceFullScreenExclusiveInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
-            delete reinterpret_cast<const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT *>(header);
+            delete reinterpret_cast<safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
-            delete reinterpret_cast<const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT *>(header);
+            delete reinterpret_cast<safe_VkSurfaceFullScreenExclusiveWin32InfoEXT *>(header);
             break;
 #endif  // VK_USE_PLATFORM_WIN32_KHR
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceHostImageCopyFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceHostImageCopyFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceHostImageCopyPropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceHostImageCopyPropertiesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT:
-            delete reinterpret_cast<const safe_VkSubresourceHostMemcpySizeEXT *>(header);
+            delete reinterpret_cast<safe_VkSubresourceHostMemcpySizeEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT:
-            delete reinterpret_cast<const safe_VkHostImageCopyDevicePerformanceQueryEXT *>(header);
+            delete reinterpret_cast<safe_VkHostImageCopyDevicePerformanceQueryEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT:
-            delete reinterpret_cast<const safe_VkMemoryMapPlacedInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkMemoryMapPlacedInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT:
-            delete reinterpret_cast<const safe_VkSurfacePresentModeEXT *>(header);
+            delete reinterpret_cast<safe_VkSurfacePresentModeEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT:
-            delete reinterpret_cast<const safe_VkSurfacePresentScalingCapabilitiesEXT *>(header);
+            delete reinterpret_cast<safe_VkSurfacePresentScalingCapabilitiesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT:
-            delete reinterpret_cast<const safe_VkSurfacePresentModeCompatibilityEXT *>(header);
+            delete reinterpret_cast<safe_VkSurfacePresentModeCompatibilityEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkSwapchainPresentFenceInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkSwapchainPresentFenceInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkSwapchainPresentModesCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkSwapchainPresentModesCreateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkSwapchainPresentModeInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkSwapchainPresentModeInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkSwapchainPresentScalingCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkSwapchainPresentScalingCreateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
-            delete reinterpret_cast<const safe_VkGraphicsPipelineShaderGroupsCreateInfoNV *>(header);
+            delete reinterpret_cast<safe_VkGraphicsPipelineShaderGroupsCreateInfoNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceInheritedViewportScissorFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
-            delete reinterpret_cast<const safe_VkCommandBufferInheritanceViewportScissorInfoNV *>(header);
+            delete reinterpret_cast<safe_VkCommandBufferInheritanceViewportScissorInfoNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
-            delete reinterpret_cast<const safe_VkRenderPassTransformBeginInfoQCOM *>(header);
+            delete reinterpret_cast<safe_VkRenderPassTransformBeginInfoQCOM *>(header);
             break;
         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
-            delete reinterpret_cast<const safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM *>(header);
+            delete reinterpret_cast<safe_VkCommandBufferInheritanceRenderPassTransformInfoQCOM *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceDepthBiasControlFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT:
-            delete reinterpret_cast<const safe_VkDepthBiasRepresentationInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkDepthBiasRepresentationInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkDeviceDeviceMemoryReportCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkDeviceDeviceMemoryReportCreateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceRobustness2FeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceRobustness2FeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceRobustness2PropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceRobustness2PropertiesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkSamplerCustomBorderColorCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkSamplerCustomBorderColorCreateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceCustomBorderColorPropertiesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceCustomBorderColorFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDevicePresentBarrierFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDevicePresentBarrierFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV:
-            delete reinterpret_cast<const safe_VkSurfaceCapabilitiesPresentBarrierNV *>(header);
+            delete reinterpret_cast<safe_VkSurfaceCapabilitiesPresentBarrierNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV:
-            delete reinterpret_cast<const safe_VkSwapchainPresentBarrierCreateInfoNV *>(header);
+            delete reinterpret_cast<safe_VkSwapchainPresentBarrierCreateInfoNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceDiagnosticsConfigFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
-            delete reinterpret_cast<const safe_VkDeviceDiagnosticsConfigCreateInfoNV *>(header);
+            delete reinterpret_cast<safe_VkDeviceDiagnosticsConfigCreateInfoNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV:
-            delete reinterpret_cast<const safe_VkQueryLowLatencySupportNV *>(header);
+            delete reinterpret_cast<safe_VkQueryLowLatencySupportNV *>(header);
             break;
 #ifdef VK_USE_PLATFORM_METAL_EXT
         case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkExportMetalObjectCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkExportMetalObjectCreateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkExportMetalDeviceInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkExportMetalDeviceInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkExportMetalCommandQueueInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkExportMetalCommandQueueInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT:
-            delete reinterpret_cast<const safe_VkExportMetalBufferInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkExportMetalBufferInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT:
-            delete reinterpret_cast<const safe_VkImportMetalBufferInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkImportMetalBufferInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkExportMetalTextureInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkExportMetalTextureInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkImportMetalTextureInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkImportMetalTextureInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkExportMetalIOSurfaceInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkExportMetalIOSurfaceInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkImportMetalIOSurfaceInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkImportMetalIOSurfaceInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT:
-            delete reinterpret_cast<const safe_VkExportMetalSharedEventInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkExportMetalSharedEventInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT:
-            delete reinterpret_cast<const safe_VkImportMetalSharedEventInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkImportMetalSharedEventInfoEXT *>(header);
             break;
 #endif  // VK_USE_PLATFORM_METAL_EXT
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceDescriptorBufferPropertiesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceDescriptorBufferFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT:
-            delete reinterpret_cast<const safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT *>(header);
+            delete reinterpret_cast<safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkOpaqueCaptureDescriptorDataCreateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkGraphicsPipelineLibraryCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkGraphicsPipelineLibraryCreateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
-            delete reinterpret_cast<const safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV *>(header);
+            delete reinterpret_cast<safe_VkPipelineFragmentShadingRateEnumStateCreateInfoNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV:
-            delete reinterpret_cast<const safe_VkAccelerationStructureGeometryMotionTrianglesDataNV *>(header);
+            delete reinterpret_cast<safe_VkAccelerationStructureGeometryMotionTrianglesDataNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV:
-            delete reinterpret_cast<const safe_VkAccelerationStructureMotionInfoNV *>(header);
+            delete reinterpret_cast<safe_VkAccelerationStructureMotionInfoNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
-            delete reinterpret_cast<const safe_VkCopyCommandTransformInfoQCOM *>(header);
+            delete reinterpret_cast<safe_VkCopyCommandTransformInfoQCOM *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceImageCompressionControlFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
-            delete reinterpret_cast<const safe_VkImageCompressionControlEXT *>(header);
+            delete reinterpret_cast<safe_VkImageCompressionControlEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkImageCompressionPropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkImageCompressionPropertiesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDevice4444FormatsFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDevice4444FormatsFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceFaultFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceFaultFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkMutableDescriptorTypeCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkMutableDescriptorTypeCreateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceDrmPropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceDrmPropertiesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceAddressBindingReportFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT:
-            delete reinterpret_cast<const safe_VkDeviceAddressBindingCallbackDataEXT *>(header);
+            delete reinterpret_cast<safe_VkDeviceAddressBindingCallbackDataEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceDepthClipControlFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceDepthClipControlFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkPipelineViewportDepthClipControlCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkPipelineViewportDepthClipControlCreateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *>(header);
             break;
 #ifdef VK_USE_PLATFORM_FUCHSIA
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
-            delete reinterpret_cast<const safe_VkImportMemoryZirconHandleInfoFUCHSIA *>(header);
+            delete reinterpret_cast<safe_VkImportMemoryZirconHandleInfoFUCHSIA *>(header);
             break;
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA:
-            delete reinterpret_cast<const safe_VkImportMemoryBufferCollectionFUCHSIA *>(header);
+            delete reinterpret_cast<safe_VkImportMemoryBufferCollectionFUCHSIA *>(header);
             break;
         case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA:
-            delete reinterpret_cast<const safe_VkBufferCollectionImageCreateInfoFUCHSIA *>(header);
+            delete reinterpret_cast<safe_VkBufferCollectionImageCreateInfoFUCHSIA *>(header);
             break;
         case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA:
-            delete reinterpret_cast<const safe_VkBufferCollectionBufferCreateInfoFUCHSIA *>(header);
+            delete reinterpret_cast<safe_VkBufferCollectionBufferCreateInfoFUCHSIA *>(header);
             break;
 #endif  // VK_USE_PLATFORM_FUCHSIA
         case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI:
-            delete reinterpret_cast<const safe_VkSubpassShadingPipelineCreateInfoHUAWEI *>(header);
+            delete reinterpret_cast<safe_VkSubpassShadingPipelineCreateInfoHUAWEI *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDevicePipelinePropertiesFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceFrameBoundaryFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT:
-            delete reinterpret_cast<const safe_VkFrameBoundaryEXT *>(header);
+            delete reinterpret_cast<safe_VkFrameBoundaryEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT:
-            delete reinterpret_cast<const safe_VkSubpassResolvePerformanceQueryEXT *>(header);
+            delete reinterpret_cast<safe_VkSubpassResolvePerformanceQueryEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT:
-            delete reinterpret_cast<const safe_VkMultisampledRenderToSingleSampledInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkMultisampledRenderToSingleSampledInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceColorWriteEnableFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkPipelineColorWriteCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkPipelineColorWriteCreateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceImageViewMinLodFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkImageViewMinLodCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkImageViewMinLodCreateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceMultiDrawFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceMultiDrawFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceMultiDrawPropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceMultiDrawPropertiesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderTileImageFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderTileImageFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderTileImagePropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderTileImagePropertiesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceOpacityMicromapFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceOpacityMicromapPropertiesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT:
-            delete reinterpret_cast<const safe_VkAccelerationStructureTrianglesOpacityMicromapEXT *>(header);
+            delete reinterpret_cast<safe_VkAccelerationStructureTrianglesOpacityMicromapEXT *>(header);
             break;
 #ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceDisplacementMicromapFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceDisplacementMicromapPropertiesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV:
-            delete reinterpret_cast<const safe_VkAccelerationStructureTrianglesDisplacementMicromapNV *>(header);
+            delete reinterpret_cast<safe_VkAccelerationStructureTrianglesDisplacementMicromapNV *>(header);
             break;
 #endif  // VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkSamplerBorderColorComponentMappingCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkSamplerBorderColorComponentMappingCreateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderCorePropertiesARM *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderCorePropertiesARM *>(header);
             break;
         case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM:
-            delete reinterpret_cast<const safe_VkDeviceQueueShaderCoreControlCreateInfoARM *>(header);
+            delete reinterpret_cast<safe_VkDeviceQueueShaderCoreControlCreateInfoARM *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceSchedulingControlsFeaturesARM *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceSchedulingControlsFeaturesARM *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceSchedulingControlsPropertiesARM *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceSchedulingControlsPropertiesARM *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkImageViewSlicedCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkImageViewSlicedCreateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceRenderPassStripedFeaturesARM *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceRenderPassStripedFeaturesARM *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceRenderPassStripedPropertiesARM *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceRenderPassStripedPropertiesARM *>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM:
-            delete reinterpret_cast<const safe_VkRenderPassStripeBeginInfoARM *>(header);
+            delete reinterpret_cast<safe_VkRenderPassStripeBeginInfoARM *>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM:
-            delete reinterpret_cast<const safe_VkRenderPassStripeSubmitInfoARM *>(header);
+            delete reinterpret_cast<safe_VkRenderPassStripeSubmitInfoARM *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *>(header);
             break;
         case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM:
-            delete reinterpret_cast<const safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM *>(header);
+            delete reinterpret_cast<safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceMemoryDecompressionFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceMemoryDecompressionPropertiesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV:
-            delete reinterpret_cast<const safe_VkComputePipelineIndirectBufferInfoNV *>(header);
+            delete reinterpret_cast<safe_VkComputePipelineIndirectBufferInfoNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM:
-            delete reinterpret_cast<const safe_VkImageViewSampleWeightCreateInfoQCOM *>(header);
+            delete reinterpret_cast<safe_VkImageViewSampleWeightCreateInfoQCOM *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceImageProcessingFeaturesQCOM *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceImageProcessingFeaturesQCOM *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceImageProcessingPropertiesQCOM *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceImageProcessingPropertiesQCOM *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceNestedCommandBufferFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceNestedCommandBufferPropertiesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT:
-            delete reinterpret_cast<const safe_VkExternalMemoryAcquireUnmodifiedEXT *>(header);
+            delete reinterpret_cast<safe_VkExternalMemoryAcquireUnmodifiedEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT:
-            delete reinterpret_cast<const safe_VkRenderPassCreationControlEXT *>(header);
+            delete reinterpret_cast<safe_VkRenderPassCreationControlEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkRenderPassCreationFeedbackCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkRenderPassCreationFeedbackCreateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkRenderPassSubpassFeedbackCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkRenderPassSubpassFeedbackCreateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG:
-            delete reinterpret_cast<const safe_VkDirectDriverLoadingListLUNARG *>(header);
+            delete reinterpret_cast<safe_VkDirectDriverLoadingListLUNARG *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkPipelineShaderStageModuleIdentifierCreateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceOpticalFlowFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceOpticalFlowFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceOpticalFlowPropertiesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceOpticalFlowPropertiesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV:
-            delete reinterpret_cast<const safe_VkOpticalFlowImageFormatInfoNV *>(header);
+            delete reinterpret_cast<safe_VkOpticalFlowImageFormatInfoNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV:
-            delete reinterpret_cast<const safe_VkOpticalFlowSessionCreatePrivateDataInfoNV *>(header);
+            delete reinterpret_cast<safe_VkOpticalFlowSessionCreatePrivateDataInfoNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *>(header);
             break;
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID *>(header);
             break;
         case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID:
-            delete reinterpret_cast<const safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID *>(header);
+            delete reinterpret_cast<safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID *>(header);
             break;
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderObjectFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderObjectFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderObjectPropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderObjectPropertiesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceAmigoProfilingFeaturesSEC *>(header);
             break;
         case VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC:
-            delete reinterpret_cast<const safe_VkAmigoProfilingSubmitInfoSEC *>(header);
+            delete reinterpret_cast<safe_VkAmigoProfilingSubmitInfoSEC *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT:
-            delete reinterpret_cast<const safe_VkLayerSettingsCreateInfoEXT *>(header);
+            delete reinterpret_cast<safe_VkLayerSettingsCreateInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV:
-            delete reinterpret_cast<const safe_VkLatencySubmissionPresentIdNV *>(header);
+            delete reinterpret_cast<safe_VkLatencySubmissionPresentIdNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV:
-            delete reinterpret_cast<const safe_VkSwapchainLatencyCreateInfoNV *>(header);
+            delete reinterpret_cast<safe_VkSwapchainLatencyCreateInfoNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV:
-            delete reinterpret_cast<const safe_VkLatencySurfaceCapabilitiesNV *>(header);
+            delete reinterpret_cast<safe_VkLatencySurfaceCapabilitiesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *>(header);
             break;
         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM:
-            delete reinterpret_cast<const safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM *>(header);
+            delete reinterpret_cast<safe_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDevicePerStageDescriptorSetFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceImageProcessing2FeaturesQCOM *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceImageProcessing2PropertiesQCOM *>(header);
             break;
         case VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM:
-            delete reinterpret_cast<const safe_VkSamplerBlockMatchWindowCreateInfoQCOM *>(header);
+            delete reinterpret_cast<safe_VkSamplerBlockMatchWindowCreateInfoQCOM *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceCubicWeightsFeaturesQCOM *>(header);
             break;
         case VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM:
-            delete reinterpret_cast<const safe_VkSamplerCubicWeightsCreateInfoQCOM *>(header);
+            delete reinterpret_cast<safe_VkSamplerCubicWeightsCreateInfoQCOM *>(header);
             break;
         case VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM:
-            delete reinterpret_cast<const safe_VkBlitImageCubicWeightsInfoQCOM *>(header);
+            delete reinterpret_cast<safe_VkBlitImageCubicWeightsInfoQCOM *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *>(header);
             break;
         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM:
-            delete reinterpret_cast<const safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM *>(header);
+            delete reinterpret_cast<safe_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceCubicClampFeaturesQCOM *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceCubicClampFeaturesQCOM *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *>(header);
             break;
 #ifdef VK_USE_PLATFORM_SCREEN_QNX
         case VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX:
-            delete reinterpret_cast<const safe_VkScreenBufferFormatPropertiesQNX *>(header);
+            delete reinterpret_cast<safe_VkScreenBufferFormatPropertiesQNX *>(header);
             break;
         case VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX:
-            delete reinterpret_cast<const safe_VkImportScreenBufferInfoQNX *>(header);
+            delete reinterpret_cast<safe_VkImportScreenBufferInfoQNX *>(header);
             break;
         case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX:
-            delete reinterpret_cast<const safe_VkExternalFormatQNX *>(header);
+            delete reinterpret_cast<safe_VkExternalFormatQNX *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX *>(header);
             break;
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceLayeredDriverPropertiesMSFT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceRawAccessChainsFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceRawAccessChainsFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceRayTracingValidationFeaturesNV *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingValidationFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceImageAlignmentControlPropertiesMESA *>(header);
             break;
         case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA:
-            delete reinterpret_cast<const safe_VkImageAlignmentControlCreateInfoMESA *>(header);
+            delete reinterpret_cast<safe_VkImageAlignmentControlCreateInfoMESA *>(header);
             break;
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
-            delete reinterpret_cast<const safe_VkWriteDescriptorSetAccelerationStructureKHR *>(header);
+            delete reinterpret_cast<safe_VkWriteDescriptorSetAccelerationStructureKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceAccelerationStructureFeaturesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingPipelinePropertiesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceRayQueryFeaturesKHR *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceRayQueryFeaturesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceMeshShaderFeaturesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceMeshShaderFeaturesEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT:
-            delete reinterpret_cast<const safe_VkPhysicalDeviceMeshShaderPropertiesEXT *>(header);
+            delete reinterpret_cast<safe_VkPhysicalDeviceMeshShaderPropertiesEXT *>(header);
             break;
 
         default: // Encountered an unknown sType
             // If sType is in custom list, free custom struct memory and clean up
             for (auto item : custom_stype_info) {
                 if (item.first == static_cast<uint32_t>(header->sType)) {
-                    if (header->pNext) {
-                        FreePnextChain(header->pNext);
-                    }
-                    free(const_cast<void *>(pNext));
-                    pNext = nullptr;
+                    free(current);
                     break;
                 }
             }
-            if (pNext) {
-                FreePnextChain(header->pNext);
-            }
             break;
+        }
+        current = next;
     }
 }  // clang-format on
 

From 1b07de9a3a174b853833f7f87a824f20604266b9 Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Fri, 14 Jun 2024 12:27:28 -0700
Subject: [PATCH 033/106] build: Update to header 1.3.288

---
 include/vulkan/utility/vk_safe_struct.hpp   | 24 +++++++++
 include/vulkan/utility/vk_struct_helper.hpp |  1 +
 include/vulkan/vk_enum_string_helper.h      |  2 +
 scripts/known_good.json                     |  2 +-
 src/vulkan/vk_safe_struct_khr.cpp           | 55 +++++++++++++++++++++
 src/vulkan/vk_safe_struct_utils.cpp         |  6 +++
 6 files changed, 89 insertions(+), 1 deletion(-)

diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index d994cdb..6685de9 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -8497,6 +8497,30 @@ struct safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT {
         return reinterpret_cast<VkBindDescriptorBufferEmbeddedSamplersInfoEXT const*>(this);
     }
 };
+struct safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderRelaxedExtendedInstruction;
+
+    safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR(
+        const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR(
+        const safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR& operator=(
+        const safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR();
+    ~safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR();
+    void initialize(const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR* copy_src,
+                    PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR const*>(this);
+    }
+};
 struct safe_VkDebugReportCallbackCreateInfoEXT {
     VkStructureType sType;
     const void* pNext{};
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index f893bdf..4468d2b 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -453,6 +453,7 @@ template <> inline VkStructureType GetSType<VkPushDescriptorSetInfoKHR>() { retu
 template <> inline VkStructureType GetSType<VkPushDescriptorSetWithTemplateInfoKHR>() { return VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkSetDescriptorBufferOffsetsInfoEXT>() { return VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkBindDescriptorBufferEmbeddedSamplersInfoEXT>() { return VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkDebugReportCallbackCreateInfoEXT>() { return VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkPipelineRasterizationStateRasterizationOrderAMD>() { return VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD; }
 template <> inline VkStructureType GetSType<VkDebugMarkerObjectNameInfoEXT>() { return VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index f56ba03..d083911 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -1910,6 +1910,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT:
diff --git a/scripts/known_good.json b/scripts/known_good.json
index dc54022..f7662ef 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.3.287"
+            "commit": "v1.3.288"
         },
         {
             "name": "googletest",
diff --git a/src/vulkan/vk_safe_struct_khr.cpp b/src/vulkan/vk_safe_struct_khr.cpp
index d3bf001..80d9629 100644
--- a/src/vulkan/vk_safe_struct_khr.cpp
+++ b/src/vulkan/vk_safe_struct_khr.cpp
@@ -14084,6 +14084,61 @@ void safe_VkPushDescriptorSetWithTemplateInfoKHR::initialize(const safe_VkPushDe
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR::safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR(
+    const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), shaderRelaxedExtendedInstruction(in_struct->shaderRelaxedExtendedInstruction) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR::safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR),
+      pNext(nullptr),
+      shaderRelaxedExtendedInstruction() {}
+
+safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR::safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR(
+    const safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    shaderRelaxedExtendedInstruction = copy_src.shaderRelaxedExtendedInstruction;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR&
+safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderRelaxedExtendedInstruction = copy_src.shaderRelaxedExtendedInstruction;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR::
+    ~safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR::initialize(
+    const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderRelaxedExtendedInstruction = in_struct->shaderRelaxedExtendedInstruction;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR::initialize(
+    const safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderRelaxedExtendedInstruction = copy_src->shaderRelaxedExtendedInstruction;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkDeviceOrHostAddressConstKHR::safe_VkDeviceOrHostAddressConstKHR(const VkDeviceOrHostAddressConstKHR* in_struct,
                                                                        PNextCopyState*) {
     initialize(in_struct);
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index b443381..5f24df5 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -769,6 +769,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR:
                 safe_pNext = new safe_VkBindMemoryStatusKHR(reinterpret_cast<const VkBindMemoryStatusKHR *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
                 safe_pNext = new safe_VkDebugReportCallbackCreateInfoEXT(reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>(pNext), copy_state, false);
                 break;
@@ -2586,6 +2589,9 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR:
             delete reinterpret_cast<safe_VkBindMemoryStatusKHR *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR:
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *>(header);
+            break;
         case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
             delete reinterpret_cast<safe_VkDebugReportCallbackCreateInfoEXT *>(header);
             break;

From 60fe7d0c153dc07325a8fb45310723a1767db811 Mon Sep 17 00:00:00 2001
From: Daniel Rakos <daniel.rakos@rastergrid.com>
Date: Mon, 24 Jun 2024 17:48:37 +0200
Subject: [PATCH 034/106] build: Do not specialize source tree for API variants

---
 CMakeLists.txt             |  2 +-
 scripts/generate_source.py | 20 ++++++++++----------
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 042550b..674dcfe 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -41,7 +41,7 @@ if (VUL_IS_TOP_LEVEL)
     include(CMakePackageConfigHelpers)
 
     install(
-        DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/${API_TYPE}/"
+        DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/vulkan/"
         DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/vulkan"
     )
 
diff --git a/scripts/generate_source.py b/scripts/generate_source.py
index 0e1768d..941b021 100755
--- a/scripts/generate_source.py
+++ b/scripts/generate_source.py
@@ -44,53 +44,53 @@ def RunGenerators(api: str, registry: str, targetFilter: str) -> None:
         'vk_dispatch_table.h' : {
            'generator' : DispatchTableOutputGenerator,
            'genCombined': True,
-           'directory' : f'include/{api}/utility',
+           'directory' : f'include/vulkan/utility',
         },
         'vk_enum_string_helper.h' : {
             'generator' : EnumStringHelperOutputGenerator,
             'genCombined': True,
-            'directory' : f'include/{api}',
+            'directory' : f'include/vulkan',
         },
         'vk_format_utils.h' : {
             'generator' : FormatUtilsOutputGenerator,
             'genCombined': True,
-            'directory' : f'include/{api}/utility',
+            'directory' : f'include/vulkan/utility',
         },
         'vk_struct_helper.hpp' : {
             'generator' : StructHelperOutputGenerator,
             'genCombined': True,
-            'directory' : f'include/{api}/utility',
+            'directory' : f'include/vulkan/utility',
         },
         'vk_safe_struct.hpp' : {
             'generator' : SafeStructOutputGenerator,
             'genCombined': True,
-            'directory' : f'include/{api}/utility',
+            'directory' : f'include/vulkan/utility',
         },
         'vk_safe_struct_utils.cpp' : {
             'generator' : SafeStructOutputGenerator,
             'genCombined': True,
-            'directory' : f'src/{api}',
+            'directory' : f'src/vulkan',
         },
         'vk_safe_struct_core.cpp' : {
             'generator' : SafeStructOutputGenerator,
             'genCombined': True,
             'regenerate' : True,
-            'directory' : f'src/{api}',
+            'directory' : f'src/vulkan',
         },
         'vk_safe_struct_khr.cpp' : {
             'generator' : SafeStructOutputGenerator,
             'genCombined': True,
-            'directory' : f'src/{api}',
+            'directory' : f'src/vulkan',
         },
         'vk_safe_struct_ext.cpp' : {
             'generator' : SafeStructOutputGenerator,
             'genCombined': True,
-            'directory' : f'src/{api}',
+            'directory' : f'src/vulkan',
         },
         'vk_safe_struct_vendor.cpp' : {
             'generator' : SafeStructOutputGenerator,
             'genCombined': True,
-            'directory' : f'src/{api}',
+            'directory' : f'src/vulkan',
         },
     }
 

From ef99ad5203b8f0f410dd3bac11fa193c48d80dd8 Mon Sep 17 00:00:00 2001
From: Charles Giessen <charles@lunarg.com>
Date: Thu, 27 Jun 2024 10:35:07 -0500
Subject: [PATCH 035/106] Update .gitignore

---
 .gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitignore b/.gitignore
index d61e226..b220ab5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -10,6 +10,7 @@ build
 .vscode/
 **/.*.swp
 external
+.cache
 
 # Chromium build artifacts
 .cipd/

From 144ce1b3c19caf29a69fca192fb168f3aa7ab9aa Mon Sep 17 00:00:00 2001
From: Charles Giessen <charles@lunarg.com>
Date: Thu, 27 Jun 2024 10:43:03 -0500
Subject: [PATCH 036/106] Better declare GetObjectType()'s lack of 32 bit
 support

Create a new default specialization for 32 bit which indicates to the
user that the GetObjectType() helper does not work in 32 bit builds.
---
 include/vulkan/utility/vk_struct_helper.hpp   | 10 +++++++---
 scripts/generators/struct_helper_generator.py | 10 +++++++---
 2 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index 4468d2b..6993f5a 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -1038,13 +1038,12 @@ class InitStructHelper {
         return InitStruct<T>(p_next);
     }
 };
-
+#if VK_USE_64_BIT_PTR_DEFINES == 1
 template<typename T> VkObjectType GetObjectType() {
     static_assert(sizeof(T) == 0, "GetObjectType() is being used with an unsupported Type! Is the code-gen up to date?");
     return VK_OBJECT_TYPE_UNKNOWN;
 }
 
-#if VK_USE_64_BIT_PTR_DEFINES == 1
 template<> inline VkObjectType GetObjectType<VkBuffer>() { return VK_OBJECT_TYPE_BUFFER; }
 template<> inline VkObjectType GetObjectType<VkImage>() { return VK_OBJECT_TYPE_IMAGE; }
 template<> inline VkObjectType GetObjectType<VkInstance>() { return VK_OBJECT_TYPE_INSTANCE; }
@@ -1098,7 +1097,12 @@ template<> inline VkObjectType GetObjectType<VkMicromapEXT>() { return VK_OBJECT
 template<> inline VkObjectType GetObjectType<VkOpticalFlowSessionNV>() { return VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV; }
 template<> inline VkObjectType GetObjectType<VkShaderEXT>() { return VK_OBJECT_TYPE_SHADER_EXT; }
 
-#endif // VK_USE_64_BIT_PTR_DEFINES == 1
+# else // 32 bit
+template<typename T> VkObjectType GetObjectType() {
+    static_assert(sizeof(T) == 0, "GetObjectType() does not support 32 bit builds! This is a limitation of the vulkan.h headers");
+    return VK_OBJECT_TYPE_UNKNOWN;
+}
+# endif // VK_USE_64_BIT_PTR_DEFINES == 1
 } // namespace vku
 
 // NOLINTEND// clang-format on
diff --git a/scripts/generators/struct_helper_generator.py b/scripts/generators/struct_helper_generator.py
index b84a1ca..f92a872 100644
--- a/scripts/generators/struct_helper_generator.py
+++ b/scripts/generators/struct_helper_generator.py
@@ -123,20 +123,24 @@ class InitStructHelper {
         return InitStruct<T>(p_next);
     }
 };
-
+#if VK_USE_64_BIT_PTR_DEFINES == 1
 template<typename T> VkObjectType GetObjectType() {
     static_assert(sizeof(T) == 0, "GetObjectType() is being used with an unsupported Type! Is the code-gen up to date?");
     return VK_OBJECT_TYPE_UNKNOWN;
 }
 
-#if VK_USE_64_BIT_PTR_DEFINES == 1
 ''')
         for handle in self.vk.handles.values():
             out.extend(guard_helper.add_guard(handle.protect))
             out.append(f'template<> inline VkObjectType GetObjectType<{handle.name}>() {{ return {handle.type}; }}\n')
         out.extend(guard_helper.add_guard(None))
         out.append('''
-#endif // VK_USE_64_BIT_PTR_DEFINES == 1
+# else // 32 bit
+template<typename T> VkObjectType GetObjectType() {
+    static_assert(sizeof(T) == 0, "GetObjectType() does not support 32 bit builds! This is a limitation of the vulkan.h headers");
+    return VK_OBJECT_TYPE_UNKNOWN;
+}
+# endif // VK_USE_64_BIT_PTR_DEFINES == 1
 } // namespace vku
 \n''')
 

From df78ee39d2ff6c10b4f7f2ae06c7ca64524f9e25 Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Fri, 28 Jun 2024 10:24:45 -0700
Subject: [PATCH 037/106] build: Update to header 1.3.289

---
 include/vulkan/utility/vk_safe_struct.hpp   | 106 ++++++
 include/vulkan/utility/vk_struct_helper.hpp |   5 +
 include/vulkan/vk_enum_string_helper.h      |  34 +-
 scripts/known_good.json                     |   5 +-
 src/vulkan/vk_safe_struct_khr.cpp           | 358 ++++++++++++++++++++
 src/vulkan/vk_safe_struct_utils.cpp         |  24 ++
 6 files changed, 527 insertions(+), 5 deletions(-)

diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index 6685de9..e168920 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -8521,6 +8521,112 @@ struct safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR {
         return reinterpret_cast<VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR const*>(this);
     }
 };
+struct safe_VkPhysicalDeviceMaintenance7FeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 maintenance7;
+
+    safe_VkPhysicalDeviceMaintenance7FeaturesKHR(const VkPhysicalDeviceMaintenance7FeaturesKHR* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceMaintenance7FeaturesKHR(const safe_VkPhysicalDeviceMaintenance7FeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceMaintenance7FeaturesKHR& operator=(const safe_VkPhysicalDeviceMaintenance7FeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceMaintenance7FeaturesKHR();
+    ~safe_VkPhysicalDeviceMaintenance7FeaturesKHR();
+    void initialize(const VkPhysicalDeviceMaintenance7FeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMaintenance7FeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMaintenance7FeaturesKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceMaintenance7FeaturesKHR*>(this); }
+    VkPhysicalDeviceMaintenance7FeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMaintenance7FeaturesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceMaintenance7PropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 robustFragmentShadingRateAttachmentAccess;
+    VkBool32 separateDepthStencilAttachmentAccess;
+    uint32_t maxDescriptorSetTotalUniformBuffersDynamic;
+    uint32_t maxDescriptorSetTotalStorageBuffersDynamic;
+    uint32_t maxDescriptorSetTotalBuffersDynamic;
+    uint32_t maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic;
+    uint32_t maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic;
+    uint32_t maxDescriptorSetUpdateAfterBindTotalBuffersDynamic;
+
+    safe_VkPhysicalDeviceMaintenance7PropertiesKHR(const VkPhysicalDeviceMaintenance7PropertiesKHR* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceMaintenance7PropertiesKHR(const safe_VkPhysicalDeviceMaintenance7PropertiesKHR& copy_src);
+    safe_VkPhysicalDeviceMaintenance7PropertiesKHR& operator=(const safe_VkPhysicalDeviceMaintenance7PropertiesKHR& copy_src);
+    safe_VkPhysicalDeviceMaintenance7PropertiesKHR();
+    ~safe_VkPhysicalDeviceMaintenance7PropertiesKHR();
+    void initialize(const VkPhysicalDeviceMaintenance7PropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMaintenance7PropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMaintenance7PropertiesKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceMaintenance7PropertiesKHR*>(this); }
+    VkPhysicalDeviceMaintenance7PropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMaintenance7PropertiesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceLayeredApiPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t vendorID;
+    uint32_t deviceID;
+    VkPhysicalDeviceLayeredApiKHR layeredAPI;
+    char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
+
+    safe_VkPhysicalDeviceLayeredApiPropertiesKHR(const VkPhysicalDeviceLayeredApiPropertiesKHR* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceLayeredApiPropertiesKHR(const safe_VkPhysicalDeviceLayeredApiPropertiesKHR& copy_src);
+    safe_VkPhysicalDeviceLayeredApiPropertiesKHR& operator=(const safe_VkPhysicalDeviceLayeredApiPropertiesKHR& copy_src);
+    safe_VkPhysicalDeviceLayeredApiPropertiesKHR();
+    ~safe_VkPhysicalDeviceLayeredApiPropertiesKHR();
+    void initialize(const VkPhysicalDeviceLayeredApiPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceLayeredApiPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceLayeredApiPropertiesKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceLayeredApiPropertiesKHR*>(this); }
+    VkPhysicalDeviceLayeredApiPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceLayeredApiPropertiesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceLayeredApiPropertiesListKHR {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t layeredApiCount;
+    safe_VkPhysicalDeviceLayeredApiPropertiesKHR* pLayeredApis{};
+
+    safe_VkPhysicalDeviceLayeredApiPropertiesListKHR(const VkPhysicalDeviceLayeredApiPropertiesListKHR* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceLayeredApiPropertiesListKHR(const safe_VkPhysicalDeviceLayeredApiPropertiesListKHR& copy_src);
+    safe_VkPhysicalDeviceLayeredApiPropertiesListKHR& operator=(const safe_VkPhysicalDeviceLayeredApiPropertiesListKHR& copy_src);
+    safe_VkPhysicalDeviceLayeredApiPropertiesListKHR();
+    ~safe_VkPhysicalDeviceLayeredApiPropertiesListKHR();
+    void initialize(const VkPhysicalDeviceLayeredApiPropertiesListKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceLayeredApiPropertiesListKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceLayeredApiPropertiesListKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceLayeredApiPropertiesListKHR*>(this);
+    }
+    VkPhysicalDeviceLayeredApiPropertiesListKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceLayeredApiPropertiesListKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    safe_VkPhysicalDeviceProperties2 properties;
+
+    safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR(const VkPhysicalDeviceLayeredApiVulkanPropertiesKHR* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR(const safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR& copy_src);
+    safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR& operator=(
+        const safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR& copy_src);
+    safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR();
+    ~safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR();
+    void initialize(const VkPhysicalDeviceLayeredApiVulkanPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceLayeredApiVulkanPropertiesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceLayeredApiVulkanPropertiesKHR*>(this);
+    }
+    VkPhysicalDeviceLayeredApiVulkanPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceLayeredApiVulkanPropertiesKHR const*>(this);
+    }
+};
 struct safe_VkDebugReportCallbackCreateInfoEXT {
     VkStructureType sType;
     const void* pNext{};
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index 6993f5a..c94c8f8 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -454,6 +454,11 @@ template <> inline VkStructureType GetSType<VkPushDescriptorSetWithTemplateInfoK
 template <> inline VkStructureType GetSType<VkSetDescriptorBufferOffsetsInfoEXT>() { return VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkBindDescriptorBufferEmbeddedSamplersInfoEXT>() { return VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance7FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance7PropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceLayeredApiPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceLayeredApiPropertiesListKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceLayeredApiVulkanPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR; }
 template <> inline VkStructureType GetSType<VkDebugReportCallbackCreateInfoEXT>() { return VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkPipelineRasterizationStateRasterizationOrderAMD>() { return VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD; }
 template <> inline VkStructureType GetSType<VkDebugMarkerObjectNameInfoEXT>() { return VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index d083911..8835cfb 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -1912,6 +1912,16 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT:
@@ -3410,8 +3420,8 @@ static inline const char* string_VkSubpassContents(VkSubpassContents input_value
             return "VK_SUBPASS_CONTENTS_INLINE";
         case VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS:
             return "VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS";
-        case VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_EXT:
-            return "VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_EXT";
+        case VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR:
+            return "VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR";
         default:
             return "Unhandled VkSubpassContents";
     }
@@ -3836,6 +3846,22 @@ static inline const char* string_VkTimeDomainKHR(VkTimeDomainKHR input_value) {
             return "Unhandled VkTimeDomainKHR";
     }
 }
+static inline const char* string_VkPhysicalDeviceLayeredApiKHR(VkPhysicalDeviceLayeredApiKHR input_value) {
+    switch (input_value) {
+        case VK_PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR:
+            return "VK_PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR";
+        case VK_PHYSICAL_DEVICE_LAYERED_API_D3D12_KHR:
+            return "VK_PHYSICAL_DEVICE_LAYERED_API_D3D12_KHR";
+        case VK_PHYSICAL_DEVICE_LAYERED_API_METAL_KHR:
+            return "VK_PHYSICAL_DEVICE_LAYERED_API_METAL_KHR";
+        case VK_PHYSICAL_DEVICE_LAYERED_API_OPENGL_KHR:
+            return "VK_PHYSICAL_DEVICE_LAYERED_API_OPENGL_KHR";
+        case VK_PHYSICAL_DEVICE_LAYERED_API_OPENGLES_KHR:
+            return "VK_PHYSICAL_DEVICE_LAYERED_API_OPENGLES_KHR";
+        default:
+            return "Unhandled VkPhysicalDeviceLayeredApiKHR";
+    }
+}
 static inline const char* string_VkDebugReportObjectTypeEXT(VkDebugReportObjectTypeEXT input_value) {
     switch (input_value) {
         case VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT:
@@ -7178,10 +7204,10 @@ static inline const char* string_VkRenderingFlagBits(VkRenderingFlagBits input_v
             return "VK_RENDERING_SUSPENDING_BIT";
         case VK_RENDERING_RESUMING_BIT:
             return "VK_RENDERING_RESUMING_BIT";
-        case VK_RENDERING_CONTENTS_INLINE_BIT_EXT:
-            return "VK_RENDERING_CONTENTS_INLINE_BIT_EXT";
         case VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT:
             return "VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT";
+        case VK_RENDERING_CONTENTS_INLINE_BIT_KHR:
+            return "VK_RENDERING_CONTENTS_INLINE_BIT_KHR";
         default:
             return "Unhandled VkRenderingFlagBits";
     }
diff --git a/scripts/known_good.json b/scripts/known_good.json
index f7662ef..b9219c2 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,10 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.3.288"
+            "cmake_options": [
+                "-DVULKAN_HEADERS_ENABLE_MODULE=OFF"
+            ],
+            "commit": "v1.3.289"
         },
         {
             "name": "googletest",
diff --git a/src/vulkan/vk_safe_struct_khr.cpp b/src/vulkan/vk_safe_struct_khr.cpp
index 80d9629..edbd7e2 100644
--- a/src/vulkan/vk_safe_struct_khr.cpp
+++ b/src/vulkan/vk_safe_struct_khr.cpp
@@ -14139,6 +14139,364 @@ void safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR::initializ
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkPhysicalDeviceMaintenance7FeaturesKHR::safe_VkPhysicalDeviceMaintenance7FeaturesKHR(
+    const VkPhysicalDeviceMaintenance7FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), maintenance7(in_struct->maintenance7) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMaintenance7FeaturesKHR::safe_VkPhysicalDeviceMaintenance7FeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR), pNext(nullptr), maintenance7() {}
+
+safe_VkPhysicalDeviceMaintenance7FeaturesKHR::safe_VkPhysicalDeviceMaintenance7FeaturesKHR(
+    const safe_VkPhysicalDeviceMaintenance7FeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    maintenance7 = copy_src.maintenance7;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMaintenance7FeaturesKHR& safe_VkPhysicalDeviceMaintenance7FeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceMaintenance7FeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maintenance7 = copy_src.maintenance7;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMaintenance7FeaturesKHR::~safe_VkPhysicalDeviceMaintenance7FeaturesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceMaintenance7FeaturesKHR::initialize(const VkPhysicalDeviceMaintenance7FeaturesKHR* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maintenance7 = in_struct->maintenance7;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMaintenance7FeaturesKHR::initialize(const safe_VkPhysicalDeviceMaintenance7FeaturesKHR* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maintenance7 = copy_src->maintenance7;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceMaintenance7PropertiesKHR::safe_VkPhysicalDeviceMaintenance7PropertiesKHR(
+    const VkPhysicalDeviceMaintenance7PropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      robustFragmentShadingRateAttachmentAccess(in_struct->robustFragmentShadingRateAttachmentAccess),
+      separateDepthStencilAttachmentAccess(in_struct->separateDepthStencilAttachmentAccess),
+      maxDescriptorSetTotalUniformBuffersDynamic(in_struct->maxDescriptorSetTotalUniformBuffersDynamic),
+      maxDescriptorSetTotalStorageBuffersDynamic(in_struct->maxDescriptorSetTotalStorageBuffersDynamic),
+      maxDescriptorSetTotalBuffersDynamic(in_struct->maxDescriptorSetTotalBuffersDynamic),
+      maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic(
+          in_struct->maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic),
+      maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic(
+          in_struct->maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic),
+      maxDescriptorSetUpdateAfterBindTotalBuffersDynamic(in_struct->maxDescriptorSetUpdateAfterBindTotalBuffersDynamic) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMaintenance7PropertiesKHR::safe_VkPhysicalDeviceMaintenance7PropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR),
+      pNext(nullptr),
+      robustFragmentShadingRateAttachmentAccess(),
+      separateDepthStencilAttachmentAccess(),
+      maxDescriptorSetTotalUniformBuffersDynamic(),
+      maxDescriptorSetTotalStorageBuffersDynamic(),
+      maxDescriptorSetTotalBuffersDynamic(),
+      maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic(),
+      maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic(),
+      maxDescriptorSetUpdateAfterBindTotalBuffersDynamic() {}
+
+safe_VkPhysicalDeviceMaintenance7PropertiesKHR::safe_VkPhysicalDeviceMaintenance7PropertiesKHR(
+    const safe_VkPhysicalDeviceMaintenance7PropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    robustFragmentShadingRateAttachmentAccess = copy_src.robustFragmentShadingRateAttachmentAccess;
+    separateDepthStencilAttachmentAccess = copy_src.separateDepthStencilAttachmentAccess;
+    maxDescriptorSetTotalUniformBuffersDynamic = copy_src.maxDescriptorSetTotalUniformBuffersDynamic;
+    maxDescriptorSetTotalStorageBuffersDynamic = copy_src.maxDescriptorSetTotalStorageBuffersDynamic;
+    maxDescriptorSetTotalBuffersDynamic = copy_src.maxDescriptorSetTotalBuffersDynamic;
+    maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic = copy_src.maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic;
+    maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic = copy_src.maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic;
+    maxDescriptorSetUpdateAfterBindTotalBuffersDynamic = copy_src.maxDescriptorSetUpdateAfterBindTotalBuffersDynamic;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMaintenance7PropertiesKHR& safe_VkPhysicalDeviceMaintenance7PropertiesKHR::operator=(
+    const safe_VkPhysicalDeviceMaintenance7PropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    robustFragmentShadingRateAttachmentAccess = copy_src.robustFragmentShadingRateAttachmentAccess;
+    separateDepthStencilAttachmentAccess = copy_src.separateDepthStencilAttachmentAccess;
+    maxDescriptorSetTotalUniformBuffersDynamic = copy_src.maxDescriptorSetTotalUniformBuffersDynamic;
+    maxDescriptorSetTotalStorageBuffersDynamic = copy_src.maxDescriptorSetTotalStorageBuffersDynamic;
+    maxDescriptorSetTotalBuffersDynamic = copy_src.maxDescriptorSetTotalBuffersDynamic;
+    maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic = copy_src.maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic;
+    maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic = copy_src.maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic;
+    maxDescriptorSetUpdateAfterBindTotalBuffersDynamic = copy_src.maxDescriptorSetUpdateAfterBindTotalBuffersDynamic;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMaintenance7PropertiesKHR::~safe_VkPhysicalDeviceMaintenance7PropertiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceMaintenance7PropertiesKHR::initialize(const VkPhysicalDeviceMaintenance7PropertiesKHR* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    robustFragmentShadingRateAttachmentAccess = in_struct->robustFragmentShadingRateAttachmentAccess;
+    separateDepthStencilAttachmentAccess = in_struct->separateDepthStencilAttachmentAccess;
+    maxDescriptorSetTotalUniformBuffersDynamic = in_struct->maxDescriptorSetTotalUniformBuffersDynamic;
+    maxDescriptorSetTotalStorageBuffersDynamic = in_struct->maxDescriptorSetTotalStorageBuffersDynamic;
+    maxDescriptorSetTotalBuffersDynamic = in_struct->maxDescriptorSetTotalBuffersDynamic;
+    maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic =
+        in_struct->maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic;
+    maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic =
+        in_struct->maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic;
+    maxDescriptorSetUpdateAfterBindTotalBuffersDynamic = in_struct->maxDescriptorSetUpdateAfterBindTotalBuffersDynamic;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMaintenance7PropertiesKHR::initialize(const safe_VkPhysicalDeviceMaintenance7PropertiesKHR* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    robustFragmentShadingRateAttachmentAccess = copy_src->robustFragmentShadingRateAttachmentAccess;
+    separateDepthStencilAttachmentAccess = copy_src->separateDepthStencilAttachmentAccess;
+    maxDescriptorSetTotalUniformBuffersDynamic = copy_src->maxDescriptorSetTotalUniformBuffersDynamic;
+    maxDescriptorSetTotalStorageBuffersDynamic = copy_src->maxDescriptorSetTotalStorageBuffersDynamic;
+    maxDescriptorSetTotalBuffersDynamic = copy_src->maxDescriptorSetTotalBuffersDynamic;
+    maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic = copy_src->maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic;
+    maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic = copy_src->maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic;
+    maxDescriptorSetUpdateAfterBindTotalBuffersDynamic = copy_src->maxDescriptorSetUpdateAfterBindTotalBuffersDynamic;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceLayeredApiPropertiesKHR::safe_VkPhysicalDeviceLayeredApiPropertiesKHR(
+    const VkPhysicalDeviceLayeredApiPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), vendorID(in_struct->vendorID), deviceID(in_struct->deviceID), layeredAPI(in_struct->layeredAPI) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    for (uint32_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; ++i) {
+        deviceName[i] = in_struct->deviceName[i];
+    }
+}
+
+safe_VkPhysicalDeviceLayeredApiPropertiesKHR::safe_VkPhysicalDeviceLayeredApiPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR), pNext(nullptr), vendorID(), deviceID(), layeredAPI() {}
+
+safe_VkPhysicalDeviceLayeredApiPropertiesKHR::safe_VkPhysicalDeviceLayeredApiPropertiesKHR(
+    const safe_VkPhysicalDeviceLayeredApiPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    vendorID = copy_src.vendorID;
+    deviceID = copy_src.deviceID;
+    layeredAPI = copy_src.layeredAPI;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; ++i) {
+        deviceName[i] = copy_src.deviceName[i];
+    }
+}
+
+safe_VkPhysicalDeviceLayeredApiPropertiesKHR& safe_VkPhysicalDeviceLayeredApiPropertiesKHR::operator=(
+    const safe_VkPhysicalDeviceLayeredApiPropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    vendorID = copy_src.vendorID;
+    deviceID = copy_src.deviceID;
+    layeredAPI = copy_src.layeredAPI;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; ++i) {
+        deviceName[i] = copy_src.deviceName[i];
+    }
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceLayeredApiPropertiesKHR::~safe_VkPhysicalDeviceLayeredApiPropertiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceLayeredApiPropertiesKHR::initialize(const VkPhysicalDeviceLayeredApiPropertiesKHR* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    vendorID = in_struct->vendorID;
+    deviceID = in_struct->deviceID;
+    layeredAPI = in_struct->layeredAPI;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    for (uint32_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; ++i) {
+        deviceName[i] = in_struct->deviceName[i];
+    }
+}
+
+void safe_VkPhysicalDeviceLayeredApiPropertiesKHR::initialize(const safe_VkPhysicalDeviceLayeredApiPropertiesKHR* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    vendorID = copy_src->vendorID;
+    deviceID = copy_src->deviceID;
+    layeredAPI = copy_src->layeredAPI;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; ++i) {
+        deviceName[i] = copy_src->deviceName[i];
+    }
+}
+
+safe_VkPhysicalDeviceLayeredApiPropertiesListKHR::safe_VkPhysicalDeviceLayeredApiPropertiesListKHR(
+    const VkPhysicalDeviceLayeredApiPropertiesListKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), layeredApiCount(in_struct->layeredApiCount), pLayeredApis(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (layeredApiCount && in_struct->pLayeredApis) {
+        pLayeredApis = new safe_VkPhysicalDeviceLayeredApiPropertiesKHR[layeredApiCount];
+        for (uint32_t i = 0; i < layeredApiCount; ++i) {
+            pLayeredApis[i].initialize(&in_struct->pLayeredApis[i]);
+        }
+    }
+}
+
+safe_VkPhysicalDeviceLayeredApiPropertiesListKHR::safe_VkPhysicalDeviceLayeredApiPropertiesListKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR),
+      pNext(nullptr),
+      layeredApiCount(),
+      pLayeredApis(nullptr) {}
+
+safe_VkPhysicalDeviceLayeredApiPropertiesListKHR::safe_VkPhysicalDeviceLayeredApiPropertiesListKHR(
+    const safe_VkPhysicalDeviceLayeredApiPropertiesListKHR& copy_src) {
+    sType = copy_src.sType;
+    layeredApiCount = copy_src.layeredApiCount;
+    pLayeredApis = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (layeredApiCount && copy_src.pLayeredApis) {
+        pLayeredApis = new safe_VkPhysicalDeviceLayeredApiPropertiesKHR[layeredApiCount];
+        for (uint32_t i = 0; i < layeredApiCount; ++i) {
+            pLayeredApis[i].initialize(&copy_src.pLayeredApis[i]);
+        }
+    }
+}
+
+safe_VkPhysicalDeviceLayeredApiPropertiesListKHR& safe_VkPhysicalDeviceLayeredApiPropertiesListKHR::operator=(
+    const safe_VkPhysicalDeviceLayeredApiPropertiesListKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pLayeredApis) delete[] pLayeredApis;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    layeredApiCount = copy_src.layeredApiCount;
+    pLayeredApis = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (layeredApiCount && copy_src.pLayeredApis) {
+        pLayeredApis = new safe_VkPhysicalDeviceLayeredApiPropertiesKHR[layeredApiCount];
+        for (uint32_t i = 0; i < layeredApiCount; ++i) {
+            pLayeredApis[i].initialize(&copy_src.pLayeredApis[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceLayeredApiPropertiesListKHR::~safe_VkPhysicalDeviceLayeredApiPropertiesListKHR() {
+    if (pLayeredApis) delete[] pLayeredApis;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceLayeredApiPropertiesListKHR::initialize(const VkPhysicalDeviceLayeredApiPropertiesListKHR* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pLayeredApis) delete[] pLayeredApis;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    layeredApiCount = in_struct->layeredApiCount;
+    pLayeredApis = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (layeredApiCount && in_struct->pLayeredApis) {
+        pLayeredApis = new safe_VkPhysicalDeviceLayeredApiPropertiesKHR[layeredApiCount];
+        for (uint32_t i = 0; i < layeredApiCount; ++i) {
+            pLayeredApis[i].initialize(&in_struct->pLayeredApis[i]);
+        }
+    }
+}
+
+void safe_VkPhysicalDeviceLayeredApiPropertiesListKHR::initialize(const safe_VkPhysicalDeviceLayeredApiPropertiesListKHR* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    layeredApiCount = copy_src->layeredApiCount;
+    pLayeredApis = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (layeredApiCount && copy_src->pLayeredApis) {
+        pLayeredApis = new safe_VkPhysicalDeviceLayeredApiPropertiesKHR[layeredApiCount];
+        for (uint32_t i = 0; i < layeredApiCount; ++i) {
+            pLayeredApis[i].initialize(&copy_src->pLayeredApis[i]);
+        }
+    }
+}
+
+safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR::safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR(
+    const VkPhysicalDeviceLayeredApiVulkanPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), properties(&in_struct->properties) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR::safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR), pNext(nullptr) {}
+
+safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR::safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR(
+    const safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    properties.initialize(&copy_src.properties);
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR& safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR::operator=(
+    const safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    properties.initialize(&copy_src.properties);
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR::~safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR::initialize(const VkPhysicalDeviceLayeredApiVulkanPropertiesKHR* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    properties.initialize(&in_struct->properties);
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR::initialize(
+    const safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    properties.initialize(&copy_src->properties);
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkDeviceOrHostAddressConstKHR::safe_VkDeviceOrHostAddressConstKHR(const VkDeviceOrHostAddressConstKHR* in_struct,
                                                                        PNextCopyState*) {
     initialize(in_struct);
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index 5f24df5..3c60c55 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -772,6 +772,18 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR:
                 safe_pNext = new safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceMaintenance7FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceMaintenance7FeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceMaintenance7PropertiesKHR(reinterpret_cast<const VkPhysicalDeviceMaintenance7PropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceLayeredApiPropertiesListKHR(reinterpret_cast<const VkPhysicalDeviceLayeredApiPropertiesListKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR(reinterpret_cast<const VkPhysicalDeviceLayeredApiVulkanPropertiesKHR *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
                 safe_pNext = new safe_VkDebugReportCallbackCreateInfoEXT(reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>(pNext), copy_state, false);
                 break;
@@ -2592,6 +2604,18 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR:
             delete reinterpret_cast<safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR:
+            delete reinterpret_cast<safe_VkPhysicalDeviceMaintenance7FeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR:
+            delete reinterpret_cast<safe_VkPhysicalDeviceMaintenance7PropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR:
+            delete reinterpret_cast<safe_VkPhysicalDeviceLayeredApiPropertiesListKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR:
+            delete reinterpret_cast<safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR *>(header);
+            break;
         case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
             delete reinterpret_cast<safe_VkDebugReportCallbackCreateInfoEXT *>(header);
             break;

From d13c1ee715c4674237aca1c775479e1edde87d3c Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 8 Jul 2024 15:32:18 +0000
Subject: [PATCH 038/106] build(deps): Bump fsfe/reuse-action from 3 to 4

Bumps [fsfe/reuse-action](https://github.com/fsfe/reuse-action) from 3 to 4.
- [Release notes](https://github.com/fsfe/reuse-action/releases)
- [Commits](https://github.com/fsfe/reuse-action/compare/v3...v4)

---
updated-dependencies:
- dependency-name: fsfe/reuse-action
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 .github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 1a7efcc..c2946e2 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -86,7 +86,7 @@ jobs:
     steps:
     - uses: actions/checkout@v4
     - name: REUSE Compliance Check
-      uses: fsfe/reuse-action@v3
+      uses: fsfe/reuse-action@v4
 
   # Test to ensure we don't accidentally break the Chromium build.
   chromium:

From 5f26cf65a18bc89a8e3d6569c14314b6fdac8d4d Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Fri, 12 Jul 2024 10:47:20 -0700
Subject: [PATCH 039/106] build: Update to header 1.3.290

---
 scripts/known_good.json | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/scripts/known_good.json b/scripts/known_good.json
index b9219c2..60c4cd0 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,10 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "cmake_options": [
-                "-DVULKAN_HEADERS_ENABLE_MODULE=OFF"
-            ],
-            "commit": "v1.3.289"
+            "commit": "v1.3.290"
         },
         {
             "name": "googletest",
@@ -49,4 +46,4 @@
         "googletest": "GOOGLETEST_INSTALL_DIR",
         "magic_enum": "MAGIC_ENUM_INSTALL_DIR"
     }
-}
\ No newline at end of file
+}

From 9479047902e8031210b1bb33a8850e32b313dd25 Mon Sep 17 00:00:00 2001
From: Arno <arno@lunarg.com>
Date: Wed, 17 Jul 2024 16:02:41 +0200
Subject: [PATCH 040/106] safestruct: Accessors for non trivial globals

Adding Tracy in VVL showed that we are paying the price of initializing
global variables upon shared library entry, even if we do not
end up accessing those.
Adding accessors will make sure we pay this price
only when truly needed.
Also making the necessary changes in VVL.
---
 include/vulkan/utility/vk_safe_struct.hpp     |  4 ++
 .../vulkan/utility/vk_safe_struct_utils.hpp   |  4 --
 scripts/generators/safe_struct_generator.py   | 10 ++--
 src/vulkan/vk_safe_struct_manual.cpp          | 56 +++++++++++--------
 src/vulkan/vk_safe_struct_utils.cpp           |  6 +-
 5 files changed, 44 insertions(+), 36 deletions(-)

diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index e168920..f9ddd85 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -22,6 +22,10 @@
 
 namespace vku {
 
+// Mapping of unknown stype codes to structure lengths. This should be set up by the application
+// before vkCreateInstance() and not modified afterwards.
+std::vector<std::pair<uint32_t, uint32_t>>& GetCustomStypeInfo();
+
 struct safe_VkBufferMemoryBarrier {
     VkStructureType sType;
     const void* pNext{};
diff --git a/include/vulkan/utility/vk_safe_struct_utils.hpp b/include/vulkan/utility/vk_safe_struct_utils.hpp
index 9606df4..a770298 100644
--- a/include/vulkan/utility/vk_safe_struct_utils.hpp
+++ b/include/vulkan/utility/vk_safe_struct_utils.hpp
@@ -19,10 +19,6 @@
 
 namespace vku {
 
-// Mapping of unknown stype codes to structure lengths. This should be set up by the application
-// before vkCreateInstance() and not modified afterwards.
-extern std::vector<std::pair<uint32_t, uint32_t>> custom_stype_info;
-
 // State that elements in a pNext chain may need to be aware of
 struct PNextCopyState {
     // Custom initialization function. Returns true if the structure passed to init was initialized, false otherwise
diff --git a/scripts/generators/safe_struct_generator.py b/scripts/generators/safe_struct_generator.py
index 8b4fae8..e1d2bf0 100644
--- a/scripts/generators/safe_struct_generator.py
+++ b/scripts/generators/safe_struct_generator.py
@@ -159,6 +159,10 @@ class SafeStructOutputGenerator(BaseGenerator):
             #include <vulkan/utility/vk_safe_struct_utils.hpp>
 
             namespace vku {
+            
+            // Mapping of unknown stype codes to structure lengths. This should be set up by the application
+            // before vkCreateInstance() and not modified afterwards.
+            std::vector<std::pair<uint32_t, uint32_t>>& GetCustomStypeInfo();
             \n''')
 
         guard_helper = PlatformGuardHelper()
@@ -251,8 +255,6 @@ class SafeStructOutputGenerator(BaseGenerator):
             #include <vector>
             #include <cstring>
 
-            extern std::vector<std::pair<uint32_t, uint32_t>> custom_stype_info;
-
             namespace vku {
             char *SafeStringCopy(const char *in_string) {
                 if (nullptr == in_string) return nullptr;
@@ -305,7 +307,7 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
         out.append('''
             default: // Encountered an unknown sType -- skip (do not copy) this entry in the chain
                 // If sType is in custom list, construct blind copy
-                for (auto item : custom_stype_info) {
+                for (auto item : GetCustomStypeInfo()) {
                     if (item.first == static_cast<uint32_t>(header->sType)) {
                         safe_pNext = malloc(item.second);
                         memcpy(safe_pNext, header, item.second);
@@ -361,7 +363,7 @@ void FreePnextChain(const void *pNext) {
         out.append('''
         default: // Encountered an unknown sType
             // If sType is in custom list, free custom struct memory and clean up
-            for (auto item : custom_stype_info) {
+            for (auto item : GetCustomStypeInfo()   ) {
                 if (item.first == static_cast<uint32_t>(header->sType)) {
                     free(current);
                     break;
diff --git a/src/vulkan/vk_safe_struct_manual.cpp b/src/vulkan/vk_safe_struct_manual.cpp
index 76f13e5..2975fa8 100644
--- a/src/vulkan/vk_safe_struct_manual.cpp
+++ b/src/vulkan/vk_safe_struct_manual.cpp
@@ -18,7 +18,10 @@
 
 namespace vku {
 
-std::vector<std::pair<uint32_t, uint32_t>> custom_stype_info{};
+std::vector<std::pair<uint32_t, uint32_t>>& GetCustomStypeInfo() {
+    static std::vector<std::pair<uint32_t, uint32_t>> custom_stype_info{};
+    return custom_stype_info;
+}
 
 struct ASGeomKHRExtraData {
     ASGeomKHRExtraData(uint8_t* alloc, uint32_t primOffset, uint32_t primCount)
@@ -31,7 +34,12 @@ struct ASGeomKHRExtraData {
     uint32_t primitiveCount;
 };
 
-vku::concurrent::unordered_map<const safe_VkAccelerationStructureGeometryKHR*, ASGeomKHRExtraData*, 4> as_geom_khr_host_alloc;
+vku::concurrent::unordered_map<const safe_VkAccelerationStructureGeometryKHR*, ASGeomKHRExtraData*, 4>&
+GetAccelStructGeomHostAllocMap() {
+    static vku::concurrent::unordered_map<const safe_VkAccelerationStructureGeometryKHR*, ASGeomKHRExtraData*, 4>
+        as_geom_khr_host_alloc;
+    return as_geom_khr_host_alloc;
+}
 
 safe_VkAccelerationStructureGeometryKHR::safe_VkAccelerationStructureGeometryKHR(
     const VkAccelerationStructureGeometryKHR* in_struct, const bool is_host,
@@ -57,7 +65,7 @@ safe_VkAccelerationStructureGeometryKHR::safe_VkAccelerationStructureGeometryKHR
                 ppInstances[i] = &pInstances[i];
             }
             geometry.instances.data.hostAddress = allocation;
-            as_geom_khr_host_alloc.insert(
+            GetAccelStructGeomHostAllocMap().insert(
                 this, new ASGeomKHRExtraData(allocation, build_range_info->primitiveOffset, build_range_info->primitiveCount));
         } else {
             const auto primitive_offset = build_range_info->primitiveOffset;
@@ -68,7 +76,7 @@ safe_VkAccelerationStructureGeometryKHR::safe_VkAccelerationStructureGeometryKHR
             memcpy(allocation + primitive_offset, host_address + primitive_offset,
                    primitive_count * sizeof(VkAccelerationStructureInstanceKHR));
             geometry.instances.data.hostAddress = allocation;
-            as_geom_khr_host_alloc.insert(
+            GetAccelStructGeomHostAllocMap().insert(
                 this, new ASGeomKHRExtraData(allocation, build_range_info->primitiveOffset, build_range_info->primitiveCount));
         }
     }
@@ -85,8 +93,8 @@ safe_VkAccelerationStructureGeometryKHR::safe_VkAccelerationStructureGeometryKHR
     flags = copy_src.flags;
 
     pNext = SafePnextCopy(copy_src.pNext);
-    auto src_iter = as_geom_khr_host_alloc.find(&copy_src);
-    if (src_iter != as_geom_khr_host_alloc.end()) {
+    auto src_iter = GetAccelStructGeomHostAllocMap().find(&copy_src);
+    if (src_iter != GetAccelStructGeomHostAllocMap().end()) {
         auto& src_alloc = src_iter->second;
         if (geometry.instances.arrayOfPointers) {
             size_t pp_array_size = src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR*);
@@ -103,14 +111,14 @@ safe_VkAccelerationStructureGeometryKHR::safe_VkAccelerationStructureGeometryKHR
                 ppInstances[i] = &pInstances[i];
             }
             geometry.instances.data.hostAddress = allocation;
-            as_geom_khr_host_alloc.insert(
+            GetAccelStructGeomHostAllocMap().insert(
                 this, new ASGeomKHRExtraData(allocation, src_alloc->primitiveOffset, src_alloc->primitiveCount));
         } else {
             size_t array_size = src_alloc->primitiveOffset + src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR);
             uint8_t* allocation = new uint8_t[array_size];
             memcpy(allocation, src_alloc->ptr, array_size);
             geometry.instances.data.hostAddress = allocation;
-            as_geom_khr_host_alloc.insert(
+            GetAccelStructGeomHostAllocMap().insert(
                 this, new ASGeomKHRExtraData(allocation, src_alloc->primitiveOffset, src_alloc->primitiveCount));
         }
     }
@@ -120,8 +128,8 @@ safe_VkAccelerationStructureGeometryKHR& safe_VkAccelerationStructureGeometryKHR
     const safe_VkAccelerationStructureGeometryKHR& copy_src) {
     if (&copy_src == this) return *this;
 
-    auto iter = as_geom_khr_host_alloc.pop(this);
-    if (iter != as_geom_khr_host_alloc.end()) {
+    auto iter = GetAccelStructGeomHostAllocMap().pop(this);
+    if (iter != GetAccelStructGeomHostAllocMap().end()) {
         delete iter->second;
     }
     FreePnextChain(pNext);
@@ -132,8 +140,8 @@ safe_VkAccelerationStructureGeometryKHR& safe_VkAccelerationStructureGeometryKHR
     flags = copy_src.flags;
 
     pNext = SafePnextCopy(copy_src.pNext);
-    auto src_iter = as_geom_khr_host_alloc.find(&copy_src);
-    if (src_iter != as_geom_khr_host_alloc.end()) {
+    auto src_iter = GetAccelStructGeomHostAllocMap().find(&copy_src);
+    if (src_iter != GetAccelStructGeomHostAllocMap().end()) {
         auto& src_alloc = src_iter->second;
         if (geometry.instances.arrayOfPointers) {
             size_t pp_array_size = src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR*);
@@ -150,14 +158,14 @@ safe_VkAccelerationStructureGeometryKHR& safe_VkAccelerationStructureGeometryKHR
                 ppInstances[i] = &pInstances[i];
             }
             geometry.instances.data.hostAddress = allocation;
-            as_geom_khr_host_alloc.insert(
+            GetAccelStructGeomHostAllocMap().insert(
                 this, new ASGeomKHRExtraData(allocation, src_alloc->primitiveOffset, src_alloc->primitiveCount));
         } else {
             size_t array_size = src_alloc->primitiveOffset + src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR);
             uint8_t* allocation = new uint8_t[array_size];
             memcpy(allocation, src_alloc->ptr, array_size);
             geometry.instances.data.hostAddress = allocation;
-            as_geom_khr_host_alloc.insert(
+            GetAccelStructGeomHostAllocMap().insert(
                 this, new ASGeomKHRExtraData(allocation, src_alloc->primitiveOffset, src_alloc->primitiveCount));
         }
     }
@@ -166,8 +174,8 @@ safe_VkAccelerationStructureGeometryKHR& safe_VkAccelerationStructureGeometryKHR
 }
 
 safe_VkAccelerationStructureGeometryKHR::~safe_VkAccelerationStructureGeometryKHR() {
-    auto iter = as_geom_khr_host_alloc.pop(this);
-    if (iter != as_geom_khr_host_alloc.end()) {
+    auto iter = GetAccelStructGeomHostAllocMap().pop(this);
+    if (iter != GetAccelStructGeomHostAllocMap().end()) {
         delete iter->second;
     }
     FreePnextChain(pNext);
@@ -176,8 +184,8 @@ safe_VkAccelerationStructureGeometryKHR::~safe_VkAccelerationStructureGeometryKH
 void safe_VkAccelerationStructureGeometryKHR::initialize(const VkAccelerationStructureGeometryKHR* in_struct, const bool is_host,
                                                          const VkAccelerationStructureBuildRangeInfoKHR* build_range_info,
                                                          [[maybe_unused]] PNextCopyState* copy_state) {
-    auto iter = as_geom_khr_host_alloc.pop(this);
-    if (iter != as_geom_khr_host_alloc.end()) {
+    auto iter = GetAccelStructGeomHostAllocMap().pop(this);
+    if (iter != GetAccelStructGeomHostAllocMap().end()) {
         delete iter->second;
     }
     FreePnextChain(pNext);
@@ -204,7 +212,7 @@ void safe_VkAccelerationStructureGeometryKHR::initialize(const VkAccelerationStr
                 ppInstances[i] = &pInstances[i];
             }
             geometry.instances.data.hostAddress = allocation;
-            as_geom_khr_host_alloc.insert(
+            GetAccelStructGeomHostAllocMap().insert(
                 this, new ASGeomKHRExtraData(allocation, build_range_info->primitiveOffset, build_range_info->primitiveCount));
         } else {
             const auto primitive_offset = build_range_info->primitiveOffset;
@@ -215,7 +223,7 @@ void safe_VkAccelerationStructureGeometryKHR::initialize(const VkAccelerationStr
             memcpy(allocation + primitive_offset, host_address + primitive_offset,
                    primitive_count * sizeof(VkAccelerationStructureInstanceKHR));
             geometry.instances.data.hostAddress = allocation;
-            as_geom_khr_host_alloc.insert(
+            GetAccelStructGeomHostAllocMap().insert(
                 this, new ASGeomKHRExtraData(allocation, build_range_info->primitiveOffset, build_range_info->primitiveCount));
         }
     }
@@ -229,8 +237,8 @@ void safe_VkAccelerationStructureGeometryKHR::initialize(const safe_VkAccelerati
     flags = copy_src->flags;
 
     pNext = SafePnextCopy(copy_src->pNext);
-    auto src_iter = as_geom_khr_host_alloc.find(copy_src);
-    if (src_iter != as_geom_khr_host_alloc.end()) {
+    auto src_iter = GetAccelStructGeomHostAllocMap().find(copy_src);
+    if (src_iter != GetAccelStructGeomHostAllocMap().end()) {
         auto& src_alloc = src_iter->second;
         if (geometry.instances.arrayOfPointers) {
             size_t pp_array_size = src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR*);
@@ -247,14 +255,14 @@ void safe_VkAccelerationStructureGeometryKHR::initialize(const safe_VkAccelerati
                 ppInstances[i] = &pInstances[i];
             }
             geometry.instances.data.hostAddress = allocation;
-            as_geom_khr_host_alloc.insert(
+            GetAccelStructGeomHostAllocMap().insert(
                 this, new ASGeomKHRExtraData(allocation, src_alloc->primitiveOffset, src_alloc->primitiveCount));
         } else {
             size_t array_size = src_alloc->primitiveOffset + src_alloc->primitiveCount * sizeof(VkAccelerationStructureInstanceKHR);
             uint8_t* allocation = new uint8_t[array_size];
             memcpy(allocation, src_alloc->ptr, array_size);
             geometry.instances.data.hostAddress = allocation;
-            as_geom_khr_host_alloc.insert(
+            GetAccelStructGeomHostAllocMap().insert(
                 this, new ASGeomKHRExtraData(allocation, src_alloc->primitiveOffset, src_alloc->primitiveCount));
         }
     }
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index 3c60c55..75666e0 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -20,8 +20,6 @@
 #include <vector>
 #include <cstring>
 
-extern std::vector<std::pair<uint32_t, uint32_t>> custom_stype_info;
-
 namespace vku {
 char *SafeStringCopy(const char *in_string) {
     if (nullptr == in_string) return nullptr;
@@ -1848,7 +1846,7 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
 
             default: // Encountered an unknown sType -- skip (do not copy) this entry in the chain
                 // If sType is in custom list, construct blind copy
-                for (auto item : custom_stype_info) {
+                for (auto item : GetCustomStypeInfo()) {
                     if (item.first == static_cast<uint32_t>(header->sType)) {
                         safe_pNext = malloc(item.second);
                         memcpy(safe_pNext, header, item.second);
@@ -3680,7 +3678,7 @@ void FreePnextChain(const void *pNext) {
 
         default: // Encountered an unknown sType
             // If sType is in custom list, free custom struct memory and clean up
-            for (auto item : custom_stype_info) {
+            for (auto item : GetCustomStypeInfo()   ) {
                 if (item.first == static_cast<uint32_t>(header->sType)) {
                     free(current);
                     break;

From 67522b34edde86dbb97e164280291f387ade55fc Mon Sep 17 00:00:00 2001
From: ziga-lunarg <ziga@lunarg.com>
Date: Fri, 19 Jul 2024 20:51:44 +0200
Subject: [PATCH 041/106] build: Update to header 1.3.291

---
 include/vulkan/utility/vk_dispatch_table.h  |   2 +
 include/vulkan/utility/vk_safe_struct.hpp   |  52 +++++++
 include/vulkan/utility/vk_struct_helper.hpp |   3 +
 include/vulkan/vk_enum_string_helper.h      |  28 ++++
 scripts/known_good.json                     |   2 +-
 src/vulkan/vk_safe_struct_utils.cpp         |   6 +
 src/vulkan/vk_safe_struct_vendor.cpp        | 160 ++++++++++++++++++++
 7 files changed, 252 insertions(+), 1 deletion(-)

diff --git a/include/vulkan/utility/vk_dispatch_table.h b/include/vulkan/utility/vk_dispatch_table.h
index 2a10ad4..cda0aea 100644
--- a/include/vulkan/utility/vk_dispatch_table.h
+++ b/include/vulkan/utility/vk_dispatch_table.h
@@ -716,6 +716,7 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkDestroyOpticalFlowSessionNV DestroyOpticalFlowSessionNV;
     PFN_vkBindOpticalFlowSessionImageNV BindOpticalFlowSessionImageNV;
     PFN_vkCmdOpticalFlowExecuteNV CmdOpticalFlowExecuteNV;
+    PFN_vkAntiLagUpdateAMD AntiLagUpdateAMD;
     PFN_vkCreateShadersEXT CreateShadersEXT;
     PFN_vkDestroyShaderEXT DestroyShaderEXT;
     PFN_vkGetShaderBinaryDataEXT GetShaderBinaryDataEXT;
@@ -1312,6 +1313,7 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
     table->DestroyOpticalFlowSessionNV = (PFN_vkDestroyOpticalFlowSessionNV)gdpa(device, "vkDestroyOpticalFlowSessionNV");
     table->BindOpticalFlowSessionImageNV = (PFN_vkBindOpticalFlowSessionImageNV)gdpa(device, "vkBindOpticalFlowSessionImageNV");
     table->CmdOpticalFlowExecuteNV = (PFN_vkCmdOpticalFlowExecuteNV)gdpa(device, "vkCmdOpticalFlowExecuteNV");
+    table->AntiLagUpdateAMD = (PFN_vkAntiLagUpdateAMD)gdpa(device, "vkAntiLagUpdateAMD");
     table->CreateShadersEXT = (PFN_vkCreateShadersEXT)gdpa(device, "vkCreateShadersEXT");
     table->DestroyShaderEXT = (PFN_vkDestroyShaderEXT)gdpa(device, "vkDestroyShaderEXT");
     table->GetShaderBinaryDataEXT = (PFN_vkGetShaderBinaryDataEXT)gdpa(device, "vkGetShaderBinaryDataEXT");
diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index f9ddd85..cd886d7 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -17001,6 +17001,58 @@ struct safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID {
     }
 };
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
+struct safe_VkPhysicalDeviceAntiLagFeaturesAMD {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 antiLag;
+
+    safe_VkPhysicalDeviceAntiLagFeaturesAMD(const VkPhysicalDeviceAntiLagFeaturesAMD* in_struct, PNextCopyState* copy_state = {},
+                                            bool copy_pnext = true);
+    safe_VkPhysicalDeviceAntiLagFeaturesAMD(const safe_VkPhysicalDeviceAntiLagFeaturesAMD& copy_src);
+    safe_VkPhysicalDeviceAntiLagFeaturesAMD& operator=(const safe_VkPhysicalDeviceAntiLagFeaturesAMD& copy_src);
+    safe_VkPhysicalDeviceAntiLagFeaturesAMD();
+    ~safe_VkPhysicalDeviceAntiLagFeaturesAMD();
+    void initialize(const VkPhysicalDeviceAntiLagFeaturesAMD* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceAntiLagFeaturesAMD* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceAntiLagFeaturesAMD* ptr() { return reinterpret_cast<VkPhysicalDeviceAntiLagFeaturesAMD*>(this); }
+    VkPhysicalDeviceAntiLagFeaturesAMD const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceAntiLagFeaturesAMD const*>(this);
+    }
+};
+struct safe_VkAntiLagPresentationInfoAMD {
+    VkStructureType sType;
+    void* pNext{};
+    VkAntiLagStageAMD stage;
+    uint64_t frameIndex;
+
+    safe_VkAntiLagPresentationInfoAMD(const VkAntiLagPresentationInfoAMD* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    safe_VkAntiLagPresentationInfoAMD(const safe_VkAntiLagPresentationInfoAMD& copy_src);
+    safe_VkAntiLagPresentationInfoAMD& operator=(const safe_VkAntiLagPresentationInfoAMD& copy_src);
+    safe_VkAntiLagPresentationInfoAMD();
+    ~safe_VkAntiLagPresentationInfoAMD();
+    void initialize(const VkAntiLagPresentationInfoAMD* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAntiLagPresentationInfoAMD* copy_src, PNextCopyState* copy_state = {});
+    VkAntiLagPresentationInfoAMD* ptr() { return reinterpret_cast<VkAntiLagPresentationInfoAMD*>(this); }
+    VkAntiLagPresentationInfoAMD const* ptr() const { return reinterpret_cast<VkAntiLagPresentationInfoAMD const*>(this); }
+};
+struct safe_VkAntiLagDataAMD {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAntiLagModeAMD mode;
+    uint32_t maxFPS;
+    safe_VkAntiLagPresentationInfoAMD* pPresentationInfo{};
+
+    safe_VkAntiLagDataAMD(const VkAntiLagDataAMD* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkAntiLagDataAMD(const safe_VkAntiLagDataAMD& copy_src);
+    safe_VkAntiLagDataAMD& operator=(const safe_VkAntiLagDataAMD& copy_src);
+    safe_VkAntiLagDataAMD();
+    ~safe_VkAntiLagDataAMD();
+    void initialize(const VkAntiLagDataAMD* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAntiLagDataAMD* copy_src, PNextCopyState* copy_state = {});
+    VkAntiLagDataAMD* ptr() { return reinterpret_cast<VkAntiLagDataAMD*>(this); }
+    VkAntiLagDataAMD const* ptr() const { return reinterpret_cast<VkAntiLagDataAMD const*>(this); }
+};
 struct safe_VkPhysicalDeviceShaderObjectFeaturesEXT {
     VkStructureType sType;
     void* pNext{};
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index c94c8f8..9339f0c 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -896,6 +896,9 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceExternalFormatResolv
 template <> inline VkStructureType GetSType<VkPhysicalDeviceExternalFormatResolvePropertiesANDROID>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID; }
 template <> inline VkStructureType GetSType<VkAndroidHardwareBufferFormatResolvePropertiesANDROID>() { return VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID; }
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
+template <> inline VkStructureType GetSType<VkPhysicalDeviceAntiLagFeaturesAMD>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD; }
+template <> inline VkStructureType GetSType<VkAntiLagPresentationInfoAMD>() { return VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD; }
+template <> inline VkStructureType GetSType<VkAntiLagDataAMD>() { return VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderObjectFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderObjectPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT; }
 template <> inline VkStructureType GetSType<VkShaderCreateInfoEXT>() { return VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index 8835cfb..990af08 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -1748,6 +1748,12 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR";
         case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR:
             return "VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD";
+        case VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD:
+            return "VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD";
+        case VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD:
+            return "VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
@@ -4682,6 +4688,28 @@ static inline const char* string_VkOpticalFlowSessionBindingPointNV(VkOpticalFlo
             return "Unhandled VkOpticalFlowSessionBindingPointNV";
     }
 }
+static inline const char* string_VkAntiLagModeAMD(VkAntiLagModeAMD input_value) {
+    switch (input_value) {
+        case VK_ANTI_LAG_MODE_DRIVER_CONTROL_AMD:
+            return "VK_ANTI_LAG_MODE_DRIVER_CONTROL_AMD";
+        case VK_ANTI_LAG_MODE_ON_AMD:
+            return "VK_ANTI_LAG_MODE_ON_AMD";
+        case VK_ANTI_LAG_MODE_OFF_AMD:
+            return "VK_ANTI_LAG_MODE_OFF_AMD";
+        default:
+            return "Unhandled VkAntiLagModeAMD";
+    }
+}
+static inline const char* string_VkAntiLagStageAMD(VkAntiLagStageAMD input_value) {
+    switch (input_value) {
+        case VK_ANTI_LAG_STAGE_INPUT_AMD:
+            return "VK_ANTI_LAG_STAGE_INPUT_AMD";
+        case VK_ANTI_LAG_STAGE_PRESENT_AMD:
+            return "VK_ANTI_LAG_STAGE_PRESENT_AMD";
+        default:
+            return "Unhandled VkAntiLagStageAMD";
+    }
+}
 static inline const char* string_VkShaderCodeTypeEXT(VkShaderCodeTypeEXT input_value) {
     switch (input_value) {
         case VK_SHADER_CODE_TYPE_BINARY_EXT:
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 60c4cd0..9aca842 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.3.290"
+            "commit": "v1.3.291"
         },
         {
             "name": "googletest",
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index 75666e0..e7563b8 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -1679,6 +1679,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
                 safe_pNext = new safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID(reinterpret_cast<const VkAndroidHardwareBufferFormatResolvePropertiesANDROID *>(pNext), copy_state, false);
                 break;
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD:
+                safe_pNext = new safe_VkPhysicalDeviceAntiLagFeaturesAMD(reinterpret_cast<const VkPhysicalDeviceAntiLagFeaturesAMD *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
                 safe_pNext = new safe_VkPhysicalDeviceShaderObjectFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceShaderObjectFeaturesEXT *>(pNext), copy_state, false);
                 break;
@@ -3511,6 +3514,9 @@ void FreePnextChain(const void *pNext) {
             delete reinterpret_cast<safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID *>(header);
             break;
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD:
+            delete reinterpret_cast<safe_VkPhysicalDeviceAntiLagFeaturesAMD *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
             delete reinterpret_cast<safe_VkPhysicalDeviceShaderObjectFeaturesEXT *>(header);
             break;
diff --git a/src/vulkan/vk_safe_struct_vendor.cpp b/src/vulkan/vk_safe_struct_vendor.cpp
index e7b54d6..63e50ec 100644
--- a/src/vulkan/vk_safe_struct_vendor.cpp
+++ b/src/vulkan/vk_safe_struct_vendor.cpp
@@ -12735,6 +12735,166 @@ void safe_VkAndroidHardwareBufferFormatResolvePropertiesANDROID::initialize(
 }
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
 
+safe_VkPhysicalDeviceAntiLagFeaturesAMD::safe_VkPhysicalDeviceAntiLagFeaturesAMD(
+    const VkPhysicalDeviceAntiLagFeaturesAMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), antiLag(in_struct->antiLag) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceAntiLagFeaturesAMD::safe_VkPhysicalDeviceAntiLagFeaturesAMD()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD), pNext(nullptr), antiLag() {}
+
+safe_VkPhysicalDeviceAntiLagFeaturesAMD::safe_VkPhysicalDeviceAntiLagFeaturesAMD(
+    const safe_VkPhysicalDeviceAntiLagFeaturesAMD& copy_src) {
+    sType = copy_src.sType;
+    antiLag = copy_src.antiLag;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceAntiLagFeaturesAMD& safe_VkPhysicalDeviceAntiLagFeaturesAMD::operator=(
+    const safe_VkPhysicalDeviceAntiLagFeaturesAMD& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    antiLag = copy_src.antiLag;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceAntiLagFeaturesAMD::~safe_VkPhysicalDeviceAntiLagFeaturesAMD() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceAntiLagFeaturesAMD::initialize(const VkPhysicalDeviceAntiLagFeaturesAMD* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    antiLag = in_struct->antiLag;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceAntiLagFeaturesAMD::initialize(const safe_VkPhysicalDeviceAntiLagFeaturesAMD* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    antiLag = copy_src->antiLag;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkAntiLagPresentationInfoAMD::safe_VkAntiLagPresentationInfoAMD(const VkAntiLagPresentationInfoAMD* in_struct,
+                                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), stage(in_struct->stage), frameIndex(in_struct->frameIndex) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkAntiLagPresentationInfoAMD::safe_VkAntiLagPresentationInfoAMD()
+    : sType(VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD), pNext(nullptr), stage(), frameIndex() {}
+
+safe_VkAntiLagPresentationInfoAMD::safe_VkAntiLagPresentationInfoAMD(const safe_VkAntiLagPresentationInfoAMD& copy_src) {
+    sType = copy_src.sType;
+    stage = copy_src.stage;
+    frameIndex = copy_src.frameIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkAntiLagPresentationInfoAMD& safe_VkAntiLagPresentationInfoAMD::operator=(const safe_VkAntiLagPresentationInfoAMD& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    stage = copy_src.stage;
+    frameIndex = copy_src.frameIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkAntiLagPresentationInfoAMD::~safe_VkAntiLagPresentationInfoAMD() { FreePnextChain(pNext); }
+
+void safe_VkAntiLagPresentationInfoAMD::initialize(const VkAntiLagPresentationInfoAMD* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    stage = in_struct->stage;
+    frameIndex = in_struct->frameIndex;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkAntiLagPresentationInfoAMD::initialize(const safe_VkAntiLagPresentationInfoAMD* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stage = copy_src->stage;
+    frameIndex = copy_src->frameIndex;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkAntiLagDataAMD::safe_VkAntiLagDataAMD(const VkAntiLagDataAMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                             bool copy_pnext)
+    : sType(in_struct->sType), mode(in_struct->mode), maxFPS(in_struct->maxFPS), pPresentationInfo(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pPresentationInfo) pPresentationInfo = new safe_VkAntiLagPresentationInfoAMD(in_struct->pPresentationInfo);
+}
+
+safe_VkAntiLagDataAMD::safe_VkAntiLagDataAMD()
+    : sType(VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD), pNext(nullptr), mode(), maxFPS(), pPresentationInfo(nullptr) {}
+
+safe_VkAntiLagDataAMD::safe_VkAntiLagDataAMD(const safe_VkAntiLagDataAMD& copy_src) {
+    sType = copy_src.sType;
+    mode = copy_src.mode;
+    maxFPS = copy_src.maxFPS;
+    pPresentationInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pPresentationInfo) pPresentationInfo = new safe_VkAntiLagPresentationInfoAMD(*copy_src.pPresentationInfo);
+}
+
+safe_VkAntiLagDataAMD& safe_VkAntiLagDataAMD::operator=(const safe_VkAntiLagDataAMD& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pPresentationInfo) delete pPresentationInfo;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    mode = copy_src.mode;
+    maxFPS = copy_src.maxFPS;
+    pPresentationInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pPresentationInfo) pPresentationInfo = new safe_VkAntiLagPresentationInfoAMD(*copy_src.pPresentationInfo);
+
+    return *this;
+}
+
+safe_VkAntiLagDataAMD::~safe_VkAntiLagDataAMD() {
+    if (pPresentationInfo) delete pPresentationInfo;
+    FreePnextChain(pNext);
+}
+
+void safe_VkAntiLagDataAMD::initialize(const VkAntiLagDataAMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pPresentationInfo) delete pPresentationInfo;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    mode = in_struct->mode;
+    maxFPS = in_struct->maxFPS;
+    pPresentationInfo = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (in_struct->pPresentationInfo) pPresentationInfo = new safe_VkAntiLagPresentationInfoAMD(in_struct->pPresentationInfo);
+}
+
+void safe_VkAntiLagDataAMD::initialize(const safe_VkAntiLagDataAMD* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    mode = copy_src->mode;
+    maxFPS = copy_src->maxFPS;
+    pPresentationInfo = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (copy_src->pPresentationInfo) pPresentationInfo = new safe_VkAntiLagPresentationInfoAMD(*copy_src->pPresentationInfo);
+}
+
 safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM::safe_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
     const VkPhysicalDeviceTilePropertiesFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType), tileProperties(in_struct->tileProperties) {

From 45b881573538f8e481cb6e1d811a9076be6920c1 Mon Sep 17 00:00:00 2001
From: ziga-lunarg <ziga@lunarg.com>
Date: Wed, 31 Jul 2024 13:46:14 +0200
Subject: [PATCH 042/106] build: Update to header 1.3.292

---
 include/vulkan/utility/vk_safe_struct.hpp | 4 ++--
 scripts/known_good.json                   | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index cd886d7..c1b7829 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -13590,7 +13590,7 @@ struct safe_VkDescriptorAddressInfoEXT {
 };
 struct safe_VkDescriptorBufferBindingInfoEXT {
     VkStructureType sType;
-    void* pNext{};
+    const void* pNext{};
     VkDeviceAddress address;
     VkBufferUsageFlags usage;
 
@@ -13607,7 +13607,7 @@ struct safe_VkDescriptorBufferBindingInfoEXT {
 };
 struct safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT {
     VkStructureType sType;
-    void* pNext{};
+    const void* pNext{};
     VkBuffer buffer;
 
     safe_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 9aca842..341aa76 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.3.291"
+            "commit": "v1.3.292"
         },
         {
             "name": "googletest",

From 9b6e18888be3ac761a3f71594c3949f8dc862ccc Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Fri, 16 Aug 2024 08:50:32 -0700
Subject: [PATCH 043/106] build: Update to header 1.3.293

---
 include/vulkan/utility/vk_safe_struct.hpp   | 22 +++++++++
 include/vulkan/utility/vk_struct_helper.hpp |  1 +
 include/vulkan/vk_enum_string_helper.h      |  2 +
 scripts/known_good.json                     |  4 +-
 src/vulkan/vk_safe_struct_utils.cpp         |  6 +++
 src/vulkan/vk_safe_struct_vendor.cpp        | 51 +++++++++++++++++++++
 6 files changed, 84 insertions(+), 2 deletions(-)

diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index c1b7829..277ada8 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -18058,6 +18058,28 @@ struct safe_VkPhysicalDeviceRawAccessChainsFeaturesNV {
         return reinterpret_cast<VkPhysicalDeviceRawAccessChainsFeaturesNV const*>(this);
     }
 };
+struct safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 commandBufferInheritance;
+
+    safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV(const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV* in_struct,
+                                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV(
+        const safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV& operator=(
+        const safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV();
+    ~safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV();
+    void initialize(const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCommandBufferInheritanceFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceCommandBufferInheritanceFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceCommandBufferInheritanceFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCommandBufferInheritanceFeaturesNV const*>(this);
+    }
+};
 struct safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV {
     VkStructureType sType;
     void* pNext{};
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index 9339f0c..3142695 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -950,6 +950,7 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceExternalMemoryScreen
 template <> inline VkStructureType GetSType<VkPhysicalDeviceLayeredDriverPropertiesMSFT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceRawAccessChainsFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceCommandBufferInheritanceFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingValidationFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index 990af08..00982f0 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -1918,6 +1918,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR:
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 341aa76..04506a4 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.3.292"
+            "commit": "v1.3.293"
         },
         {
             "name": "googletest",
@@ -46,4 +46,4 @@
         "googletest": "GOOGLETEST_INSTALL_DIR",
         "magic_enum": "MAGIC_ENUM_INSTALL_DIR"
     }
-}
+}
\ No newline at end of file
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index e7563b8..8b56c1e 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -1804,6 +1804,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
                 safe_pNext = new safe_VkPhysicalDeviceRawAccessChainsFeaturesNV(reinterpret_cast<const VkPhysicalDeviceRawAccessChainsFeaturesNV *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV(reinterpret_cast<const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV:
                 safe_pNext = new safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV(reinterpret_cast<const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *>(pNext), copy_state, false);
                 break;
@@ -3639,6 +3642,9 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
             delete reinterpret_cast<safe_VkPhysicalDeviceRawAccessChainsFeaturesNV *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV:
+            delete reinterpret_cast<safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV:
             delete reinterpret_cast<safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *>(header);
             break;
diff --git a/src/vulkan/vk_safe_struct_vendor.cpp b/src/vulkan/vk_safe_struct_vendor.cpp
index 63e50ec..c6310cc 100644
--- a/src/vulkan/vk_safe_struct_vendor.cpp
+++ b/src/vulkan/vk_safe_struct_vendor.cpp
@@ -15175,6 +15175,57 @@ void safe_VkPhysicalDeviceRawAccessChainsFeaturesNV::initialize(const safe_VkPhy
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV::safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV(
+    const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), commandBufferInheritance(in_struct->commandBufferInheritance) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV::safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV), pNext(nullptr), commandBufferInheritance() {}
+
+safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV::safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV(
+    const safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    commandBufferInheritance = copy_src.commandBufferInheritance;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV& safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    commandBufferInheritance = copy_src.commandBufferInheritance;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV::~safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV::initialize(
+    const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    commandBufferInheritance = in_struct->commandBufferInheritance;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV::initialize(
+    const safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    commandBufferInheritance = copy_src->commandBufferInheritance;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV::safe_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV(
     const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
     bool copy_pnext)

From 7ea05992a52e96426bd4c56ea12d208e0d6c9a5f Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Fri, 23 Aug 2024 10:33:16 -0700
Subject: [PATCH 044/106] build: Update to header 1.3.294

---
 include/vulkan/utility/vk_dispatch_table.h  |  10 +
 include/vulkan/utility/vk_safe_struct.hpp   | 207 +++++
 include/vulkan/utility/vk_struct_helper.hpp |  11 +
 include/vulkan/vk_enum_string_helper.h      |  27 +
 scripts/known_good.json                     |   2 +-
 src/vulkan/vk_safe_struct_khr.cpp           | 805 ++++++++++++++++++++
 src/vulkan/vk_safe_struct_utils.cpp         |  54 ++
 7 files changed, 1115 insertions(+), 1 deletion(-)

diff --git a/include/vulkan/utility/vk_dispatch_table.h b/include/vulkan/utility/vk_dispatch_table.h
index cda0aea..75d7b01 100644
--- a/include/vulkan/utility/vk_dispatch_table.h
+++ b/include/vulkan/utility/vk_dispatch_table.h
@@ -461,6 +461,11 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkGetRenderingAreaGranularityKHR GetRenderingAreaGranularityKHR;
     PFN_vkGetDeviceImageSubresourceLayoutKHR GetDeviceImageSubresourceLayoutKHR;
     PFN_vkGetImageSubresourceLayout2KHR GetImageSubresourceLayout2KHR;
+    PFN_vkCreatePipelineBinariesKHR CreatePipelineBinariesKHR;
+    PFN_vkDestroyPipelineBinaryKHR DestroyPipelineBinaryKHR;
+    PFN_vkGetPipelineKeyKHR GetPipelineKeyKHR;
+    PFN_vkGetPipelineBinaryDataKHR GetPipelineBinaryDataKHR;
+    PFN_vkReleaseCapturedPipelineDataKHR ReleaseCapturedPipelineDataKHR;
     PFN_vkCmdSetLineStippleKHR CmdSetLineStippleKHR;
     PFN_vkGetCalibratedTimestampsKHR GetCalibratedTimestampsKHR;
     PFN_vkCmdBindDescriptorSets2KHR CmdBindDescriptorSets2KHR;
@@ -1058,6 +1063,11 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
     table->GetRenderingAreaGranularityKHR = (PFN_vkGetRenderingAreaGranularityKHR)gdpa(device, "vkGetRenderingAreaGranularityKHR");
     table->GetDeviceImageSubresourceLayoutKHR = (PFN_vkGetDeviceImageSubresourceLayoutKHR)gdpa(device, "vkGetDeviceImageSubresourceLayoutKHR");
     table->GetImageSubresourceLayout2KHR = (PFN_vkGetImageSubresourceLayout2KHR)gdpa(device, "vkGetImageSubresourceLayout2KHR");
+    table->CreatePipelineBinariesKHR = (PFN_vkCreatePipelineBinariesKHR)gdpa(device, "vkCreatePipelineBinariesKHR");
+    table->DestroyPipelineBinaryKHR = (PFN_vkDestroyPipelineBinaryKHR)gdpa(device, "vkDestroyPipelineBinaryKHR");
+    table->GetPipelineKeyKHR = (PFN_vkGetPipelineKeyKHR)gdpa(device, "vkGetPipelineKeyKHR");
+    table->GetPipelineBinaryDataKHR = (PFN_vkGetPipelineBinaryDataKHR)gdpa(device, "vkGetPipelineBinaryDataKHR");
+    table->ReleaseCapturedPipelineDataKHR = (PFN_vkReleaseCapturedPipelineDataKHR)gdpa(device, "vkReleaseCapturedPipelineDataKHR");
     table->CmdSetLineStippleKHR = (PFN_vkCmdSetLineStippleKHR)gdpa(device, "vkCmdSetLineStippleKHR");
     table->GetCalibratedTimestampsKHR = (PFN_vkGetCalibratedTimestampsKHR)gdpa(device, "vkGetCalibratedTimestampsKHR");
     table->CmdBindDescriptorSets2KHR = (PFN_vkCmdBindDescriptorSets2KHR)gdpa(device, "vkCmdBindDescriptorSets2KHR");
diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index 277ada8..cb4e3b3 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -7912,6 +7912,213 @@ struct safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR {
         return reinterpret_cast<VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR const*>(this);
     }
 };
+struct safe_VkPhysicalDevicePipelineBinaryFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 pipelineBinaries;
+
+    safe_VkPhysicalDevicePipelineBinaryFeaturesKHR(const VkPhysicalDevicePipelineBinaryFeaturesKHR* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDevicePipelineBinaryFeaturesKHR(const safe_VkPhysicalDevicePipelineBinaryFeaturesKHR& copy_src);
+    safe_VkPhysicalDevicePipelineBinaryFeaturesKHR& operator=(const safe_VkPhysicalDevicePipelineBinaryFeaturesKHR& copy_src);
+    safe_VkPhysicalDevicePipelineBinaryFeaturesKHR();
+    ~safe_VkPhysicalDevicePipelineBinaryFeaturesKHR();
+    void initialize(const VkPhysicalDevicePipelineBinaryFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePipelineBinaryFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePipelineBinaryFeaturesKHR* ptr() { return reinterpret_cast<VkPhysicalDevicePipelineBinaryFeaturesKHR*>(this); }
+    VkPhysicalDevicePipelineBinaryFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePipelineBinaryFeaturesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDevicePipelineBinaryPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 pipelineBinaryInternalCache;
+    VkBool32 pipelineBinaryInternalCacheControl;
+    VkBool32 pipelineBinaryPrefersInternalCache;
+    VkBool32 pipelineBinaryPrecompiledInternalCache;
+    VkBool32 pipelineBinaryCompressedData;
+
+    safe_VkPhysicalDevicePipelineBinaryPropertiesKHR(const VkPhysicalDevicePipelineBinaryPropertiesKHR* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDevicePipelineBinaryPropertiesKHR(const safe_VkPhysicalDevicePipelineBinaryPropertiesKHR& copy_src);
+    safe_VkPhysicalDevicePipelineBinaryPropertiesKHR& operator=(const safe_VkPhysicalDevicePipelineBinaryPropertiesKHR& copy_src);
+    safe_VkPhysicalDevicePipelineBinaryPropertiesKHR();
+    ~safe_VkPhysicalDevicePipelineBinaryPropertiesKHR();
+    void initialize(const VkPhysicalDevicePipelineBinaryPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePipelineBinaryPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePipelineBinaryPropertiesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePipelineBinaryPropertiesKHR*>(this);
+    }
+    VkPhysicalDevicePipelineBinaryPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePipelineBinaryPropertiesKHR const*>(this);
+    }
+};
+struct safe_VkDevicePipelineBinaryInternalCacheControlKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 disableInternalCache;
+
+    safe_VkDevicePipelineBinaryInternalCacheControlKHR(const VkDevicePipelineBinaryInternalCacheControlKHR* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDevicePipelineBinaryInternalCacheControlKHR(const safe_VkDevicePipelineBinaryInternalCacheControlKHR& copy_src);
+    safe_VkDevicePipelineBinaryInternalCacheControlKHR& operator=(
+        const safe_VkDevicePipelineBinaryInternalCacheControlKHR& copy_src);
+    safe_VkDevicePipelineBinaryInternalCacheControlKHR();
+    ~safe_VkDevicePipelineBinaryInternalCacheControlKHR();
+    void initialize(const VkDevicePipelineBinaryInternalCacheControlKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDevicePipelineBinaryInternalCacheControlKHR* copy_src, PNextCopyState* copy_state = {});
+    VkDevicePipelineBinaryInternalCacheControlKHR* ptr() {
+        return reinterpret_cast<VkDevicePipelineBinaryInternalCacheControlKHR*>(this);
+    }
+    VkDevicePipelineBinaryInternalCacheControlKHR const* ptr() const {
+        return reinterpret_cast<VkDevicePipelineBinaryInternalCacheControlKHR const*>(this);
+    }
+};
+struct safe_VkPipelineBinaryKeyKHR {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t keySize;
+    uint8_t key[VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR];
+
+    safe_VkPipelineBinaryKeyKHR(const VkPipelineBinaryKeyKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineBinaryKeyKHR(const safe_VkPipelineBinaryKeyKHR& copy_src);
+    safe_VkPipelineBinaryKeyKHR& operator=(const safe_VkPipelineBinaryKeyKHR& copy_src);
+    safe_VkPipelineBinaryKeyKHR();
+    ~safe_VkPipelineBinaryKeyKHR();
+    void initialize(const VkPipelineBinaryKeyKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineBinaryKeyKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineBinaryKeyKHR* ptr() { return reinterpret_cast<VkPipelineBinaryKeyKHR*>(this); }
+    VkPipelineBinaryKeyKHR const* ptr() const { return reinterpret_cast<VkPipelineBinaryKeyKHR const*>(this); }
+};
+struct safe_VkPipelineBinaryDataKHR {
+    size_t dataSize;
+    void* pData{};
+
+    safe_VkPipelineBinaryDataKHR(const VkPipelineBinaryDataKHR* in_struct, PNextCopyState* copy_state = {});
+    safe_VkPipelineBinaryDataKHR(const safe_VkPipelineBinaryDataKHR& copy_src);
+    safe_VkPipelineBinaryDataKHR& operator=(const safe_VkPipelineBinaryDataKHR& copy_src);
+    safe_VkPipelineBinaryDataKHR();
+    ~safe_VkPipelineBinaryDataKHR();
+    void initialize(const VkPipelineBinaryDataKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineBinaryDataKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineBinaryDataKHR* ptr() { return reinterpret_cast<VkPipelineBinaryDataKHR*>(this); }
+    VkPipelineBinaryDataKHR const* ptr() const { return reinterpret_cast<VkPipelineBinaryDataKHR const*>(this); }
+};
+struct safe_VkPipelineBinaryKeysAndDataKHR {
+    uint32_t binaryCount;
+    safe_VkPipelineBinaryKeyKHR* pPipelineBinaryKeys{};
+    safe_VkPipelineBinaryDataKHR* pPipelineBinaryData{};
+
+    safe_VkPipelineBinaryKeysAndDataKHR(const VkPipelineBinaryKeysAndDataKHR* in_struct, PNextCopyState* copy_state = {});
+    safe_VkPipelineBinaryKeysAndDataKHR(const safe_VkPipelineBinaryKeysAndDataKHR& copy_src);
+    safe_VkPipelineBinaryKeysAndDataKHR& operator=(const safe_VkPipelineBinaryKeysAndDataKHR& copy_src);
+    safe_VkPipelineBinaryKeysAndDataKHR();
+    ~safe_VkPipelineBinaryKeysAndDataKHR();
+    void initialize(const VkPipelineBinaryKeysAndDataKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineBinaryKeysAndDataKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineBinaryKeysAndDataKHR* ptr() { return reinterpret_cast<VkPipelineBinaryKeysAndDataKHR*>(this); }
+    VkPipelineBinaryKeysAndDataKHR const* ptr() const { return reinterpret_cast<VkPipelineBinaryKeysAndDataKHR const*>(this); }
+};
+struct safe_VkPipelineCreateInfoKHR {
+    VkStructureType sType;
+    void* pNext{};
+
+    safe_VkPipelineCreateInfoKHR(const VkPipelineCreateInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineCreateInfoKHR(const safe_VkPipelineCreateInfoKHR& copy_src);
+    safe_VkPipelineCreateInfoKHR& operator=(const safe_VkPipelineCreateInfoKHR& copy_src);
+    safe_VkPipelineCreateInfoKHR();
+    ~safe_VkPipelineCreateInfoKHR();
+    void initialize(const VkPipelineCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineCreateInfoKHR* ptr() { return reinterpret_cast<VkPipelineCreateInfoKHR*>(this); }
+    VkPipelineCreateInfoKHR const* ptr() const { return reinterpret_cast<VkPipelineCreateInfoKHR const*>(this); }
+};
+struct safe_VkPipelineBinaryCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    safe_VkPipelineBinaryKeysAndDataKHR* pKeysAndDataInfo{};
+    VkPipeline pipeline;
+    safe_VkPipelineCreateInfoKHR* pPipelineCreateInfo{};
+
+    safe_VkPipelineBinaryCreateInfoKHR(const VkPipelineBinaryCreateInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    safe_VkPipelineBinaryCreateInfoKHR(const safe_VkPipelineBinaryCreateInfoKHR& copy_src);
+    safe_VkPipelineBinaryCreateInfoKHR& operator=(const safe_VkPipelineBinaryCreateInfoKHR& copy_src);
+    safe_VkPipelineBinaryCreateInfoKHR();
+    ~safe_VkPipelineBinaryCreateInfoKHR();
+    void initialize(const VkPipelineBinaryCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineBinaryCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineBinaryCreateInfoKHR* ptr() { return reinterpret_cast<VkPipelineBinaryCreateInfoKHR*>(this); }
+    VkPipelineBinaryCreateInfoKHR const* ptr() const { return reinterpret_cast<VkPipelineBinaryCreateInfoKHR const*>(this); }
+};
+struct safe_VkPipelineBinaryInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t binaryCount;
+    VkPipelineBinaryKHR* pPipelineBinaries{};
+
+    safe_VkPipelineBinaryInfoKHR(const VkPipelineBinaryInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineBinaryInfoKHR(const safe_VkPipelineBinaryInfoKHR& copy_src);
+    safe_VkPipelineBinaryInfoKHR& operator=(const safe_VkPipelineBinaryInfoKHR& copy_src);
+    safe_VkPipelineBinaryInfoKHR();
+    ~safe_VkPipelineBinaryInfoKHR();
+    void initialize(const VkPipelineBinaryInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineBinaryInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineBinaryInfoKHR* ptr() { return reinterpret_cast<VkPipelineBinaryInfoKHR*>(this); }
+    VkPipelineBinaryInfoKHR const* ptr() const { return reinterpret_cast<VkPipelineBinaryInfoKHR const*>(this); }
+};
+struct safe_VkReleaseCapturedPipelineDataInfoKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkPipeline pipeline;
+
+    safe_VkReleaseCapturedPipelineDataInfoKHR(const VkReleaseCapturedPipelineDataInfoKHR* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkReleaseCapturedPipelineDataInfoKHR(const safe_VkReleaseCapturedPipelineDataInfoKHR& copy_src);
+    safe_VkReleaseCapturedPipelineDataInfoKHR& operator=(const safe_VkReleaseCapturedPipelineDataInfoKHR& copy_src);
+    safe_VkReleaseCapturedPipelineDataInfoKHR();
+    ~safe_VkReleaseCapturedPipelineDataInfoKHR();
+    void initialize(const VkReleaseCapturedPipelineDataInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkReleaseCapturedPipelineDataInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkReleaseCapturedPipelineDataInfoKHR* ptr() { return reinterpret_cast<VkReleaseCapturedPipelineDataInfoKHR*>(this); }
+    VkReleaseCapturedPipelineDataInfoKHR const* ptr() const {
+        return reinterpret_cast<VkReleaseCapturedPipelineDataInfoKHR const*>(this);
+    }
+};
+struct safe_VkPipelineBinaryDataInfoKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkPipelineBinaryKHR pipelineBinary;
+
+    safe_VkPipelineBinaryDataInfoKHR(const VkPipelineBinaryDataInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    safe_VkPipelineBinaryDataInfoKHR(const safe_VkPipelineBinaryDataInfoKHR& copy_src);
+    safe_VkPipelineBinaryDataInfoKHR& operator=(const safe_VkPipelineBinaryDataInfoKHR& copy_src);
+    safe_VkPipelineBinaryDataInfoKHR();
+    ~safe_VkPipelineBinaryDataInfoKHR();
+    void initialize(const VkPipelineBinaryDataInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineBinaryDataInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineBinaryDataInfoKHR* ptr() { return reinterpret_cast<VkPipelineBinaryDataInfoKHR*>(this); }
+    VkPipelineBinaryDataInfoKHR const* ptr() const { return reinterpret_cast<VkPipelineBinaryDataInfoKHR const*>(this); }
+};
+struct safe_VkPipelineBinaryHandlesInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t pipelineBinaryCount;
+    VkPipelineBinaryKHR* pPipelineBinaries{};
+
+    safe_VkPipelineBinaryHandlesInfoKHR(const VkPipelineBinaryHandlesInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkPipelineBinaryHandlesInfoKHR(const safe_VkPipelineBinaryHandlesInfoKHR& copy_src);
+    safe_VkPipelineBinaryHandlesInfoKHR& operator=(const safe_VkPipelineBinaryHandlesInfoKHR& copy_src);
+    safe_VkPipelineBinaryHandlesInfoKHR();
+    ~safe_VkPipelineBinaryHandlesInfoKHR();
+    void initialize(const VkPipelineBinaryHandlesInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineBinaryHandlesInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineBinaryHandlesInfoKHR* ptr() { return reinterpret_cast<VkPipelineBinaryHandlesInfoKHR*>(this); }
+    VkPipelineBinaryHandlesInfoKHR const* ptr() const { return reinterpret_cast<VkPipelineBinaryHandlesInfoKHR const*>(this); }
+};
 struct safe_VkCooperativeMatrixPropertiesKHR {
     VkStructureType sType;
     void* pNext{};
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index 3142695..faf95e5 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -424,6 +424,16 @@ template <> inline VkStructureType GetSType<VkSubresourceLayout2KHR>() { return
 template <> inline VkStructureType GetSType<VkPipelineCreateFlags2CreateInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkBufferUsageFlags2CreateInfoKHR>() { return VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDevicePipelineBinaryFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDevicePipelineBinaryPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR; }
+template <> inline VkStructureType GetSType<VkDevicePipelineBinaryInternalCacheControlKHR>() { return VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR; }
+template <> inline VkStructureType GetSType<VkPipelineBinaryKeyKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR; }
+template <> inline VkStructureType GetSType<VkPipelineCreateInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkPipelineBinaryCreateInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkPipelineBinaryInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkReleaseCapturedPipelineDataInfoKHR>() { return VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkPipelineBinaryDataInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkPipelineBinaryHandlesInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkCooperativeMatrixPropertiesKHR>() { return VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeMatrixFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeMatrixPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR; }
@@ -1088,6 +1098,7 @@ template<> inline VkObjectType GetObjectType<VkDisplayModeKHR>() { return VK_OBJ
 template<> inline VkObjectType GetObjectType<VkVideoSessionKHR>() { return VK_OBJECT_TYPE_VIDEO_SESSION_KHR; }
 template<> inline VkObjectType GetObjectType<VkVideoSessionParametersKHR>() { return VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR; }
 template<> inline VkObjectType GetObjectType<VkDeferredOperationKHR>() { return VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR; }
+template<> inline VkObjectType GetObjectType<VkPipelineBinaryKHR>() { return VK_OBJECT_TYPE_PIPELINE_BINARY_KHR; }
 template<> inline VkObjectType GetObjectType<VkDebugReportCallbackEXT>() { return VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT; }
 template<> inline VkObjectType GetObjectType<VkCuModuleNVX>() { return VK_OBJECT_TYPE_CU_MODULE_NVX; }
 template<> inline VkObjectType GetObjectType<VkCuFunctionNVX>() { return VK_OBJECT_TYPE_CU_FUNCTION_NVX; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index 00982f0..a26e127 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -110,6 +110,10 @@ static inline const char* string_VkResult(VkResult input_value) {
             return "VK_ERROR_COMPRESSION_EXHAUSTED_EXT";
         case VK_INCOMPATIBLE_SHADER_BINARY_EXT:
             return "VK_INCOMPATIBLE_SHADER_BINARY_EXT";
+        case VK_PIPELINE_BINARY_MISSING_KHR:
+            return "VK_PIPELINE_BINARY_MISSING_KHR";
+        case VK_ERROR_NOT_ENOUGH_SPACE_KHR:
+            return "VK_ERROR_NOT_ENOUGH_SPACE_KHR";
         default:
             return "Unhandled VkResult";
     }
@@ -1762,6 +1766,26 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT";
         case VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT:
             return "VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR";
+        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR";
+        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR";
+        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR:
+            return "VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR";
+        case VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR";
+        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR";
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR";
+        case VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR:
+            return "VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR";
+        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM";
         case VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM:
@@ -2122,6 +2146,8 @@ static inline const char* string_VkObjectType(VkObjectType input_value) {
             return "VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV";
         case VK_OBJECT_TYPE_SHADER_EXT:
             return "VK_OBJECT_TYPE_SHADER_EXT";
+        case VK_OBJECT_TYPE_PIPELINE_BINARY_KHR:
+            return "VK_OBJECT_TYPE_PIPELINE_BINARY_KHR";
         default:
             return "Unhandled VkObjectType";
     }
@@ -8332,6 +8358,7 @@ static inline const char* string_VkPipelineCreateFlagBits2KHR(uint64_t input_val
     if (input_value == VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT) return "VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT";
     if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV) return "VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV";
     if (input_value == VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT) return "VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT";
+    if (input_value == VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR) return "VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR";
     return "Unhandled VkPipelineCreateFlagBits2KHR";
 }
 
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 04506a4..4ed3bca 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.3.293"
+            "commit": "v1.3.294"
         },
         {
             "name": "googletest",
diff --git a/src/vulkan/vk_safe_struct_khr.cpp b/src/vulkan/vk_safe_struct_khr.cpp
index edbd7e2..be16aba 100644
--- a/src/vulkan/vk_safe_struct_khr.cpp
+++ b/src/vulkan/vk_safe_struct_khr.cpp
@@ -12163,6 +12163,811 @@ void safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::initialize(
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::safe_VkPhysicalDevicePipelineBinaryFeaturesKHR(
+    const VkPhysicalDevicePipelineBinaryFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), pipelineBinaries(in_struct->pipelineBinaries) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::safe_VkPhysicalDevicePipelineBinaryFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR), pNext(nullptr), pipelineBinaries() {}
+
+safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::safe_VkPhysicalDevicePipelineBinaryFeaturesKHR(
+    const safe_VkPhysicalDevicePipelineBinaryFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    pipelineBinaries = copy_src.pipelineBinaries;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePipelineBinaryFeaturesKHR& safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::operator=(
+    const safe_VkPhysicalDevicePipelineBinaryFeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pipelineBinaries = copy_src.pipelineBinaries;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::~safe_VkPhysicalDevicePipelineBinaryFeaturesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::initialize(const VkPhysicalDevicePipelineBinaryFeaturesKHR* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pipelineBinaries = in_struct->pipelineBinaries;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePipelineBinaryFeaturesKHR::initialize(const safe_VkPhysicalDevicePipelineBinaryFeaturesKHR* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pipelineBinaries = copy_src->pipelineBinaries;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::safe_VkPhysicalDevicePipelineBinaryPropertiesKHR(
+    const VkPhysicalDevicePipelineBinaryPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      pipelineBinaryInternalCache(in_struct->pipelineBinaryInternalCache),
+      pipelineBinaryInternalCacheControl(in_struct->pipelineBinaryInternalCacheControl),
+      pipelineBinaryPrefersInternalCache(in_struct->pipelineBinaryPrefersInternalCache),
+      pipelineBinaryPrecompiledInternalCache(in_struct->pipelineBinaryPrecompiledInternalCache),
+      pipelineBinaryCompressedData(in_struct->pipelineBinaryCompressedData) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::safe_VkPhysicalDevicePipelineBinaryPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR),
+      pNext(nullptr),
+      pipelineBinaryInternalCache(),
+      pipelineBinaryInternalCacheControl(),
+      pipelineBinaryPrefersInternalCache(),
+      pipelineBinaryPrecompiledInternalCache(),
+      pipelineBinaryCompressedData() {}
+
+safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::safe_VkPhysicalDevicePipelineBinaryPropertiesKHR(
+    const safe_VkPhysicalDevicePipelineBinaryPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    pipelineBinaryInternalCache = copy_src.pipelineBinaryInternalCache;
+    pipelineBinaryInternalCacheControl = copy_src.pipelineBinaryInternalCacheControl;
+    pipelineBinaryPrefersInternalCache = copy_src.pipelineBinaryPrefersInternalCache;
+    pipelineBinaryPrecompiledInternalCache = copy_src.pipelineBinaryPrecompiledInternalCache;
+    pipelineBinaryCompressedData = copy_src.pipelineBinaryCompressedData;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePipelineBinaryPropertiesKHR& safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::operator=(
+    const safe_VkPhysicalDevicePipelineBinaryPropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pipelineBinaryInternalCache = copy_src.pipelineBinaryInternalCache;
+    pipelineBinaryInternalCacheControl = copy_src.pipelineBinaryInternalCacheControl;
+    pipelineBinaryPrefersInternalCache = copy_src.pipelineBinaryPrefersInternalCache;
+    pipelineBinaryPrecompiledInternalCache = copy_src.pipelineBinaryPrecompiledInternalCache;
+    pipelineBinaryCompressedData = copy_src.pipelineBinaryCompressedData;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::~safe_VkPhysicalDevicePipelineBinaryPropertiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::initialize(const VkPhysicalDevicePipelineBinaryPropertiesKHR* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pipelineBinaryInternalCache = in_struct->pipelineBinaryInternalCache;
+    pipelineBinaryInternalCacheControl = in_struct->pipelineBinaryInternalCacheControl;
+    pipelineBinaryPrefersInternalCache = in_struct->pipelineBinaryPrefersInternalCache;
+    pipelineBinaryPrecompiledInternalCache = in_struct->pipelineBinaryPrecompiledInternalCache;
+    pipelineBinaryCompressedData = in_struct->pipelineBinaryCompressedData;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePipelineBinaryPropertiesKHR::initialize(const safe_VkPhysicalDevicePipelineBinaryPropertiesKHR* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pipelineBinaryInternalCache = copy_src->pipelineBinaryInternalCache;
+    pipelineBinaryInternalCacheControl = copy_src->pipelineBinaryInternalCacheControl;
+    pipelineBinaryPrefersInternalCache = copy_src->pipelineBinaryPrefersInternalCache;
+    pipelineBinaryPrecompiledInternalCache = copy_src->pipelineBinaryPrecompiledInternalCache;
+    pipelineBinaryCompressedData = copy_src->pipelineBinaryCompressedData;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDevicePipelineBinaryInternalCacheControlKHR::safe_VkDevicePipelineBinaryInternalCacheControlKHR(
+    const VkDevicePipelineBinaryInternalCacheControlKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), disableInternalCache(in_struct->disableInternalCache) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDevicePipelineBinaryInternalCacheControlKHR::safe_VkDevicePipelineBinaryInternalCacheControlKHR()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR), pNext(nullptr), disableInternalCache() {}
+
+safe_VkDevicePipelineBinaryInternalCacheControlKHR::safe_VkDevicePipelineBinaryInternalCacheControlKHR(
+    const safe_VkDevicePipelineBinaryInternalCacheControlKHR& copy_src) {
+    sType = copy_src.sType;
+    disableInternalCache = copy_src.disableInternalCache;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDevicePipelineBinaryInternalCacheControlKHR& safe_VkDevicePipelineBinaryInternalCacheControlKHR::operator=(
+    const safe_VkDevicePipelineBinaryInternalCacheControlKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    disableInternalCache = copy_src.disableInternalCache;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDevicePipelineBinaryInternalCacheControlKHR::~safe_VkDevicePipelineBinaryInternalCacheControlKHR() { FreePnextChain(pNext); }
+
+void safe_VkDevicePipelineBinaryInternalCacheControlKHR::initialize(const VkDevicePipelineBinaryInternalCacheControlKHR* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    disableInternalCache = in_struct->disableInternalCache;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDevicePipelineBinaryInternalCacheControlKHR::initialize(
+    const safe_VkDevicePipelineBinaryInternalCacheControlKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    disableInternalCache = copy_src->disableInternalCache;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineBinaryKeyKHR::safe_VkPipelineBinaryKeyKHR(const VkPipelineBinaryKeyKHR* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), keySize(in_struct->keySize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    for (uint32_t i = 0; i < VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR; ++i) {
+        key[i] = in_struct->key[i];
+    }
+}
+
+safe_VkPipelineBinaryKeyKHR::safe_VkPipelineBinaryKeyKHR()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR), pNext(nullptr), keySize() {}
+
+safe_VkPipelineBinaryKeyKHR::safe_VkPipelineBinaryKeyKHR(const safe_VkPipelineBinaryKeyKHR& copy_src) {
+    sType = copy_src.sType;
+    keySize = copy_src.keySize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR; ++i) {
+        key[i] = copy_src.key[i];
+    }
+}
+
+safe_VkPipelineBinaryKeyKHR& safe_VkPipelineBinaryKeyKHR::operator=(const safe_VkPipelineBinaryKeyKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    keySize = copy_src.keySize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR; ++i) {
+        key[i] = copy_src.key[i];
+    }
+
+    return *this;
+}
+
+safe_VkPipelineBinaryKeyKHR::~safe_VkPipelineBinaryKeyKHR() { FreePnextChain(pNext); }
+
+void safe_VkPipelineBinaryKeyKHR::initialize(const VkPipelineBinaryKeyKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    keySize = in_struct->keySize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    for (uint32_t i = 0; i < VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR; ++i) {
+        key[i] = in_struct->key[i];
+    }
+}
+
+void safe_VkPipelineBinaryKeyKHR::initialize(const safe_VkPipelineBinaryKeyKHR* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    keySize = copy_src->keySize;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR; ++i) {
+        key[i] = copy_src->key[i];
+    }
+}
+
+safe_VkPipelineBinaryDataKHR::safe_VkPipelineBinaryDataKHR(const VkPipelineBinaryDataKHR* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state)
+    : dataSize(in_struct->dataSize), pData(nullptr) {
+    if (in_struct->pData != nullptr) {
+        auto temp = new std::byte[in_struct->dataSize];
+        std::memcpy(temp, in_struct->pData, in_struct->dataSize);
+        pData = temp;
+    }
+}
+
+safe_VkPipelineBinaryDataKHR::safe_VkPipelineBinaryDataKHR() : dataSize(), pData(nullptr) {}
+
+safe_VkPipelineBinaryDataKHR::safe_VkPipelineBinaryDataKHR(const safe_VkPipelineBinaryDataKHR& copy_src) {
+    dataSize = copy_src.dataSize;
+
+    if (copy_src.pData != nullptr) {
+        auto temp = new std::byte[copy_src.dataSize];
+        std::memcpy(temp, copy_src.pData, copy_src.dataSize);
+        pData = temp;
+    }
+}
+
+safe_VkPipelineBinaryDataKHR& safe_VkPipelineBinaryDataKHR::operator=(const safe_VkPipelineBinaryDataKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pData != nullptr) {
+        auto temp = reinterpret_cast<const std::byte*>(pData);
+        delete[] temp;
+    }
+
+    dataSize = copy_src.dataSize;
+
+    if (copy_src.pData != nullptr) {
+        auto temp = new std::byte[copy_src.dataSize];
+        std::memcpy(temp, copy_src.pData, copy_src.dataSize);
+        pData = temp;
+    }
+
+    return *this;
+}
+
+safe_VkPipelineBinaryDataKHR::~safe_VkPipelineBinaryDataKHR() {
+    if (pData != nullptr) {
+        auto temp = reinterpret_cast<const std::byte*>(pData);
+        delete[] temp;
+    }
+}
+
+void safe_VkPipelineBinaryDataKHR::initialize(const VkPipelineBinaryDataKHR* in_struct,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pData != nullptr) {
+        auto temp = reinterpret_cast<const std::byte*>(pData);
+        delete[] temp;
+    }
+    dataSize = in_struct->dataSize;
+
+    if (in_struct->pData != nullptr) {
+        auto temp = new std::byte[in_struct->dataSize];
+        std::memcpy(temp, in_struct->pData, in_struct->dataSize);
+        pData = temp;
+    }
+}
+
+void safe_VkPipelineBinaryDataKHR::initialize(const safe_VkPipelineBinaryDataKHR* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    dataSize = copy_src->dataSize;
+
+    if (copy_src->pData != nullptr) {
+        auto temp = new std::byte[copy_src->dataSize];
+        std::memcpy(temp, copy_src->pData, copy_src->dataSize);
+        pData = temp;
+    }
+}
+
+safe_VkPipelineBinaryKeysAndDataKHR::safe_VkPipelineBinaryKeysAndDataKHR(const VkPipelineBinaryKeysAndDataKHR* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state)
+    : binaryCount(in_struct->binaryCount), pPipelineBinaryKeys(nullptr), pPipelineBinaryData(nullptr) {
+    if (binaryCount && in_struct->pPipelineBinaryKeys) {
+        pPipelineBinaryKeys = new safe_VkPipelineBinaryKeyKHR[binaryCount];
+        for (uint32_t i = 0; i < binaryCount; ++i) {
+            pPipelineBinaryKeys[i].initialize(&in_struct->pPipelineBinaryKeys[i]);
+        }
+    }
+    if (binaryCount && in_struct->pPipelineBinaryData) {
+        pPipelineBinaryData = new safe_VkPipelineBinaryDataKHR[binaryCount];
+        for (uint32_t i = 0; i < binaryCount; ++i) {
+            pPipelineBinaryData[i].initialize(&in_struct->pPipelineBinaryData[i]);
+        }
+    }
+}
+
+safe_VkPipelineBinaryKeysAndDataKHR::safe_VkPipelineBinaryKeysAndDataKHR()
+    : binaryCount(), pPipelineBinaryKeys(nullptr), pPipelineBinaryData(nullptr) {}
+
+safe_VkPipelineBinaryKeysAndDataKHR::safe_VkPipelineBinaryKeysAndDataKHR(const safe_VkPipelineBinaryKeysAndDataKHR& copy_src) {
+    binaryCount = copy_src.binaryCount;
+    pPipelineBinaryKeys = nullptr;
+    pPipelineBinaryData = nullptr;
+    if (binaryCount && copy_src.pPipelineBinaryKeys) {
+        pPipelineBinaryKeys = new safe_VkPipelineBinaryKeyKHR[binaryCount];
+        for (uint32_t i = 0; i < binaryCount; ++i) {
+            pPipelineBinaryKeys[i].initialize(&copy_src.pPipelineBinaryKeys[i]);
+        }
+    }
+    if (binaryCount && copy_src.pPipelineBinaryData) {
+        pPipelineBinaryData = new safe_VkPipelineBinaryDataKHR[binaryCount];
+        for (uint32_t i = 0; i < binaryCount; ++i) {
+            pPipelineBinaryData[i].initialize(&copy_src.pPipelineBinaryData[i]);
+        }
+    }
+}
+
+safe_VkPipelineBinaryKeysAndDataKHR& safe_VkPipelineBinaryKeysAndDataKHR::operator=(
+    const safe_VkPipelineBinaryKeysAndDataKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pPipelineBinaryKeys) delete[] pPipelineBinaryKeys;
+    if (pPipelineBinaryData) delete[] pPipelineBinaryData;
+
+    binaryCount = copy_src.binaryCount;
+    pPipelineBinaryKeys = nullptr;
+    pPipelineBinaryData = nullptr;
+    if (binaryCount && copy_src.pPipelineBinaryKeys) {
+        pPipelineBinaryKeys = new safe_VkPipelineBinaryKeyKHR[binaryCount];
+        for (uint32_t i = 0; i < binaryCount; ++i) {
+            pPipelineBinaryKeys[i].initialize(&copy_src.pPipelineBinaryKeys[i]);
+        }
+    }
+    if (binaryCount && copy_src.pPipelineBinaryData) {
+        pPipelineBinaryData = new safe_VkPipelineBinaryDataKHR[binaryCount];
+        for (uint32_t i = 0; i < binaryCount; ++i) {
+            pPipelineBinaryData[i].initialize(&copy_src.pPipelineBinaryData[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkPipelineBinaryKeysAndDataKHR::~safe_VkPipelineBinaryKeysAndDataKHR() {
+    if (pPipelineBinaryKeys) delete[] pPipelineBinaryKeys;
+    if (pPipelineBinaryData) delete[] pPipelineBinaryData;
+}
+
+void safe_VkPipelineBinaryKeysAndDataKHR::initialize(const VkPipelineBinaryKeysAndDataKHR* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pPipelineBinaryKeys) delete[] pPipelineBinaryKeys;
+    if (pPipelineBinaryData) delete[] pPipelineBinaryData;
+    binaryCount = in_struct->binaryCount;
+    pPipelineBinaryKeys = nullptr;
+    pPipelineBinaryData = nullptr;
+    if (binaryCount && in_struct->pPipelineBinaryKeys) {
+        pPipelineBinaryKeys = new safe_VkPipelineBinaryKeyKHR[binaryCount];
+        for (uint32_t i = 0; i < binaryCount; ++i) {
+            pPipelineBinaryKeys[i].initialize(&in_struct->pPipelineBinaryKeys[i]);
+        }
+    }
+    if (binaryCount && in_struct->pPipelineBinaryData) {
+        pPipelineBinaryData = new safe_VkPipelineBinaryDataKHR[binaryCount];
+        for (uint32_t i = 0; i < binaryCount; ++i) {
+            pPipelineBinaryData[i].initialize(&in_struct->pPipelineBinaryData[i]);
+        }
+    }
+}
+
+void safe_VkPipelineBinaryKeysAndDataKHR::initialize(const safe_VkPipelineBinaryKeysAndDataKHR* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    binaryCount = copy_src->binaryCount;
+    pPipelineBinaryKeys = nullptr;
+    pPipelineBinaryData = nullptr;
+    if (binaryCount && copy_src->pPipelineBinaryKeys) {
+        pPipelineBinaryKeys = new safe_VkPipelineBinaryKeyKHR[binaryCount];
+        for (uint32_t i = 0; i < binaryCount; ++i) {
+            pPipelineBinaryKeys[i].initialize(&copy_src->pPipelineBinaryKeys[i]);
+        }
+    }
+    if (binaryCount && copy_src->pPipelineBinaryData) {
+        pPipelineBinaryData = new safe_VkPipelineBinaryDataKHR[binaryCount];
+        for (uint32_t i = 0; i < binaryCount; ++i) {
+            pPipelineBinaryData[i].initialize(&copy_src->pPipelineBinaryData[i]);
+        }
+    }
+}
+
+safe_VkPipelineCreateInfoKHR::safe_VkPipelineCreateInfoKHR(const VkPipelineCreateInfoKHR* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPipelineCreateInfoKHR::safe_VkPipelineCreateInfoKHR() : sType(VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR), pNext(nullptr) {}
+
+safe_VkPipelineCreateInfoKHR::safe_VkPipelineCreateInfoKHR(const safe_VkPipelineCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPipelineCreateInfoKHR& safe_VkPipelineCreateInfoKHR::operator=(const safe_VkPipelineCreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineCreateInfoKHR::~safe_VkPipelineCreateInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkPipelineCreateInfoKHR::initialize(const VkPipelineCreateInfoKHR* in_struct,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPipelineCreateInfoKHR::initialize(const safe_VkPipelineCreateInfoKHR* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineBinaryCreateInfoKHR::safe_VkPipelineBinaryCreateInfoKHR(const VkPipelineBinaryCreateInfoKHR* in_struct,
+                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), pKeysAndDataInfo(nullptr), pipeline(in_struct->pipeline), pPipelineCreateInfo(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pKeysAndDataInfo) pKeysAndDataInfo = new safe_VkPipelineBinaryKeysAndDataKHR(in_struct->pKeysAndDataInfo);
+    if (in_struct->pPipelineCreateInfo) pPipelineCreateInfo = new safe_VkPipelineCreateInfoKHR(in_struct->pPipelineCreateInfo);
+}
+
+safe_VkPipelineBinaryCreateInfoKHR::safe_VkPipelineBinaryCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR),
+      pNext(nullptr),
+      pKeysAndDataInfo(nullptr),
+      pipeline(),
+      pPipelineCreateInfo(nullptr) {}
+
+safe_VkPipelineBinaryCreateInfoKHR::safe_VkPipelineBinaryCreateInfoKHR(const safe_VkPipelineBinaryCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pKeysAndDataInfo = nullptr;
+    pipeline = copy_src.pipeline;
+    pPipelineCreateInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pKeysAndDataInfo) pKeysAndDataInfo = new safe_VkPipelineBinaryKeysAndDataKHR(*copy_src.pKeysAndDataInfo);
+    if (copy_src.pPipelineCreateInfo) pPipelineCreateInfo = new safe_VkPipelineCreateInfoKHR(*copy_src.pPipelineCreateInfo);
+}
+
+safe_VkPipelineBinaryCreateInfoKHR& safe_VkPipelineBinaryCreateInfoKHR::operator=(
+    const safe_VkPipelineBinaryCreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pKeysAndDataInfo) delete pKeysAndDataInfo;
+    if (pPipelineCreateInfo) delete pPipelineCreateInfo;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pKeysAndDataInfo = nullptr;
+    pipeline = copy_src.pipeline;
+    pPipelineCreateInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pKeysAndDataInfo) pKeysAndDataInfo = new safe_VkPipelineBinaryKeysAndDataKHR(*copy_src.pKeysAndDataInfo);
+    if (copy_src.pPipelineCreateInfo) pPipelineCreateInfo = new safe_VkPipelineCreateInfoKHR(*copy_src.pPipelineCreateInfo);
+
+    return *this;
+}
+
+safe_VkPipelineBinaryCreateInfoKHR::~safe_VkPipelineBinaryCreateInfoKHR() {
+    if (pKeysAndDataInfo) delete pKeysAndDataInfo;
+    if (pPipelineCreateInfo) delete pPipelineCreateInfo;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineBinaryCreateInfoKHR::initialize(const VkPipelineBinaryCreateInfoKHR* in_struct,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pKeysAndDataInfo) delete pKeysAndDataInfo;
+    if (pPipelineCreateInfo) delete pPipelineCreateInfo;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pKeysAndDataInfo = nullptr;
+    pipeline = in_struct->pipeline;
+    pPipelineCreateInfo = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (in_struct->pKeysAndDataInfo) pKeysAndDataInfo = new safe_VkPipelineBinaryKeysAndDataKHR(in_struct->pKeysAndDataInfo);
+    if (in_struct->pPipelineCreateInfo) pPipelineCreateInfo = new safe_VkPipelineCreateInfoKHR(in_struct->pPipelineCreateInfo);
+}
+
+void safe_VkPipelineBinaryCreateInfoKHR::initialize(const safe_VkPipelineBinaryCreateInfoKHR* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pKeysAndDataInfo = nullptr;
+    pipeline = copy_src->pipeline;
+    pPipelineCreateInfo = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (copy_src->pKeysAndDataInfo) pKeysAndDataInfo = new safe_VkPipelineBinaryKeysAndDataKHR(*copy_src->pKeysAndDataInfo);
+    if (copy_src->pPipelineCreateInfo) pPipelineCreateInfo = new safe_VkPipelineCreateInfoKHR(*copy_src->pPipelineCreateInfo);
+}
+
+safe_VkPipelineBinaryInfoKHR::safe_VkPipelineBinaryInfoKHR(const VkPipelineBinaryInfoKHR* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), binaryCount(in_struct->binaryCount), pPipelineBinaries(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (binaryCount && in_struct->pPipelineBinaries) {
+        pPipelineBinaries = new VkPipelineBinaryKHR[binaryCount];
+        for (uint32_t i = 0; i < binaryCount; ++i) {
+            pPipelineBinaries[i] = in_struct->pPipelineBinaries[i];
+        }
+    }
+}
+
+safe_VkPipelineBinaryInfoKHR::safe_VkPipelineBinaryInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR), pNext(nullptr), binaryCount(), pPipelineBinaries(nullptr) {}
+
+safe_VkPipelineBinaryInfoKHR::safe_VkPipelineBinaryInfoKHR(const safe_VkPipelineBinaryInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    binaryCount = copy_src.binaryCount;
+    pPipelineBinaries = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (binaryCount && copy_src.pPipelineBinaries) {
+        pPipelineBinaries = new VkPipelineBinaryKHR[binaryCount];
+        for (uint32_t i = 0; i < binaryCount; ++i) {
+            pPipelineBinaries[i] = copy_src.pPipelineBinaries[i];
+        }
+    }
+}
+
+safe_VkPipelineBinaryInfoKHR& safe_VkPipelineBinaryInfoKHR::operator=(const safe_VkPipelineBinaryInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pPipelineBinaries) delete[] pPipelineBinaries;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    binaryCount = copy_src.binaryCount;
+    pPipelineBinaries = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (binaryCount && copy_src.pPipelineBinaries) {
+        pPipelineBinaries = new VkPipelineBinaryKHR[binaryCount];
+        for (uint32_t i = 0; i < binaryCount; ++i) {
+            pPipelineBinaries[i] = copy_src.pPipelineBinaries[i];
+        }
+    }
+
+    return *this;
+}
+
+safe_VkPipelineBinaryInfoKHR::~safe_VkPipelineBinaryInfoKHR() {
+    if (pPipelineBinaries) delete[] pPipelineBinaries;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineBinaryInfoKHR::initialize(const VkPipelineBinaryInfoKHR* in_struct,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pPipelineBinaries) delete[] pPipelineBinaries;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    binaryCount = in_struct->binaryCount;
+    pPipelineBinaries = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (binaryCount && in_struct->pPipelineBinaries) {
+        pPipelineBinaries = new VkPipelineBinaryKHR[binaryCount];
+        for (uint32_t i = 0; i < binaryCount; ++i) {
+            pPipelineBinaries[i] = in_struct->pPipelineBinaries[i];
+        }
+    }
+}
+
+void safe_VkPipelineBinaryInfoKHR::initialize(const safe_VkPipelineBinaryInfoKHR* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    binaryCount = copy_src->binaryCount;
+    pPipelineBinaries = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (binaryCount && copy_src->pPipelineBinaries) {
+        pPipelineBinaries = new VkPipelineBinaryKHR[binaryCount];
+        for (uint32_t i = 0; i < binaryCount; ++i) {
+            pPipelineBinaries[i] = copy_src->pPipelineBinaries[i];
+        }
+    }
+}
+
+safe_VkReleaseCapturedPipelineDataInfoKHR::safe_VkReleaseCapturedPipelineDataInfoKHR(
+    const VkReleaseCapturedPipelineDataInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), pipeline(in_struct->pipeline) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkReleaseCapturedPipelineDataInfoKHR::safe_VkReleaseCapturedPipelineDataInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR), pNext(nullptr), pipeline() {}
+
+safe_VkReleaseCapturedPipelineDataInfoKHR::safe_VkReleaseCapturedPipelineDataInfoKHR(
+    const safe_VkReleaseCapturedPipelineDataInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pipeline = copy_src.pipeline;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkReleaseCapturedPipelineDataInfoKHR& safe_VkReleaseCapturedPipelineDataInfoKHR::operator=(
+    const safe_VkReleaseCapturedPipelineDataInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pipeline = copy_src.pipeline;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkReleaseCapturedPipelineDataInfoKHR::~safe_VkReleaseCapturedPipelineDataInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkReleaseCapturedPipelineDataInfoKHR::initialize(const VkReleaseCapturedPipelineDataInfoKHR* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pipeline = in_struct->pipeline;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkReleaseCapturedPipelineDataInfoKHR::initialize(const safe_VkReleaseCapturedPipelineDataInfoKHR* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pipeline = copy_src->pipeline;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineBinaryDataInfoKHR::safe_VkPipelineBinaryDataInfoKHR(const VkPipelineBinaryDataInfoKHR* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), pipelineBinary(in_struct->pipelineBinary) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPipelineBinaryDataInfoKHR::safe_VkPipelineBinaryDataInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR), pNext(nullptr), pipelineBinary() {}
+
+safe_VkPipelineBinaryDataInfoKHR::safe_VkPipelineBinaryDataInfoKHR(const safe_VkPipelineBinaryDataInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pipelineBinary = copy_src.pipelineBinary;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPipelineBinaryDataInfoKHR& safe_VkPipelineBinaryDataInfoKHR::operator=(const safe_VkPipelineBinaryDataInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pipelineBinary = copy_src.pipelineBinary;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineBinaryDataInfoKHR::~safe_VkPipelineBinaryDataInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkPipelineBinaryDataInfoKHR::initialize(const VkPipelineBinaryDataInfoKHR* in_struct,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pipelineBinary = in_struct->pipelineBinary;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPipelineBinaryDataInfoKHR::initialize(const safe_VkPipelineBinaryDataInfoKHR* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pipelineBinary = copy_src->pipelineBinary;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineBinaryHandlesInfoKHR::safe_VkPipelineBinaryHandlesInfoKHR(const VkPipelineBinaryHandlesInfoKHR* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType), pipelineBinaryCount(in_struct->pipelineBinaryCount), pPipelineBinaries(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (pipelineBinaryCount && in_struct->pPipelineBinaries) {
+        pPipelineBinaries = new VkPipelineBinaryKHR[pipelineBinaryCount];
+        for (uint32_t i = 0; i < pipelineBinaryCount; ++i) {
+            pPipelineBinaries[i] = in_struct->pPipelineBinaries[i];
+        }
+    }
+}
+
+safe_VkPipelineBinaryHandlesInfoKHR::safe_VkPipelineBinaryHandlesInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR),
+      pNext(nullptr),
+      pipelineBinaryCount(),
+      pPipelineBinaries(nullptr) {}
+
+safe_VkPipelineBinaryHandlesInfoKHR::safe_VkPipelineBinaryHandlesInfoKHR(const safe_VkPipelineBinaryHandlesInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pipelineBinaryCount = copy_src.pipelineBinaryCount;
+    pPipelineBinaries = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (pipelineBinaryCount && copy_src.pPipelineBinaries) {
+        pPipelineBinaries = new VkPipelineBinaryKHR[pipelineBinaryCount];
+        for (uint32_t i = 0; i < pipelineBinaryCount; ++i) {
+            pPipelineBinaries[i] = copy_src.pPipelineBinaries[i];
+        }
+    }
+}
+
+safe_VkPipelineBinaryHandlesInfoKHR& safe_VkPipelineBinaryHandlesInfoKHR::operator=(
+    const safe_VkPipelineBinaryHandlesInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pPipelineBinaries) delete[] pPipelineBinaries;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pipelineBinaryCount = copy_src.pipelineBinaryCount;
+    pPipelineBinaries = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (pipelineBinaryCount && copy_src.pPipelineBinaries) {
+        pPipelineBinaries = new VkPipelineBinaryKHR[pipelineBinaryCount];
+        for (uint32_t i = 0; i < pipelineBinaryCount; ++i) {
+            pPipelineBinaries[i] = copy_src.pPipelineBinaries[i];
+        }
+    }
+
+    return *this;
+}
+
+safe_VkPipelineBinaryHandlesInfoKHR::~safe_VkPipelineBinaryHandlesInfoKHR() {
+    if (pPipelineBinaries) delete[] pPipelineBinaries;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineBinaryHandlesInfoKHR::initialize(const VkPipelineBinaryHandlesInfoKHR* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pPipelineBinaries) delete[] pPipelineBinaries;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pipelineBinaryCount = in_struct->pipelineBinaryCount;
+    pPipelineBinaries = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (pipelineBinaryCount && in_struct->pPipelineBinaries) {
+        pPipelineBinaries = new VkPipelineBinaryKHR[pipelineBinaryCount];
+        for (uint32_t i = 0; i < pipelineBinaryCount; ++i) {
+            pPipelineBinaries[i] = in_struct->pPipelineBinaries[i];
+        }
+    }
+}
+
+void safe_VkPipelineBinaryHandlesInfoKHR::initialize(const safe_VkPipelineBinaryHandlesInfoKHR* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pipelineBinaryCount = copy_src->pipelineBinaryCount;
+    pPipelineBinaries = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (pipelineBinaryCount && copy_src->pPipelineBinaries) {
+        pPipelineBinaries = new VkPipelineBinaryKHR[pipelineBinaryCount];
+        for (uint32_t i = 0; i < pipelineBinaryCount; ++i) {
+            pPipelineBinaries[i] = copy_src->pPipelineBinaries[i];
+        }
+    }
+}
+
 safe_VkCooperativeMatrixPropertiesKHR::safe_VkCooperativeMatrixPropertiesKHR(const VkCooperativeMatrixPropertiesKHR* in_struct,
                                                                              [[maybe_unused]] PNextCopyState* copy_state,
                                                                              bool copy_pnext)
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index 8b56c1e..f1a065a 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -60,6 +60,12 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
                 safe_pNext = new safe_VkShaderModuleCreateInfo(reinterpret_cast<const VkShaderModuleCreateInfo *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
+                safe_pNext = new safe_VkComputePipelineCreateInfo(reinterpret_cast<const VkComputePipelineCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
+                safe_pNext = new safe_VkGraphicsPipelineCreateInfo(reinterpret_cast<const VkGraphicsPipelineCreateInfo *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:
                 safe_pNext = new safe_VkPipelineLayoutCreateInfo(reinterpret_cast<const VkPipelineLayoutCreateInfo *>(pNext), copy_state, false);
                 break;
@@ -704,6 +710,18 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
                 safe_pNext = new safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDevicePipelineBinaryFeaturesKHR(reinterpret_cast<const VkPhysicalDevicePipelineBinaryFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR:
+                safe_pNext = new safe_VkPhysicalDevicePipelineBinaryPropertiesKHR(reinterpret_cast<const VkPhysicalDevicePipelineBinaryPropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR:
+                safe_pNext = new safe_VkDevicePipelineBinaryInternalCacheControlKHR(reinterpret_cast<const VkDevicePipelineBinaryInternalCacheControlKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR:
+                safe_pNext = new safe_VkPipelineBinaryInfoKHR(reinterpret_cast<const VkPipelineBinaryInfoKHR *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
                 safe_pNext = new safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *>(pNext), copy_state, false);
                 break;
@@ -919,6 +937,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX:
                 safe_pNext = new safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX(reinterpret_cast<const VkPhysicalDeviceShaderEnqueuePropertiesAMDX *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX:
+                safe_pNext = new safe_VkExecutionGraphPipelineCreateInfoAMDX(reinterpret_cast<const VkExecutionGraphPipelineCreateInfoAMDX *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX:
                 safe_pNext = new safe_VkPipelineShaderStageNodeCreateInfoAMDX(reinterpret_cast<const VkPipelineShaderStageNodeCreateInfoAMDX *>(pNext), copy_state, false);
                 break;
@@ -986,6 +1007,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
                 safe_pNext = new safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV:
+                safe_pNext = new safe_VkRayTracingPipelineCreateInfoNV(reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
                 safe_pNext = new safe_VkWriteDescriptorSetAccelerationStructureNV(reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV *>(pNext), copy_state, false);
                 break;
@@ -1834,6 +1858,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
                 safe_pNext = new safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR(reinterpret_cast<const VkPhysicalDeviceAccelerationStructurePropertiesKHR *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR:
+                safe_pNext = new safe_VkRayTracingPipelineCreateInfoKHR(reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
                 safe_pNext = new safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *>(pNext), copy_state, false);
                 break;
@@ -1898,6 +1925,12 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
             delete reinterpret_cast<safe_VkShaderModuleCreateInfo *>(header);
             break;
+        case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
+            delete reinterpret_cast<safe_VkComputePipelineCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
+            delete reinterpret_cast<safe_VkGraphicsPipelineCreateInfo *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:
             delete reinterpret_cast<safe_VkPipelineLayoutCreateInfo *>(header);
             break;
@@ -2542,6 +2575,18 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
             delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR:
+            delete reinterpret_cast<safe_VkPhysicalDevicePipelineBinaryFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR:
+            delete reinterpret_cast<safe_VkPhysicalDevicePipelineBinaryPropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR:
+            delete reinterpret_cast<safe_VkDevicePipelineBinaryInternalCacheControlKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR:
+            delete reinterpret_cast<safe_VkPipelineBinaryInfoKHR *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
             delete reinterpret_cast<safe_VkPhysicalDeviceCooperativeMatrixFeaturesKHR *>(header);
             break;
@@ -2757,6 +2802,9 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX:
             delete reinterpret_cast<safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX *>(header);
             break;
+        case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX:
+            delete reinterpret_cast<safe_VkExecutionGraphPipelineCreateInfoAMDX *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX:
             delete reinterpret_cast<safe_VkPipelineShaderStageNodeCreateInfoAMDX *>(header);
             break;
@@ -2824,6 +2872,9 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
             delete reinterpret_cast<safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *>(header);
             break;
+        case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV:
+            delete reinterpret_cast<safe_VkRayTracingPipelineCreateInfoNV *>(header);
+            break;
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
             delete reinterpret_cast<safe_VkWriteDescriptorSetAccelerationStructureNV *>(header);
             break;
@@ -3672,6 +3723,9 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
             delete reinterpret_cast<safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR *>(header);
             break;
+        case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR:
+            delete reinterpret_cast<safe_VkRayTracingPipelineCreateInfoKHR *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
             delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR *>(header);
             break;

From 8f19d57274815e5dd0613138b378b73773bad2f8 Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Fri, 30 Aug 2024 08:43:11 -0700
Subject: [PATCH 045/106] build: Update to header 1.3.295

---
 include/vulkan/utility/vk_safe_struct.hpp   |  69 ++++++++----
 include/vulkan/utility/vk_struct_helper.hpp |   3 +-
 include/vulkan/vk_enum_string_helper.h      |   6 +-
 scripts/known_good.json                     |   2 +-
 src/vulkan/vk_safe_struct_khr.cpp           | 113 ++++++++++++++++++++
 src/vulkan/vk_safe_struct_utils.cpp         |  48 +++------
 src/vulkan/vk_safe_struct_vendor.cpp        |  60 -----------
 7 files changed, 178 insertions(+), 123 deletions(-)

diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index cb4e3b3..083b5c2 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -8185,6 +8185,52 @@ struct safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR {
         return reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesKHR const*>(this);
     }
 };
+struct safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 computeDerivativeGroupQuads;
+    VkBool32 computeDerivativeGroupLinear;
+
+    safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR(const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR* in_struct,
+                                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR(
+        const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR& operator=(
+        const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR();
+    ~safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR();
+    void initialize(const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 meshAndTaskShaderDerivatives;
+
+    safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR(
+        const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR(
+        const safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR& copy_src);
+    safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR& operator=(
+        const safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR& copy_src);
+    safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR();
+    ~safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR();
+    void initialize(const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR*>(this);
+    }
+    VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR const*>(this);
+    }
+};
 struct safe_VkVideoDecodeAV1ProfileInfoKHR {
     VkStructureType sType;
     const void* pNext{};
@@ -11259,29 +11305,6 @@ struct safe_VkPresentFrameTokenGGP {
     VkPresentFrameTokenGGP const* ptr() const { return reinterpret_cast<VkPresentFrameTokenGGP const*>(this); }
 };
 #endif  // VK_USE_PLATFORM_GGP
-struct safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV {
-    VkStructureType sType;
-    void* pNext{};
-    VkBool32 computeDerivativeGroupQuads;
-    VkBool32 computeDerivativeGroupLinear;
-
-    safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* in_struct,
-                                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
-        const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& copy_src);
-    safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& operator=(
-        const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& copy_src);
-    safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV();
-    ~safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV();
-    void initialize(const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* copy_src, PNextCopyState* copy_state = {});
-    VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* ptr() {
-        return reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(this);
-    }
-    VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const* ptr() const {
-        return reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const*>(this);
-    }
-};
 struct safe_VkPhysicalDeviceMeshShaderFeaturesNV {
     VkStructureType sType;
     void* pNext{};
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index faf95e5..1523516 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -437,6 +437,8 @@ template <> inline VkStructureType GetSType<VkPipelineBinaryHandlesInfoKHR>() {
 template <> inline VkStructureType GetSType<VkCooperativeMatrixPropertiesKHR>() { return VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeMatrixFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeMatrixPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR; }
 template <> inline VkStructureType GetSType<VkVideoDecodeAV1ProfileInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkVideoDecodeAV1CapabilitiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR; }
 template <> inline VkStructureType GetSType<VkVideoDecodeAV1SessionParametersCreateInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR; }
@@ -602,7 +604,6 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceVertexAttributeDivis
 #ifdef VK_USE_PLATFORM_GGP
 template <> inline VkStructureType GetSType<VkPresentFrameTokenGGP>() { return VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP; }
 #endif  // VK_USE_PLATFORM_GGP
-template <> inline VkStructureType GetSType<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceMeshShaderFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceMeshShaderPropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderImageFootprintFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index a26e127..ff68ccb 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -1078,8 +1078,6 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT";
         case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
             return "VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
@@ -1850,6 +1848,10 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM";
         case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM:
             return "VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR";
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR:
             return "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR";
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR:
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 4ed3bca..73d7ede 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.3.294"
+            "commit": "v1.3.295"
         },
         {
             "name": "googletest",
diff --git a/src/vulkan/vk_safe_struct_khr.cpp b/src/vulkan/vk_safe_struct_khr.cpp
index be16aba..7ece3b2 100644
--- a/src/vulkan/vk_safe_struct_khr.cpp
+++ b/src/vulkan/vk_safe_struct_khr.cpp
@@ -13177,6 +13177,119 @@ void safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR::initialize(
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR::safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR(
+    const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      computeDerivativeGroupQuads(in_struct->computeDerivativeGroupQuads),
+      computeDerivativeGroupLinear(in_struct->computeDerivativeGroupLinear) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR::safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR),
+      pNext(nullptr),
+      computeDerivativeGroupQuads(),
+      computeDerivativeGroupLinear() {}
+
+safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR::safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR(
+    const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    computeDerivativeGroupQuads = copy_src.computeDerivativeGroupQuads;
+    computeDerivativeGroupLinear = copy_src.computeDerivativeGroupLinear;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR& safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    computeDerivativeGroupQuads = copy_src.computeDerivativeGroupQuads;
+    computeDerivativeGroupLinear = copy_src.computeDerivativeGroupLinear;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR::~safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR::initialize(
+    const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    computeDerivativeGroupQuads = in_struct->computeDerivativeGroupQuads;
+    computeDerivativeGroupLinear = in_struct->computeDerivativeGroupLinear;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR::initialize(
+    const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    computeDerivativeGroupQuads = copy_src->computeDerivativeGroupQuads;
+    computeDerivativeGroupLinear = copy_src->computeDerivativeGroupLinear;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR::safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR(
+    const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), meshAndTaskShaderDerivatives(in_struct->meshAndTaskShaderDerivatives) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR::safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR),
+      pNext(nullptr),
+      meshAndTaskShaderDerivatives() {}
+
+safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR::safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR(
+    const safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    meshAndTaskShaderDerivatives = copy_src.meshAndTaskShaderDerivatives;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR& safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR::operator=(
+    const safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    meshAndTaskShaderDerivatives = copy_src.meshAndTaskShaderDerivatives;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR::~safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR::initialize(
+    const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    meshAndTaskShaderDerivatives = in_struct->meshAndTaskShaderDerivatives;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR::initialize(
+    const safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    meshAndTaskShaderDerivatives = copy_src->meshAndTaskShaderDerivatives;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkVideoDecodeAV1ProfileInfoKHR::safe_VkVideoDecodeAV1ProfileInfoKHR(const VkVideoDecodeAV1ProfileInfoKHR* in_struct,
                                                                          [[maybe_unused]] PNextCopyState* copy_state,
                                                                          bool copy_pnext)
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index f1a065a..1fd2d9b 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -60,12 +60,6 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
                 safe_pNext = new safe_VkShaderModuleCreateInfo(reinterpret_cast<const VkShaderModuleCreateInfo *>(pNext), copy_state, false);
                 break;
-            case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
-                safe_pNext = new safe_VkComputePipelineCreateInfo(reinterpret_cast<const VkComputePipelineCreateInfo *>(pNext), copy_state, false);
-                break;
-            case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
-                safe_pNext = new safe_VkGraphicsPipelineCreateInfo(reinterpret_cast<const VkGraphicsPipelineCreateInfo *>(pNext), copy_state, false);
-                break;
             case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:
                 safe_pNext = new safe_VkPipelineLayoutCreateInfo(reinterpret_cast<const VkPipelineLayoutCreateInfo *>(pNext), copy_state, false);
                 break;
@@ -728,6 +722,12 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR:
                 safe_pNext = new safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesKHR *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR(reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR:
                 safe_pNext = new safe_VkVideoDecodeAV1ProfileInfoKHR(reinterpret_cast<const VkVideoDecodeAV1ProfileInfoKHR *>(pNext), copy_state, false);
                 break;
@@ -937,9 +937,6 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX:
                 safe_pNext = new safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX(reinterpret_cast<const VkPhysicalDeviceShaderEnqueuePropertiesAMDX *>(pNext), copy_state, false);
                 break;
-            case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX:
-                safe_pNext = new safe_VkExecutionGraphPipelineCreateInfoAMDX(reinterpret_cast<const VkExecutionGraphPipelineCreateInfoAMDX *>(pNext), copy_state, false);
-                break;
             case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX:
                 safe_pNext = new safe_VkPipelineShaderStageNodeCreateInfoAMDX(reinterpret_cast<const VkPipelineShaderStageNodeCreateInfoAMDX *>(pNext), copy_state, false);
                 break;
@@ -1007,9 +1004,6 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
                 safe_pNext = new safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *>(pNext), copy_state, false);
                 break;
-            case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV:
-                safe_pNext = new safe_VkRayTracingPipelineCreateInfoNV(reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>(pNext), copy_state, false);
-                break;
             case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
                 safe_pNext = new safe_VkWriteDescriptorSetAccelerationStructureNV(reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV *>(pNext), copy_state, false);
                 break;
@@ -1051,9 +1045,6 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
                 safe_pNext = new safe_VkPresentFrameTokenGGP(reinterpret_cast<const VkPresentFrameTokenGGP *>(pNext), copy_state, false);
                 break;
 #endif  // VK_USE_PLATFORM_GGP
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
-                safe_pNext = new safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *>(pNext), copy_state, false);
-                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
                 safe_pNext = new safe_VkPhysicalDeviceMeshShaderFeaturesNV(reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV *>(pNext), copy_state, false);
                 break;
@@ -1858,9 +1849,6 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
                 safe_pNext = new safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR(reinterpret_cast<const VkPhysicalDeviceAccelerationStructurePropertiesKHR *>(pNext), copy_state, false);
                 break;
-            case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR:
-                safe_pNext = new safe_VkRayTracingPipelineCreateInfoKHR(reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>(pNext), copy_state, false);
-                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
                 safe_pNext = new safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *>(pNext), copy_state, false);
                 break;
@@ -1925,12 +1913,6 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
             delete reinterpret_cast<safe_VkShaderModuleCreateInfo *>(header);
             break;
-        case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
-            delete reinterpret_cast<safe_VkComputePipelineCreateInfo *>(header);
-            break;
-        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
-            delete reinterpret_cast<safe_VkGraphicsPipelineCreateInfo *>(header);
-            break;
         case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:
             delete reinterpret_cast<safe_VkPipelineLayoutCreateInfo *>(header);
             break;
@@ -2593,6 +2575,12 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR:
             delete reinterpret_cast<safe_VkPhysicalDeviceCooperativeMatrixPropertiesKHR *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR:
+            delete reinterpret_cast<safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR:
+            delete reinterpret_cast<safe_VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR *>(header);
+            break;
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR:
             delete reinterpret_cast<safe_VkVideoDecodeAV1ProfileInfoKHR *>(header);
             break;
@@ -2802,9 +2790,6 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX:
             delete reinterpret_cast<safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX *>(header);
             break;
-        case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX:
-            delete reinterpret_cast<safe_VkExecutionGraphPipelineCreateInfoAMDX *>(header);
-            break;
         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX:
             delete reinterpret_cast<safe_VkPipelineShaderStageNodeCreateInfoAMDX *>(header);
             break;
@@ -2872,9 +2857,6 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
             delete reinterpret_cast<safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *>(header);
             break;
-        case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV:
-            delete reinterpret_cast<safe_VkRayTracingPipelineCreateInfoNV *>(header);
-            break;
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
             delete reinterpret_cast<safe_VkWriteDescriptorSetAccelerationStructureNV *>(header);
             break;
@@ -2916,9 +2898,6 @@ void FreePnextChain(const void *pNext) {
             delete reinterpret_cast<safe_VkPresentFrameTokenGGP *>(header);
             break;
 #endif  // VK_USE_PLATFORM_GGP
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
-            delete reinterpret_cast<safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *>(header);
-            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
             delete reinterpret_cast<safe_VkPhysicalDeviceMeshShaderFeaturesNV *>(header);
             break;
@@ -3723,9 +3702,6 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
             delete reinterpret_cast<safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR *>(header);
             break;
-        case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR:
-            delete reinterpret_cast<safe_VkRayTracingPipelineCreateInfoKHR *>(header);
-            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
             delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR *>(header);
             break;
diff --git a/src/vulkan/vk_safe_struct_vendor.cpp b/src/vulkan/vk_safe_struct_vendor.cpp
index c6310cc..b6696a8 100644
--- a/src/vulkan/vk_safe_struct_vendor.cpp
+++ b/src/vulkan/vk_safe_struct_vendor.cpp
@@ -4801,66 +4801,6 @@ void safe_VkPresentFrameTokenGGP::initialize(const safe_VkPresentFrameTokenGGP*
 }
 #endif  // VK_USE_PLATFORM_GGP
 
-safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
-    const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
-    bool copy_pnext)
-    : sType(in_struct->sType),
-      computeDerivativeGroupQuads(in_struct->computeDerivativeGroupQuads),
-      computeDerivativeGroupLinear(in_struct->computeDerivativeGroupLinear) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV()
-    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV),
-      pNext(nullptr),
-      computeDerivativeGroupQuads(),
-      computeDerivativeGroupLinear() {}
-
-safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
-    const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& copy_src) {
-    sType = copy_src.sType;
-    computeDerivativeGroupQuads = copy_src.computeDerivativeGroupQuads;
-    computeDerivativeGroupLinear = copy_src.computeDerivativeGroupLinear;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::operator=(
-    const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    computeDerivativeGroupQuads = copy_src.computeDerivativeGroupQuads;
-    computeDerivativeGroupLinear = copy_src.computeDerivativeGroupLinear;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::~safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV() {
-    FreePnextChain(pNext);
-}
-
-void safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::initialize(
-    const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    computeDerivativeGroupQuads = in_struct->computeDerivativeGroupQuads;
-    computeDerivativeGroupLinear = in_struct->computeDerivativeGroupLinear;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::initialize(
-    const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    computeDerivativeGroupQuads = copy_src->computeDerivativeGroupQuads;
-    computeDerivativeGroupLinear = copy_src->computeDerivativeGroupLinear;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
 safe_VkPhysicalDeviceMeshShaderFeaturesNV::safe_VkPhysicalDeviceMeshShaderFeaturesNV(
     const VkPhysicalDeviceMeshShaderFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType), taskShader(in_struct->taskShader), meshShader(in_struct->meshShader) {

From fbb4db92c6b2ac09003b2b8e5ceb978f4f2dda71 Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Mon, 2 Sep 2024 11:22:55 -0700
Subject: [PATCH 046/106] safestruct: Add VkPipelineCreatInfoKHR workaround

Pipeline create info structs can appear in the VkPipelineCreatInfoKHR
pNext chain even though they don't extend that structure in the
traditional sense.
---
 scripts/generators/safe_struct_generator.py | 15 +++++++++++--
 src/vulkan/vk_safe_struct_utils.cpp         | 24 +++++++++++++++++++++
 2 files changed, 37 insertions(+), 2 deletions(-)

diff --git a/scripts/generators/safe_struct_generator.py b/scripts/generators/safe_struct_generator.py
index e1d2bf0..f4e17bf 100644
--- a/scripts/generators/safe_struct_generator.py
+++ b/scripts/generators/safe_struct_generator.py
@@ -82,6 +82,17 @@ class SafeStructOutputGenerator(BaseGenerator):
                 ', const bool is_host, const VkAccelerationStructureBuildRangeInfoKHR *build_range_info',
         }
 
+    def isInPnextChain(self, struct: Struct) -> bool:
+        # Can appear in VkPipelineCreateInfoKHR::pNext even though it isn't listed in the xml structextends attribute
+        # VUID-VkPipelineCreateInfoKHR-pNext-09604
+        pipeline_create_infos = [
+            'VkGraphicsPipelineCreateInfo',
+            'VkExecutionGraphPipelineCreateInfoAMDX',
+            'VkRayTracingPipelineCreateInfoKHR',
+            'VkComputePipelineCreateInfo',
+        ]
+        return struct.extends or struct.name in pipeline_create_infos
+
     # Determine if a structure needs a safe_struct helper function
     # That is, it has an sType or one of its members is a pointer
     def needSafeStruct(self, struct: Struct) -> bool:
@@ -296,7 +307,7 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             }
 ''')
         guard_helper = PlatformGuardHelper()
-        for struct in [x for x in self.vk.structs.values() if x.extends]:
+        for struct in filter(self.isInPnextChain, self.vk.structs.values()):
             safe_name = self.convertName(struct.name)
             out.extend(guard_helper.add_guard(struct.protect))
             out.append(f'            case {struct.sType}:\n')
@@ -352,7 +363,7 @@ void FreePnextChain(const void *pNext) {
             break;
 ''')
 
-        for struct in [x for x in self.vk.structs.values() if x.extends]:
+        for struct in filter(self.isInPnextChain, self.vk.structs.values()):
             safe_name = self.convertName(struct.name)
             out.extend(guard_helper.add_guard(struct.protect))
             out.append(f'        case {struct.sType}:\n')
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index 1fd2d9b..3550dba 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -60,6 +60,12 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
                 safe_pNext = new safe_VkShaderModuleCreateInfo(reinterpret_cast<const VkShaderModuleCreateInfo *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
+                safe_pNext = new safe_VkComputePipelineCreateInfo(reinterpret_cast<const VkComputePipelineCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
+                safe_pNext = new safe_VkGraphicsPipelineCreateInfo(reinterpret_cast<const VkGraphicsPipelineCreateInfo *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:
                 safe_pNext = new safe_VkPipelineLayoutCreateInfo(reinterpret_cast<const VkPipelineLayoutCreateInfo *>(pNext), copy_state, false);
                 break;
@@ -937,6 +943,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX:
                 safe_pNext = new safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX(reinterpret_cast<const VkPhysicalDeviceShaderEnqueuePropertiesAMDX *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX:
+                safe_pNext = new safe_VkExecutionGraphPipelineCreateInfoAMDX(reinterpret_cast<const VkExecutionGraphPipelineCreateInfoAMDX *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX:
                 safe_pNext = new safe_VkPipelineShaderStageNodeCreateInfoAMDX(reinterpret_cast<const VkPipelineShaderStageNodeCreateInfoAMDX *>(pNext), copy_state, false);
                 break;
@@ -1849,6 +1858,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
                 safe_pNext = new safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR(reinterpret_cast<const VkPhysicalDeviceAccelerationStructurePropertiesKHR *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR:
+                safe_pNext = new safe_VkRayTracingPipelineCreateInfoKHR(reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
                 safe_pNext = new safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *>(pNext), copy_state, false);
                 break;
@@ -1913,6 +1925,12 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
             delete reinterpret_cast<safe_VkShaderModuleCreateInfo *>(header);
             break;
+        case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
+            delete reinterpret_cast<safe_VkComputePipelineCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
+            delete reinterpret_cast<safe_VkGraphicsPipelineCreateInfo *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:
             delete reinterpret_cast<safe_VkPipelineLayoutCreateInfo *>(header);
             break;
@@ -2790,6 +2808,9 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX:
             delete reinterpret_cast<safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX *>(header);
             break;
+        case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX:
+            delete reinterpret_cast<safe_VkExecutionGraphPipelineCreateInfoAMDX *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX:
             delete reinterpret_cast<safe_VkPipelineShaderStageNodeCreateInfoAMDX *>(header);
             break;
@@ -3702,6 +3723,9 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
             delete reinterpret_cast<safe_VkPhysicalDeviceAccelerationStructurePropertiesKHR *>(header);
             break;
+        case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR:
+            delete reinterpret_cast<safe_VkRayTracingPipelineCreateInfoKHR *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
             delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingPipelineFeaturesKHR *>(header);
             break;

From ea5774a13e3017b6d5d79af6fba9f0d72ca5c61a Mon Sep 17 00:00:00 2001
From: sjfricke <spencerfricke@gmail.com>
Date: Mon, 9 Sep 2024 14:47:19 -0700
Subject: [PATCH 047/106] safe: Fix VK_EXT_sample_locations

---
 include/vulkan/utility/vk_safe_struct.hpp   |  32 +++-
 scripts/generators/safe_struct_generator.py |   5 +-
 src/vulkan/vk_safe_struct_ext.cpp           | 168 ++++++++++++++------
 3 files changed, 153 insertions(+), 52 deletions(-)

diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index 083b5c2..487c50d 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -10301,13 +10301,41 @@ struct safe_VkSampleLocationsInfoEXT {
     VkSampleLocationsInfoEXT* ptr() { return reinterpret_cast<VkSampleLocationsInfoEXT*>(this); }
     VkSampleLocationsInfoEXT const* ptr() const { return reinterpret_cast<VkSampleLocationsInfoEXT const*>(this); }
 };
+struct safe_VkAttachmentSampleLocationsEXT {
+    uint32_t attachmentIndex;
+    safe_VkSampleLocationsInfoEXT sampleLocationsInfo;
+
+    safe_VkAttachmentSampleLocationsEXT(const VkAttachmentSampleLocationsEXT* in_struct, PNextCopyState* copy_state = {});
+    safe_VkAttachmentSampleLocationsEXT(const safe_VkAttachmentSampleLocationsEXT& copy_src);
+    safe_VkAttachmentSampleLocationsEXT& operator=(const safe_VkAttachmentSampleLocationsEXT& copy_src);
+    safe_VkAttachmentSampleLocationsEXT();
+    ~safe_VkAttachmentSampleLocationsEXT();
+    void initialize(const VkAttachmentSampleLocationsEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAttachmentSampleLocationsEXT* copy_src, PNextCopyState* copy_state = {});
+    VkAttachmentSampleLocationsEXT* ptr() { return reinterpret_cast<VkAttachmentSampleLocationsEXT*>(this); }
+    VkAttachmentSampleLocationsEXT const* ptr() const { return reinterpret_cast<VkAttachmentSampleLocationsEXT const*>(this); }
+};
+struct safe_VkSubpassSampleLocationsEXT {
+    uint32_t subpassIndex;
+    safe_VkSampleLocationsInfoEXT sampleLocationsInfo;
+
+    safe_VkSubpassSampleLocationsEXT(const VkSubpassSampleLocationsEXT* in_struct, PNextCopyState* copy_state = {});
+    safe_VkSubpassSampleLocationsEXT(const safe_VkSubpassSampleLocationsEXT& copy_src);
+    safe_VkSubpassSampleLocationsEXT& operator=(const safe_VkSubpassSampleLocationsEXT& copy_src);
+    safe_VkSubpassSampleLocationsEXT();
+    ~safe_VkSubpassSampleLocationsEXT();
+    void initialize(const VkSubpassSampleLocationsEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSubpassSampleLocationsEXT* copy_src, PNextCopyState* copy_state = {});
+    VkSubpassSampleLocationsEXT* ptr() { return reinterpret_cast<VkSubpassSampleLocationsEXT*>(this); }
+    VkSubpassSampleLocationsEXT const* ptr() const { return reinterpret_cast<VkSubpassSampleLocationsEXT const*>(this); }
+};
 struct safe_VkRenderPassSampleLocationsBeginInfoEXT {
     VkStructureType sType;
     const void* pNext{};
     uint32_t attachmentInitialSampleLocationsCount;
-    const VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations{};
+    safe_VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations{};
     uint32_t postSubpassSampleLocationsCount;
-    const VkSubpassSampleLocationsEXT* pPostSubpassSampleLocations{};
+    safe_VkSubpassSampleLocationsEXT* pPostSubpassSampleLocations{};
 
     safe_VkRenderPassSampleLocationsBeginInfoEXT(const VkRenderPassSampleLocationsBeginInfoEXT* in_struct,
                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
diff --git a/scripts/generators/safe_struct_generator.py b/scripts/generators/safe_struct_generator.py
index f4e17bf..f5b071f 100644
--- a/scripts/generators/safe_struct_generator.py
+++ b/scripts/generators/safe_struct_generator.py
@@ -107,6 +107,9 @@ class SafeStructOutputGenerator(BaseGenerator):
         for member in struct.members:
             if member.pointer:
                 return True
+        # The VK_EXT_sample_locations design created edge case, easiest to handle here
+        if struct.name == 'VkAttachmentSampleLocationsEXT' or struct.name == 'VkSubpassSampleLocationsEXT':
+            return True
         return False
 
     def containsObjectHandle(self, member: Member) -> bool:
@@ -170,7 +173,7 @@ class SafeStructOutputGenerator(BaseGenerator):
             #include <vulkan/utility/vk_safe_struct_utils.hpp>
 
             namespace vku {
-            
+
             // Mapping of unknown stype codes to structure lengths. This should be set up by the application
             // before vkCreateInstance() and not modified afterwards.
             std::vector<std::pair<uint32_t, uint32_t>>& GetCustomStypeInfo();
diff --git a/src/vulkan/vk_safe_struct_ext.cpp b/src/vulkan/vk_safe_struct_ext.cpp
index a31a813..739ad53 100644
--- a/src/vulkan/vk_safe_struct_ext.cpp
+++ b/src/vulkan/vk_safe_struct_ext.cpp
@@ -2688,6 +2688,75 @@ void safe_VkSampleLocationsInfoEXT::initialize(const safe_VkSampleLocationsInfoE
     }
 }
 
+safe_VkAttachmentSampleLocationsEXT::safe_VkAttachmentSampleLocationsEXT(const VkAttachmentSampleLocationsEXT* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state)
+    : attachmentIndex(in_struct->attachmentIndex), sampleLocationsInfo(&in_struct->sampleLocationsInfo) {}
+
+safe_VkAttachmentSampleLocationsEXT::safe_VkAttachmentSampleLocationsEXT() : attachmentIndex() {}
+
+safe_VkAttachmentSampleLocationsEXT::safe_VkAttachmentSampleLocationsEXT(const safe_VkAttachmentSampleLocationsEXT& copy_src) {
+    attachmentIndex = copy_src.attachmentIndex;
+    sampleLocationsInfo.initialize(&copy_src.sampleLocationsInfo);
+}
+
+safe_VkAttachmentSampleLocationsEXT& safe_VkAttachmentSampleLocationsEXT::operator=(
+    const safe_VkAttachmentSampleLocationsEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    attachmentIndex = copy_src.attachmentIndex;
+    sampleLocationsInfo.initialize(&copy_src.sampleLocationsInfo);
+
+    return *this;
+}
+
+safe_VkAttachmentSampleLocationsEXT::~safe_VkAttachmentSampleLocationsEXT() {}
+
+void safe_VkAttachmentSampleLocationsEXT::initialize(const VkAttachmentSampleLocationsEXT* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    attachmentIndex = in_struct->attachmentIndex;
+    sampleLocationsInfo.initialize(&in_struct->sampleLocationsInfo);
+}
+
+void safe_VkAttachmentSampleLocationsEXT::initialize(const safe_VkAttachmentSampleLocationsEXT* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    attachmentIndex = copy_src->attachmentIndex;
+    sampleLocationsInfo.initialize(&copy_src->sampleLocationsInfo);
+}
+
+safe_VkSubpassSampleLocationsEXT::safe_VkSubpassSampleLocationsEXT(const VkSubpassSampleLocationsEXT* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state)
+    : subpassIndex(in_struct->subpassIndex), sampleLocationsInfo(&in_struct->sampleLocationsInfo) {}
+
+safe_VkSubpassSampleLocationsEXT::safe_VkSubpassSampleLocationsEXT() : subpassIndex() {}
+
+safe_VkSubpassSampleLocationsEXT::safe_VkSubpassSampleLocationsEXT(const safe_VkSubpassSampleLocationsEXT& copy_src) {
+    subpassIndex = copy_src.subpassIndex;
+    sampleLocationsInfo.initialize(&copy_src.sampleLocationsInfo);
+}
+
+safe_VkSubpassSampleLocationsEXT& safe_VkSubpassSampleLocationsEXT::operator=(const safe_VkSubpassSampleLocationsEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    subpassIndex = copy_src.subpassIndex;
+    sampleLocationsInfo.initialize(&copy_src.sampleLocationsInfo);
+
+    return *this;
+}
+
+safe_VkSubpassSampleLocationsEXT::~safe_VkSubpassSampleLocationsEXT() {}
+
+void safe_VkSubpassSampleLocationsEXT::initialize(const VkSubpassSampleLocationsEXT* in_struct,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    subpassIndex = in_struct->subpassIndex;
+    sampleLocationsInfo.initialize(&in_struct->sampleLocationsInfo);
+}
+
+void safe_VkSubpassSampleLocationsEXT::initialize(const safe_VkSubpassSampleLocationsEXT* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    subpassIndex = copy_src->subpassIndex;
+    sampleLocationsInfo.initialize(&copy_src->sampleLocationsInfo);
+}
+
 safe_VkRenderPassSampleLocationsBeginInfoEXT::safe_VkRenderPassSampleLocationsBeginInfoEXT(
     const VkRenderPassSampleLocationsBeginInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType),
@@ -2698,16 +2767,17 @@ safe_VkRenderPassSampleLocationsBeginInfoEXT::safe_VkRenderPassSampleLocationsBe
     if (copy_pnext) {
         pNext = SafePnextCopy(in_struct->pNext, copy_state);
     }
-    if (in_struct->pAttachmentInitialSampleLocations) {
-        pAttachmentInitialSampleLocations = new VkAttachmentSampleLocationsEXT[in_struct->attachmentInitialSampleLocationsCount];
-        memcpy((void*)pAttachmentInitialSampleLocations, (void*)in_struct->pAttachmentInitialSampleLocations,
-               sizeof(VkAttachmentSampleLocationsEXT) * in_struct->attachmentInitialSampleLocationsCount);
+    if (attachmentInitialSampleLocationsCount && in_struct->pAttachmentInitialSampleLocations) {
+        pAttachmentInitialSampleLocations = new safe_VkAttachmentSampleLocationsEXT[attachmentInitialSampleLocationsCount];
+        for (uint32_t i = 0; i < attachmentInitialSampleLocationsCount; ++i) {
+            pAttachmentInitialSampleLocations[i].initialize(&in_struct->pAttachmentInitialSampleLocations[i]);
+        }
     }
-
-    if (in_struct->pPostSubpassSampleLocations) {
-        pPostSubpassSampleLocations = new VkSubpassSampleLocationsEXT[in_struct->postSubpassSampleLocationsCount];
-        memcpy((void*)pPostSubpassSampleLocations, (void*)in_struct->pPostSubpassSampleLocations,
-               sizeof(VkSubpassSampleLocationsEXT) * in_struct->postSubpassSampleLocationsCount);
+    if (postSubpassSampleLocationsCount && in_struct->pPostSubpassSampleLocations) {
+        pPostSubpassSampleLocations = new safe_VkSubpassSampleLocationsEXT[postSubpassSampleLocationsCount];
+        for (uint32_t i = 0; i < postSubpassSampleLocationsCount; ++i) {
+            pPostSubpassSampleLocations[i].initialize(&in_struct->pPostSubpassSampleLocations[i]);
+        }
     }
 }
 
@@ -2727,17 +2797,17 @@ safe_VkRenderPassSampleLocationsBeginInfoEXT::safe_VkRenderPassSampleLocationsBe
     postSubpassSampleLocationsCount = copy_src.postSubpassSampleLocationsCount;
     pPostSubpassSampleLocations = nullptr;
     pNext = SafePnextCopy(copy_src.pNext);
-
-    if (copy_src.pAttachmentInitialSampleLocations) {
-        pAttachmentInitialSampleLocations = new VkAttachmentSampleLocationsEXT[copy_src.attachmentInitialSampleLocationsCount];
-        memcpy((void*)pAttachmentInitialSampleLocations, (void*)copy_src.pAttachmentInitialSampleLocations,
-               sizeof(VkAttachmentSampleLocationsEXT) * copy_src.attachmentInitialSampleLocationsCount);
+    if (attachmentInitialSampleLocationsCount && copy_src.pAttachmentInitialSampleLocations) {
+        pAttachmentInitialSampleLocations = new safe_VkAttachmentSampleLocationsEXT[attachmentInitialSampleLocationsCount];
+        for (uint32_t i = 0; i < attachmentInitialSampleLocationsCount; ++i) {
+            pAttachmentInitialSampleLocations[i].initialize(&copy_src.pAttachmentInitialSampleLocations[i]);
+        }
     }
-
-    if (copy_src.pPostSubpassSampleLocations) {
-        pPostSubpassSampleLocations = new VkSubpassSampleLocationsEXT[copy_src.postSubpassSampleLocationsCount];
-        memcpy((void*)pPostSubpassSampleLocations, (void*)copy_src.pPostSubpassSampleLocations,
-               sizeof(VkSubpassSampleLocationsEXT) * copy_src.postSubpassSampleLocationsCount);
+    if (postSubpassSampleLocationsCount && copy_src.pPostSubpassSampleLocations) {
+        pPostSubpassSampleLocations = new safe_VkSubpassSampleLocationsEXT[postSubpassSampleLocationsCount];
+        for (uint32_t i = 0; i < postSubpassSampleLocationsCount; ++i) {
+            pPostSubpassSampleLocations[i].initialize(&copy_src.pPostSubpassSampleLocations[i]);
+        }
     }
 }
 
@@ -2755,17 +2825,17 @@ safe_VkRenderPassSampleLocationsBeginInfoEXT& safe_VkRenderPassSampleLocationsBe
     postSubpassSampleLocationsCount = copy_src.postSubpassSampleLocationsCount;
     pPostSubpassSampleLocations = nullptr;
     pNext = SafePnextCopy(copy_src.pNext);
-
-    if (copy_src.pAttachmentInitialSampleLocations) {
-        pAttachmentInitialSampleLocations = new VkAttachmentSampleLocationsEXT[copy_src.attachmentInitialSampleLocationsCount];
-        memcpy((void*)pAttachmentInitialSampleLocations, (void*)copy_src.pAttachmentInitialSampleLocations,
-               sizeof(VkAttachmentSampleLocationsEXT) * copy_src.attachmentInitialSampleLocationsCount);
+    if (attachmentInitialSampleLocationsCount && copy_src.pAttachmentInitialSampleLocations) {
+        pAttachmentInitialSampleLocations = new safe_VkAttachmentSampleLocationsEXT[attachmentInitialSampleLocationsCount];
+        for (uint32_t i = 0; i < attachmentInitialSampleLocationsCount; ++i) {
+            pAttachmentInitialSampleLocations[i].initialize(&copy_src.pAttachmentInitialSampleLocations[i]);
+        }
     }
-
-    if (copy_src.pPostSubpassSampleLocations) {
-        pPostSubpassSampleLocations = new VkSubpassSampleLocationsEXT[copy_src.postSubpassSampleLocationsCount];
-        memcpy((void*)pPostSubpassSampleLocations, (void*)copy_src.pPostSubpassSampleLocations,
-               sizeof(VkSubpassSampleLocationsEXT) * copy_src.postSubpassSampleLocationsCount);
+    if (postSubpassSampleLocationsCount && copy_src.pPostSubpassSampleLocations) {
+        pPostSubpassSampleLocations = new safe_VkSubpassSampleLocationsEXT[postSubpassSampleLocationsCount];
+        for (uint32_t i = 0; i < postSubpassSampleLocationsCount; ++i) {
+            pPostSubpassSampleLocations[i].initialize(&copy_src.pPostSubpassSampleLocations[i]);
+        }
     }
 
     return *this;
@@ -2788,17 +2858,17 @@ void safe_VkRenderPassSampleLocationsBeginInfoEXT::initialize(const VkRenderPass
     postSubpassSampleLocationsCount = in_struct->postSubpassSampleLocationsCount;
     pPostSubpassSampleLocations = nullptr;
     pNext = SafePnextCopy(in_struct->pNext, copy_state);
-
-    if (in_struct->pAttachmentInitialSampleLocations) {
-        pAttachmentInitialSampleLocations = new VkAttachmentSampleLocationsEXT[in_struct->attachmentInitialSampleLocationsCount];
-        memcpy((void*)pAttachmentInitialSampleLocations, (void*)in_struct->pAttachmentInitialSampleLocations,
-               sizeof(VkAttachmentSampleLocationsEXT) * in_struct->attachmentInitialSampleLocationsCount);
+    if (attachmentInitialSampleLocationsCount && in_struct->pAttachmentInitialSampleLocations) {
+        pAttachmentInitialSampleLocations = new safe_VkAttachmentSampleLocationsEXT[attachmentInitialSampleLocationsCount];
+        for (uint32_t i = 0; i < attachmentInitialSampleLocationsCount; ++i) {
+            pAttachmentInitialSampleLocations[i].initialize(&in_struct->pAttachmentInitialSampleLocations[i]);
+        }
     }
-
-    if (in_struct->pPostSubpassSampleLocations) {
-        pPostSubpassSampleLocations = new VkSubpassSampleLocationsEXT[in_struct->postSubpassSampleLocationsCount];
-        memcpy((void*)pPostSubpassSampleLocations, (void*)in_struct->pPostSubpassSampleLocations,
-               sizeof(VkSubpassSampleLocationsEXT) * in_struct->postSubpassSampleLocationsCount);
+    if (postSubpassSampleLocationsCount && in_struct->pPostSubpassSampleLocations) {
+        pPostSubpassSampleLocations = new safe_VkSubpassSampleLocationsEXT[postSubpassSampleLocationsCount];
+        for (uint32_t i = 0; i < postSubpassSampleLocationsCount; ++i) {
+            pPostSubpassSampleLocations[i].initialize(&in_struct->pPostSubpassSampleLocations[i]);
+        }
     }
 }
 
@@ -2810,17 +2880,17 @@ void safe_VkRenderPassSampleLocationsBeginInfoEXT::initialize(const safe_VkRende
     postSubpassSampleLocationsCount = copy_src->postSubpassSampleLocationsCount;
     pPostSubpassSampleLocations = nullptr;
     pNext = SafePnextCopy(copy_src->pNext);
-
-    if (copy_src->pAttachmentInitialSampleLocations) {
-        pAttachmentInitialSampleLocations = new VkAttachmentSampleLocationsEXT[copy_src->attachmentInitialSampleLocationsCount];
-        memcpy((void*)pAttachmentInitialSampleLocations, (void*)copy_src->pAttachmentInitialSampleLocations,
-               sizeof(VkAttachmentSampleLocationsEXT) * copy_src->attachmentInitialSampleLocationsCount);
+    if (attachmentInitialSampleLocationsCount && copy_src->pAttachmentInitialSampleLocations) {
+        pAttachmentInitialSampleLocations = new safe_VkAttachmentSampleLocationsEXT[attachmentInitialSampleLocationsCount];
+        for (uint32_t i = 0; i < attachmentInitialSampleLocationsCount; ++i) {
+            pAttachmentInitialSampleLocations[i].initialize(&copy_src->pAttachmentInitialSampleLocations[i]);
+        }
     }
-
-    if (copy_src->pPostSubpassSampleLocations) {
-        pPostSubpassSampleLocations = new VkSubpassSampleLocationsEXT[copy_src->postSubpassSampleLocationsCount];
-        memcpy((void*)pPostSubpassSampleLocations, (void*)copy_src->pPostSubpassSampleLocations,
-               sizeof(VkSubpassSampleLocationsEXT) * copy_src->postSubpassSampleLocationsCount);
+    if (postSubpassSampleLocationsCount && copy_src->pPostSubpassSampleLocations) {
+        pPostSubpassSampleLocations = new safe_VkSubpassSampleLocationsEXT[postSubpassSampleLocationsCount];
+        for (uint32_t i = 0; i < postSubpassSampleLocationsCount; ++i) {
+            pPostSubpassSampleLocations[i].initialize(&copy_src->pPostSubpassSampleLocations[i]);
+        }
     }
 }
 

From eb62fb38a538cde41b1180ec182ba923455a49ee Mon Sep 17 00:00:00 2001
From: Spencer Fricke <115671160+spencer-lunarg@users.noreply.github.com>
Date: Thu, 12 Sep 2024 13:53:28 -0700
Subject: [PATCH 048/106] scripts: Better warning for getting reg.py

---
 scripts/generate_source.py | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/scripts/generate_source.py b/scripts/generate_source.py
index 941b021..ee9fc36 100755
--- a/scripts/generate_source.py
+++ b/scripts/generate_source.py
@@ -25,7 +25,13 @@ def RunGenerators(api: str, registry: str, targetFilter: str) -> None:
     scripts_directory_path = os.path.dirname(os.path.abspath(__file__))
     registry_headers_path = os.path.join(scripts_directory_path, scripts)
     sys.path.insert(0, registry_headers_path)
-    from reg import Registry
+    try:
+        from reg import Registry
+    except:
+        print("ModuleNotFoundError: No module named 'reg'") # normal python error message
+        print(f'{registry_headers_path} is not pointing to the Vulkan-Headers registry directory.')
+        print("Inside Vulkan-Headers there is a registry/reg.py file that is used.")
+        sys.exit(1) # Return without call stack so easy to spot error
 
     from generators.base_generator import BaseGeneratorOptions
     from generators.dispatch_table_generator import DispatchTableOutputGenerator

From 6fb0c125afec7b9d724d598f4dca6c61648be35f Mon Sep 17 00:00:00 2001
From: ziga-lunarg <ziga@lunarg.com>
Date: Fri, 20 Sep 2024 23:24:53 +0200
Subject: [PATCH 049/106] tests: Fix windows warnings

---
 tests/safe_struct.cpp       |  21 ++--
 tests/sparse_range_map.cpp  |   8 +-
 tests/struct_helper.cpp     |   6 +-
 tests/test_formats.cpp      | 120 +++++++++++------------
 tests/test_interface.cpp    |   6 +-
 tests/test_setting_api.cpp  |  84 ++++++++--------
 tests/test_setting_cast.cpp |  52 +++++-----
 tests/test_setting_cpp.cpp  |  34 +++----
 tests/test_setting_env.cpp  |  96 +++++++++---------
 tests/test_setting_file.cpp |  80 +++++++--------
 tests/test_setting_util.cpp | 190 ++++++++++++++++++------------------
 11 files changed, 350 insertions(+), 347 deletions(-)

diff --git a/tests/safe_struct.cpp b/tests/safe_struct.cpp
index 4af6640..186bf6e 100644
--- a/tests/safe_struct.cpp
+++ b/tests/safe_struct.cpp
@@ -32,11 +32,12 @@ TEST(safe_struct, basic) {
     }
     ASSERT_EQ(VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, safe_info.sType);
     ASSERT_EQ(0, strcmp("test", safe_info.pApplicationInfo->pApplicationName));
-    ASSERT_EQ(42, safe_info.pApplicationInfo->applicationVersion);
+    ASSERT_EQ(42u, safe_info.pApplicationInfo->applicationVersion);
 
     auto debug_ci = vku::FindStructInPNextChain<VkDebugUtilsMessengerCreateInfoEXT>(safe_info.pNext);
     ASSERT_NE(nullptr, debug_ci);
-    ASSERT_EQ(VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT, debug_ci->messageSeverity);
+    ASSERT_EQ(static_cast<VkDebugUtilsMessageSeverityFlagsEXT>(VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT),
+              debug_ci->messageSeverity);
 }
 
 TEST(safe_struct, safe_void_pointer_copies) {
@@ -111,11 +112,11 @@ TEST(safe_struct, custom_safe_pnext_copy) {
 
         auto safe_pri = reinterpret_cast<const vku::safe_VkPipelineRenderingCreateInfo *>(safe_gpci.pNext);
         // Ensure original input struct was not modified
-        ASSERT_EQ(pri.colorAttachmentCount, 1);
+        ASSERT_EQ(pri.colorAttachmentCount, 1u);
         ASSERT_EQ(pri.pColorAttachmentFormats, &format);
 
         // Ensure safe struct was modified
-        ASSERT_EQ(safe_pri->colorAttachmentCount, 0);
+        ASSERT_EQ(safe_pri->colorAttachmentCount, 0u);
         ASSERT_EQ(safe_pri->pColorAttachmentFormats, nullptr);
     }
 
@@ -129,11 +130,11 @@ TEST(safe_struct, custom_safe_pnext_copy) {
         auto safe_gpl_info = reinterpret_cast<const vku::safe_VkGraphicsPipelineLibraryCreateInfoEXT *>(safe_gpci.pNext);
         auto safe_pri = reinterpret_cast<const vku::safe_VkPipelineRenderingCreateInfo *>(safe_gpl_info->pNext);
         // Ensure original input struct was not modified
-        ASSERT_EQ(pri.colorAttachmentCount, 1);
+        ASSERT_EQ(pri.colorAttachmentCount, 1u);
         ASSERT_EQ(pri.pColorAttachmentFormats, &format);
 
         // Ensure safe struct was modified
-        ASSERT_EQ(safe_pri->colorAttachmentCount, 0);
+        ASSERT_EQ(safe_pri->colorAttachmentCount, 0u);
         ASSERT_EQ(safe_pri->pColorAttachmentFormats, nullptr);
     }
 
@@ -148,11 +149,11 @@ TEST(safe_struct, custom_safe_pnext_copy) {
 
         auto safe_pri = reinterpret_cast<const vku::safe_VkPipelineRenderingCreateInfo *>(safe_gpci.pNext);
         // Ensure original input struct was not modified
-        ASSERT_EQ(pri.colorAttachmentCount, 1);
+        ASSERT_EQ(pri.colorAttachmentCount, 1u);
         ASSERT_EQ(pri.pColorAttachmentFormats, &format);
 
         // Ensure safe struct was modified
-        ASSERT_EQ(safe_pri->colorAttachmentCount, 1);
+        ASSERT_EQ(safe_pri->colorAttachmentCount, 1u);
         ASSERT_EQ(*safe_pri->pColorAttachmentFormats, format);
     }
 }
@@ -167,7 +168,7 @@ TEST(safe_struct, extension_add_remove) {
     ci.enabledExtensionCount = static_cast<uint32_t>(extensions.size());
 
     vku::safe_VkDeviceCreateInfo safe_ci(&ci);
-    ASSERT_EQ(3, vku::FindExtension(safe_ci, "VK_KHR_maintenance4"));
+    ASSERT_EQ(3u, vku::FindExtension(safe_ci, "VK_KHR_maintenance4"));
     ASSERT_EQ(safe_ci.enabledExtensionCount, vku::FindExtension(safe_ci, "VK_KHR_maintenance0"));
 
     ASSERT_EQ(false, vku::RemoveExtension(safe_ci, "VK_KHR_maintenance0"));
@@ -179,7 +180,7 @@ TEST(safe_struct, extension_add_remove) {
     }
     ASSERT_EQ(false, vku::RemoveExtension(safe_ci, "VK_KHR_maintenance0"));
 
-    ASSERT_EQ(0, safe_ci.enabledExtensionCount);
+    ASSERT_EQ(0u, safe_ci.enabledExtensionCount);
     ASSERT_EQ(nullptr, safe_ci.ppEnabledExtensionNames);
 
     for (const auto &ext : extensions) {
diff --git a/tests/sparse_range_map.cpp b/tests/sparse_range_map.cpp
index fec61a9..73186e5 100644
--- a/tests/sparse_range_map.cpp
+++ b/tests/sparse_range_map.cpp
@@ -18,8 +18,8 @@ TEST(sparse_range_map, basic) {
 
     auto iter = map.find(42);
     ASSERT_NE(iter, map.end());
-    ASSERT_EQ(0, iter->first.begin);
-    ASSERT_EQ(100, iter->first.end);
+    ASSERT_EQ(0u, iter->first.begin);
+    ASSERT_EQ(100u, iter->first.end);
     ASSERT_EQ("first", iter->second);
 
     iter = map.find(501);
@@ -34,8 +34,8 @@ TEST(sparse_range_map, small) {
 
     auto iter = map.find(4);
     ASSERT_NE(iter, map.end());
-    ASSERT_EQ(0, iter->first.begin);
-    ASSERT_EQ(10, iter->first.end);
+    ASSERT_EQ(0u, iter->first.begin);
+    ASSERT_EQ(10u, iter->first.end);
     ASSERT_EQ("first", iter->second);
 
     iter = map.find(51);
diff --git a/tests/struct_helper.cpp b/tests/struct_helper.cpp
index 06a11f2..8167b41 100644
--- a/tests/struct_helper.cpp
+++ b/tests/struct_helper.cpp
@@ -27,11 +27,11 @@ TEST(struct_helper, structure_type_matches) {
         nullptr, static_cast<VkBufferCreateFlags>(VK_BUFFER_CREATE_SPARSE_BINDING_BIT), std::numeric_limits<uint64_t>::max(),
         static_cast<VkBufferUsageFlags>(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT), VK_SHARING_MODE_EXCLUSIVE, 0U, nullptr);
     ASSERT_EQ(VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, buffer_create_info.sType);
-    ASSERT_EQ(VK_BUFFER_CREATE_SPARSE_BINDING_BIT, buffer_create_info.flags);
+    ASSERT_EQ(static_cast<VkBufferCreateFlags>(VK_BUFFER_CREATE_SPARSE_BINDING_BIT), buffer_create_info.flags);
     ASSERT_EQ(std::numeric_limits<uint64_t>::max(), buffer_create_info.size);
-    ASSERT_EQ(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, buffer_create_info.usage);
+    ASSERT_EQ(static_cast<VkBufferUsageFlags>(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT), buffer_create_info.usage);
     ASSERT_EQ(VK_SHARING_MODE_EXCLUSIVE, buffer_create_info.sharingMode);
-    ASSERT_EQ(0, buffer_create_info.queueFamilyIndexCount);
+    ASSERT_EQ(0u, buffer_create_info.queueFamilyIndexCount);
     ASSERT_EQ(nullptr, buffer_create_info.pQueueFamilyIndices);
 }
 
diff --git a/tests/test_formats.cpp b/tests/test_formats.cpp
index 8304d89..dd0483c 100644
--- a/tests/test_formats.cpp
+++ b/tests/test_formats.cpp
@@ -259,22 +259,22 @@ TEST(format_utils, vkuFormatIsStencilOnly) {
 TEST(format_utils, vkuFormatDepthSize) {
     for (auto [format, format_str] : magic_enum::enum_entries<VkFormat>()) {
         if (std::string::npos != format_str.find("_D16")) {
-            EXPECT_EQ(vkuFormatDepthSize(format), 16);
+            EXPECT_EQ(vkuFormatDepthSize(format), 16u);
         } else if (std::string::npos != format_str.find("_D24")) {
-            EXPECT_EQ(vkuFormatDepthSize(format), 24);
+            EXPECT_EQ(vkuFormatDepthSize(format), 24u);
         } else if (std::string::npos != format_str.find("_D32")) {
-            EXPECT_EQ(vkuFormatDepthSize(format), 32);
+            EXPECT_EQ(vkuFormatDepthSize(format), 32u);
         } else {
-            EXPECT_EQ(vkuFormatDepthSize(format), 0);
+            EXPECT_EQ(vkuFormatDepthSize(format), 0u);
         }
     }
 }
 TEST(format_utils, vkuFormatStencilSize) {
     for (auto [format, format_str] : magic_enum::enum_entries<VkFormat>()) {
         if (std::string::npos != format_str.find("_S8")) {
-            EXPECT_EQ(vkuFormatStencilSize(format), 8);
+            EXPECT_EQ(vkuFormatStencilSize(format), 8u);
         } else {
-            EXPECT_EQ(vkuFormatStencilSize(format), 0);
+            EXPECT_EQ(vkuFormatStencilSize(format), 0u);
         }
     }
 }
@@ -350,11 +350,11 @@ TEST(format_utils, vkuFormatIsSinglePlane_422) {
 TEST(format_utils, vkuFormatPlaneCount) {
     for (auto [format, format_str] : magic_enum::enum_entries<VkFormat>()) {
         if (std::string::npos != format_str.find("2PLANE")) {
-            EXPECT_EQ(vkuFormatPlaneCount(format), 2);
+            EXPECT_EQ(vkuFormatPlaneCount(format), 2u);
         } else if (std::string::npos != format_str.find("3PLANE")) {
-            EXPECT_EQ(vkuFormatPlaneCount(format), 3);
+            EXPECT_EQ(vkuFormatPlaneCount(format), 3u);
         } else {
-            EXPECT_EQ(vkuFormatPlaneCount(format), 1);
+            EXPECT_EQ(vkuFormatPlaneCount(format), 1u);
         }
     }
 }
@@ -385,31 +385,31 @@ TEST(format_utils, vkuFindMultiplaneCompatibleFormat) {
 TEST(format_utils, vkuFindMultiplaneExtentDivisors) {
     EXPECT_EQ(
         vkuFindMultiplaneExtentDivisors(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, VK_IMAGE_ASPECT_PLANE_0_BIT).width,
-        1);
+        1u);
     EXPECT_EQ(
         vkuFindMultiplaneExtentDivisors(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, VK_IMAGE_ASPECT_PLANE_1_BIT).width,
-        2);
+        2u);
     EXPECT_EQ(
         vkuFindMultiplaneExtentDivisors(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, VK_IMAGE_ASPECT_PLANE_2_BIT).width,
-        2);
+        2u);
 
     EXPECT_EQ(
         vkuFindMultiplaneExtentDivisors(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, VK_IMAGE_ASPECT_PLANE_0_BIT).height,
-        1);
+        1u);
     EXPECT_EQ(
         vkuFindMultiplaneExtentDivisors(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, VK_IMAGE_ASPECT_PLANE_1_BIT).height,
-        2);
+        2u);
     EXPECT_EQ(
         vkuFindMultiplaneExtentDivisors(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, VK_IMAGE_ASPECT_PLANE_2_BIT).height,
-        2);
+        2u);
 
-    EXPECT_EQ(vkuFindMultiplaneExtentDivisors(VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, VK_IMAGE_ASPECT_PLANE_0_BIT).width, 1);
-    EXPECT_EQ(vkuFindMultiplaneExtentDivisors(VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, VK_IMAGE_ASPECT_PLANE_1_BIT).width, 2);
-    EXPECT_EQ(vkuFindMultiplaneExtentDivisors(VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, VK_IMAGE_ASPECT_PLANE_2_BIT).width, 1);
+    EXPECT_EQ(vkuFindMultiplaneExtentDivisors(VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, VK_IMAGE_ASPECT_PLANE_0_BIT).width, 1u);
+    EXPECT_EQ(vkuFindMultiplaneExtentDivisors(VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, VK_IMAGE_ASPECT_PLANE_1_BIT).width, 2u);
+    EXPECT_EQ(vkuFindMultiplaneExtentDivisors(VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, VK_IMAGE_ASPECT_PLANE_2_BIT).width, 1u);
 
-    EXPECT_EQ(vkuFindMultiplaneExtentDivisors(VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, VK_IMAGE_ASPECT_PLANE_0_BIT).height, 1);
-    EXPECT_EQ(vkuFindMultiplaneExtentDivisors(VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, VK_IMAGE_ASPECT_PLANE_1_BIT).height, 1);
-    EXPECT_EQ(vkuFindMultiplaneExtentDivisors(VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, VK_IMAGE_ASPECT_PLANE_2_BIT).height, 1);
+    EXPECT_EQ(vkuFindMultiplaneExtentDivisors(VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, VK_IMAGE_ASPECT_PLANE_0_BIT).height, 1u);
+    EXPECT_EQ(vkuFindMultiplaneExtentDivisors(VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, VK_IMAGE_ASPECT_PLANE_1_BIT).height, 1u);
+    EXPECT_EQ(vkuFindMultiplaneExtentDivisors(VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, VK_IMAGE_ASPECT_PLANE_2_BIT).height, 1u);
 }
 
 TEST(format_utils, vkuFormatComponentCount) {
@@ -430,24 +430,24 @@ TEST(format_utils, vkuFormatTexelBlockExtent) {
     for (auto format : formats) {
         auto extent = vkuFormatTexelBlockExtent(format);
         if (vkuFormatIsCompressed(format)) {
-            EXPECT_GT(extent.width, 1);
-            EXPECT_GT(extent.height, 1);
-            EXPECT_EQ(extent.depth, 1);
+            EXPECT_GT(extent.width, 1u);
+            EXPECT_GT(extent.height, 1u);
+            EXPECT_EQ(extent.depth, 1u);
         } else if (format == VK_FORMAT_UNDEFINED) {
-            EXPECT_EQ(extent.width, 0);
-            EXPECT_EQ(extent.height, 0);
-            EXPECT_EQ(extent.depth, 0);
+            EXPECT_EQ(extent.width, 0u);
+            EXPECT_EQ(extent.height, 0u);
+            EXPECT_EQ(extent.depth, 0u);
             continue;
         } else {
-            EXPECT_EQ(extent.width, 1);
-            EXPECT_EQ(extent.height, 1);
-            EXPECT_EQ(extent.depth, 1);
+            EXPECT_EQ(extent.width, 1u);
+            EXPECT_EQ(extent.height, 1u);
+            EXPECT_EQ(extent.depth, 1u);
         }
     }
     auto extent = vkuFormatTexelBlockExtent(static_cast<VkFormat>(10001));
-    EXPECT_EQ(extent.width, 0);
-    EXPECT_EQ(extent.height, 0);
-    EXPECT_EQ(extent.depth, 0);
+    EXPECT_EQ(extent.width, 0u);
+    EXPECT_EQ(extent.height, 0u);
+    EXPECT_EQ(extent.depth, 0u);
 }
 TEST(format_utils, vkuFormatCompatibilityClass) {
     for (auto [format, format_str] : magic_enum::enum_entries<VkFormat>()) {
@@ -515,30 +515,30 @@ TEST(format_utils, vkuFormatElementIsTexel) {
     }
 }
 TEST(format_utils, vkuFormatElementSizeWithAspect) {
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_R64G64_SFLOAT, VK_IMAGE_ASPECT_NONE), 16);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_R64G64_SFLOAT, VK_IMAGE_ASPECT_STENCIL_BIT), 0);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_R64G64_SFLOAT, VK_IMAGE_ASPECT_DEPTH_BIT), 0);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_NONE), 16);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_PLANE_0_BIT), 16);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_PLANE_1_BIT), 16);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_PLANE_2_BIT), 16);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_STENCIL_BIT), 0);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_DEPTH_BIT), 0);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_NONE), 0);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_PLANE_0_BIT), 2);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_PLANE_1_BIT), 2);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_PLANE_2_BIT), 2);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_STENCIL_BIT), 0);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_DEPTH_BIT), 0);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_D32_SFLOAT, VK_IMAGE_ASPECT_NONE), 4);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_D32_SFLOAT, VK_IMAGE_ASPECT_STENCIL_BIT), 0);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_D32_SFLOAT, VK_IMAGE_ASPECT_DEPTH_BIT), 4);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_D32_SFLOAT_S8_UINT, VK_IMAGE_ASPECT_NONE), 5);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_D32_SFLOAT_S8_UINT, VK_IMAGE_ASPECT_STENCIL_BIT), 1);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_D32_SFLOAT_S8_UINT, VK_IMAGE_ASPECT_DEPTH_BIT), 4);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_S8_UINT, VK_IMAGE_ASPECT_NONE), 1);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_S8_UINT, VK_IMAGE_ASPECT_STENCIL_BIT), 1);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_S8_UINT, VK_IMAGE_ASPECT_DEPTH_BIT), 0);
+    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_R64G64_SFLOAT, VK_IMAGE_ASPECT_NONE), 16u);
+    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_R64G64_SFLOAT, VK_IMAGE_ASPECT_STENCIL_BIT), 0u);
+    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_R64G64_SFLOAT, VK_IMAGE_ASPECT_DEPTH_BIT), 0u);
+    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_NONE), 16u);
+    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_PLANE_0_BIT), 16u);
+    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_PLANE_1_BIT), 16u);
+    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_PLANE_2_BIT), 16u);
+    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_STENCIL_BIT), 0u);
+    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_DEPTH_BIT), 0u);
+    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_NONE), 0u);
+    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_PLANE_0_BIT), 2u);
+    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_PLANE_1_BIT), 2u);
+    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_PLANE_2_BIT), 2u);
+    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_STENCIL_BIT), 0u);
+    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_DEPTH_BIT), 0u);
+    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_D32_SFLOAT, VK_IMAGE_ASPECT_NONE), 4u);
+    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_D32_SFLOAT, VK_IMAGE_ASPECT_STENCIL_BIT), 0u);
+    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_D32_SFLOAT, VK_IMAGE_ASPECT_DEPTH_BIT), 4u);
+    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_D32_SFLOAT_S8_UINT, VK_IMAGE_ASPECT_NONE), 5u);
+    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_D32_SFLOAT_S8_UINT, VK_IMAGE_ASPECT_STENCIL_BIT), 1u);
+    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_D32_SFLOAT_S8_UINT, VK_IMAGE_ASPECT_DEPTH_BIT), 4u);
+    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_S8_UINT, VK_IMAGE_ASPECT_NONE), 1u);
+    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_S8_UINT, VK_IMAGE_ASPECT_STENCIL_BIT), 1u);
+    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_S8_UINT, VK_IMAGE_ASPECT_DEPTH_BIT), 0u);
 }
 TEST(format_utils, vkuFormatTexelSizeWithAspect) {
     EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_R64G64_SFLOAT, VK_IMAGE_ASPECT_NONE), 16);
@@ -649,12 +649,12 @@ struct magic_enum::customize::enum_range<VkImageAspectFlagBits> {
 TEST(format_utils, vkuGetPlaneIndex) {
     for (auto [aspect_flag, aspect_flag_str] : magic_enum::enum_entries<VkImageAspectFlagBits>()) {
         if (std::string::npos != aspect_flag_str.find("_ASPECT_PLANE_0")) {
-            EXPECT_EQ(vkuGetPlaneIndex(aspect_flag), 0);
+            EXPECT_EQ(vkuGetPlaneIndex(aspect_flag), 0u);
         } else if (std::string::npos != aspect_flag_str.find("_ASPECT_PLANE_1")) {
-            EXPECT_EQ(vkuGetPlaneIndex(aspect_flag), 1);
+            EXPECT_EQ(vkuGetPlaneIndex(aspect_flag), 1u);
 
         } else if (std::string::npos != aspect_flag_str.find("_ASPECT_PLANE_2")) {
-            EXPECT_EQ(vkuGetPlaneIndex(aspect_flag), 2);
+            EXPECT_EQ(vkuGetPlaneIndex(aspect_flag), 2u);
         } else {
             EXPECT_EQ(vkuGetPlaneIndex(aspect_flag), VKU_FORMAT_INVALID_INDEX);
         }
diff --git a/tests/test_interface.cpp b/tests/test_interface.cpp
index 5102f8d..0e96725 100644
--- a/tests/test_interface.cpp
+++ b/tests/test_interface.cpp
@@ -44,11 +44,13 @@ TEST(test_vk_dispatch_table, cpp_interface) {
 
     vkuInitInstanceDispatchTable(instance, &instance_dispatch_table, local_vkGetInstanceProcAddr);
 
-    ASSERT_EQ(instance_dispatch_table.GetInstanceProcAddr, local_vkGetInstanceProcAddr);
+    ASSERT_EQ(reinterpret_cast<PFN_vkVoidFunction>(instance_dispatch_table.GetInstanceProcAddr),
+              reinterpret_cast<PFN_vkVoidFunction>(local_vkGetInstanceProcAddr));
 
     VkDevice device{};
 
     vkuInitDeviceDispatchTable(device, &device_dispatch_table, local_vkGetDeviceProcAddr);
 
-    ASSERT_EQ(device_dispatch_table.GetDeviceProcAddr, local_vkGetDeviceProcAddr);
+    ASSERT_EQ(reinterpret_cast<PFN_vkVoidFunction>(device_dispatch_table.GetDeviceProcAddr),
+              reinterpret_cast<PFN_vkVoidFunction>(local_vkGetDeviceProcAddr));
 }
diff --git a/tests/test_setting_api.cpp b/tests/test_setting_api.cpp
index f6c0d96..1515ddb 100644
--- a/tests/test_setting_api.cpp
+++ b/tests/test_setting_api.cpp
@@ -203,25 +203,25 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Bool) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<VkBool32> values(static_cast<uint32_t>(value_count));
 
-    value_count = 1;
+    value_count = 1u;
     VkResult result_incomplete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(VK_TRUE, values[0]);
     EXPECT_EQ(VK_FALSE, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
-    value_count = 2;
+    value_count = 2u;
     VkResult result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(VK_TRUE, values[0]);
     EXPECT_EQ(VK_FALSE, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -244,7 +244,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Int32) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<std::int32_t> values(static_cast<uint32_t>(value_count));
 
@@ -254,7 +254,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Int32) {
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(0, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -262,7 +262,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Int32) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(-82, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -285,7 +285,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Int64) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT64, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<std::int64_t> values(static_cast<uint32_t>(value_count));
 
@@ -295,7 +295,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Int64) {
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(0, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -303,7 +303,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Int64) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(-82, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -326,7 +326,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Uint32) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<std::uint32_t> values(static_cast<uint32_t>(value_count));
 
@@ -334,17 +334,17 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Uint32) {
     VkResult result_incomplete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
-    EXPECT_EQ(76, values[0]);
-    EXPECT_EQ(0, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(76u, values[0]);
+    EXPECT_EQ(0u, values[1]);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(76, values[0]);
-    EXPECT_EQ(82, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(76u, values[0]);
+    EXPECT_EQ(82u, values[1]);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -367,7 +367,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Uint64) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT64, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<std::uint64_t> values(static_cast<uint32_t>(value_count));
 
@@ -377,7 +377,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Uint64) {
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(0, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -385,7 +385,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Uint64) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(82, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -408,7 +408,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Float) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<float> values(static_cast<uint32_t>(value_count));
 
@@ -417,7 +417,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Float) {
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -425,7 +425,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Float) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
     EXPECT_TRUE(std::abs(values[1] - -82.5f) <= 0.0001f);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -448,7 +448,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Double) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<double> values(static_cast<uint32_t>(value_count));
 
@@ -457,7 +457,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Double) {
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -465,7 +465,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Double) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
     EXPECT_TRUE(std::abs(values[1] - -82.5) <= 0.0001);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -490,7 +490,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Frameset) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<VkuFrameset> values(static_cast<uint32_t>(value_count));
 
@@ -498,22 +498,22 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_Frameset) {
     VkResult result_incomplete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
-    EXPECT_EQ(76, values[0].first);
-    EXPECT_EQ(100, values[0].count);
-    EXPECT_EQ(10, values[0].step);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(76u, values[0].first);
+    EXPECT_EQ(100u, values[0].count);
+    EXPECT_EQ(10u, values[0].step);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(76, values[0].first);
-    EXPECT_EQ(100, values[0].count);
-    EXPECT_EQ(10, values[0].step);
-    EXPECT_EQ(1, values[1].first);
-    EXPECT_EQ(100, values[1].count);
-    EXPECT_EQ(1, values[1].step);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(76u, values[0].first);
+    EXPECT_EQ(100u, values[0].count);
+    EXPECT_EQ(10u, values[0].step);
+    EXPECT_EQ(1u, values[1].first);
+    EXPECT_EQ(100u, values[1].count);
+    EXPECT_EQ(1u, values[1].step);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -535,7 +535,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_String) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<const char*> values(static_cast<uint32_t>(value_count));
 
@@ -545,7 +545,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_String) {
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_STREQ("VALUE_A", values[0]);
     EXPECT_STREQ(nullptr, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -553,7 +553,7 @@ TEST(test_layer_setting_api, vkuGetLayerSettingValues_String) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_STREQ("VALUE_A", values[0]);
     EXPECT_STREQ("VALUE_B", values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
diff --git a/tests/test_setting_cast.cpp b/tests/test_setting_cast.cpp
index 160cdfb..c7f1c4f 100644
--- a/tests/test_setting_cast.cpp
+++ b/tests/test_setting_cast.cpp
@@ -32,7 +32,7 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Bool) {
     VkResult result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
     EXPECT_EQ(VK_TRUE, values[0]);
     EXPECT_EQ(VK_FALSE, values[1]);
 
@@ -41,7 +41,7 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Bool) {
     result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
     EXPECT_STREQ("true", string_values[0]);
     EXPECT_STREQ("false", string_values[1]);
 
@@ -70,14 +70,14 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Int32) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(-82, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<const char*> string_values(input_values.size());
 
     result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
     EXPECT_STREQ("76", string_values[0]);
     EXPECT_STREQ("-82", string_values[1]);
 
@@ -106,14 +106,14 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Int64) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(-82, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<const char*> string_values(input_values.size());
 
     result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
     EXPECT_STREQ("76", string_values[0]);
     EXPECT_STREQ("-82", string_values[1]);
 
@@ -140,16 +140,16 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Uint32) {
     VkResult result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(76, values[0]);
-    EXPECT_EQ(82, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(76u, values[0]);
+    EXPECT_EQ(82u, values[1]);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<const char*> string_values(input_values.size());
 
     result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
     EXPECT_STREQ("76", string_values[0]);
     EXPECT_STREQ("82", string_values[1]);
 
@@ -176,7 +176,7 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Uint64) {
     VkResult result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT64, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(82, values[1]);
 
@@ -185,7 +185,7 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Uint64) {
     result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
     EXPECT_STREQ("76", string_values[0]);
     EXPECT_STREQ("82", string_values[1]);
 
@@ -212,7 +212,7 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Float) {
     VkResult result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
     EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
     EXPECT_TRUE(std::abs(values[1] - -82.5f) <= 0.0001f);
 
@@ -221,7 +221,7 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Float) {
     result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
     EXPECT_TRUE(std::strstr(string_values[0], "76.") != nullptr);
     EXPECT_TRUE(std::strstr(string_values[1], "-82.5") != nullptr);
 
@@ -250,14 +250,14 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Double) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
     EXPECT_TRUE(std::abs(values[1] - -82.5) <= 0.0001);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<const char*> string_values(input_values.size());
 
     result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, &string_values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
     EXPECT_TRUE(std::strstr(string_values[0], "76.") != nullptr);
     EXPECT_TRUE(std::strstr(string_values[1], "-82.5") != nullptr);
 
@@ -286,18 +286,18 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Frameset) {
     VkResult result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(76, values[0].first);
-    EXPECT_EQ(100, values[0].count);
-    EXPECT_EQ(10, values[0].step);
-    EXPECT_EQ(1, values[1].first);
-    EXPECT_EQ(100, values[1].count);
-    EXPECT_EQ(1, values[1].step);
-    EXPECT_EQ(6, value_count);
+    EXPECT_EQ(76u, values[0].first);
+    EXPECT_EQ(100u, values[0].count);
+    EXPECT_EQ(10u, values[0].step);
+    EXPECT_EQ(1u, values[1].first);
+    EXPECT_EQ(100u, values[1].count);
+    EXPECT_EQ(1u, values[1].step);
+    EXPECT_EQ(6u, value_count);
 
     value_count = 0;
     result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET_STRING, &value_count, nullptr);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<const char*> string_values(input_values.size());
 
@@ -305,7 +305,7 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_Frameset) {
     result_complete = vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET_STRING, &value_count,
                                                &string_values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
     EXPECT_STREQ("76-100-10", string_values[0]);
     EXPECT_STREQ("1-100-1", string_values[1]);
 
@@ -333,7 +333,7 @@ TEST(test_layer_setting_cast, vkuGetLayerSettingValues_String) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_STREQ("VALUE_A", values[0]);
     EXPECT_STREQ("VALUE_B", values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
diff --git a/tests/test_setting_cpp.cpp b/tests/test_setting_cpp.cpp
index 0416133..9b65c00 100644
--- a/tests/test_setting_cpp.cpp
+++ b/tests/test_setting_cpp.cpp
@@ -122,7 +122,7 @@ TEST(test_layer_setting_cpp, vkuGetLayerSettingValue_Uint32) {
     std::uint32_t pValues;
     vkuGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
 
-    EXPECT_EQ(76, pValues);
+    EXPECT_EQ(76u, pValues);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -146,9 +146,9 @@ TEST(test_layer_setting_cpp, vkuGetLayerSettingValues_Uint32) {
     std::vector<std::uint32_t> values;
     vkuGetLayerSettingValues(layerSettingSet, "my_setting", values);
 
-    EXPECT_EQ(76, values[0]);
-    EXPECT_EQ(82, values[1]);
-    EXPECT_EQ(2, values.size());
+    EXPECT_EQ(76u, values[0]);
+    EXPECT_EQ(82u, values[1]);
+    EXPECT_EQ(2u, values.size());
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -421,9 +421,9 @@ TEST(test_layer_setting_cpp, vkuGetLayerSettingValue_Frameset) {
     VkuFrameset pValues;
     vkuGetLayerSettingValue(layerSettingSet, "my_setting", pValues);
 
-    EXPECT_EQ(76, pValues.first);
-    EXPECT_EQ(100, pValues.count);
-    EXPECT_EQ(10, pValues.step);
+    EXPECT_EQ(76u, pValues.first);
+    EXPECT_EQ(100u, pValues.count);
+    EXPECT_EQ(10u, pValues.step);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -447,12 +447,12 @@ TEST(test_layer_setting_cpp, vkuGetLayerSettingValues_Frameset) {
     std::vector<VkuFrameset> values;
     vkuGetLayerSettingValues(layerSettingSet, "my_setting", values);
 
-    EXPECT_EQ(76, values[0].first);
-    EXPECT_EQ(100, values[0].count);
-    EXPECT_EQ(10, values[0].step);
-    EXPECT_EQ(1, values[1].first);
-    EXPECT_EQ(100, values[1].count);
-    EXPECT_EQ(1, values[1].step);
+    EXPECT_EQ(76u, values[0].first);
+    EXPECT_EQ(100u, values[0].count);
+    EXPECT_EQ(10u, values[0].step);
+    EXPECT_EQ(1u, values[1].first);
+    EXPECT_EQ(100u, values[1].count);
+    EXPECT_EQ(1u, values[1].step);
     EXPECT_EQ(2, values.size());
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
@@ -476,10 +476,10 @@ TEST(test_layer_setting_cpp, vkuGetLayerSettingValues_VkuCustomSTypeInfo) {
 
     std::vector<VkuCustomSTypeInfo> values;
     vkuGetLayerSettingValues(layerSettingSet, "my_setting", values);
-    EXPECT_EQ(0x76, values[0].first);
-    EXPECT_EQ(0x82, values[0].second);
-    EXPECT_EQ(76, values[1].first);
-    EXPECT_EQ(82, values[1].second);
+    EXPECT_EQ(0x76u, values[0].first);
+    EXPECT_EQ(0x82u, values[0].second);
+    EXPECT_EQ(76u, values[1].first);
+    EXPECT_EQ(82u, values[1].second);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
diff --git a/tests/test_setting_env.cpp b/tests/test_setting_env.cpp
index bb00222..d8930c5 100644
--- a/tests/test_setting_env.cpp
+++ b/tests/test_setting_env.cpp
@@ -33,7 +33,7 @@ TEST(test_layer_setting_env, EnvVar_TrimNone) {
     VkResult result_count_a =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting_a", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count_a, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count_a);
-    EXPECT_EQ(2, value_count_a);
+    EXPECT_EQ(2u, value_count_a);
 
     std::vector<VkBool32> values_a(static_cast<std::size_t>(value_count_a));
     VkResult result_complete_a =
@@ -41,7 +41,7 @@ TEST(test_layer_setting_env, EnvVar_TrimNone) {
     EXPECT_EQ(VK_SUCCESS, result_complete_a);
     EXPECT_EQ(VK_TRUE, values_a[0]);
     EXPECT_EQ(VK_FALSE, values_a[1]);
-    EXPECT_EQ(2, value_count_a);
+    EXPECT_EQ(2u, value_count_a);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -58,7 +58,7 @@ TEST(test_layer_setting_env, EnvVar_TrimVendor) {
     VkResult result_count_b =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting_b", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count_b, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count_b);
-    EXPECT_EQ(2, value_count_b);
+    EXPECT_EQ(2u, value_count_b);
 
     std::vector<VkBool32> values_b(static_cast<std::size_t>(value_count_b));
     VkResult result_complete_b =
@@ -66,7 +66,7 @@ TEST(test_layer_setting_env, EnvVar_TrimVendor) {
     EXPECT_EQ(VK_SUCCESS, result_complete_b);
     EXPECT_EQ(VK_TRUE, values_b[0]);
     EXPECT_EQ(VK_FALSE, values_b[1]);
-    EXPECT_EQ(2, value_count_b);
+    EXPECT_EQ(2u, value_count_b);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -83,7 +83,7 @@ TEST(test_layer_setting_env, EnvVar_TrimNamespace) {
     VkResult result_count_c =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting_c", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count_c, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count_c);
-    EXPECT_EQ(2, value_count_c);
+    EXPECT_EQ(2u, value_count_c);
 
     std::vector<VkBool32> values_c(static_cast<std::size_t>(value_count_c));
     VkResult result_complete_c =
@@ -91,7 +91,7 @@ TEST(test_layer_setting_env, EnvVar_TrimNamespace) {
     EXPECT_EQ(VK_SUCCESS, result_complete_c);
     EXPECT_EQ(VK_TRUE, values_c[0]);
     EXPECT_EQ(VK_FALSE, values_c[1]);
-    EXPECT_EQ(2, value_count_c);
+    EXPECT_EQ(2u, value_count_c);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -110,7 +110,7 @@ TEST(test_layer_setting_env, EnvVar_TrimNamespace_OveriddenPrefix) {
     VkResult result_count_c =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting_c", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count_c, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count_c);
-    EXPECT_EQ(2, value_count_c);
+    EXPECT_EQ(2u, value_count_c);
 
     std::vector<VkBool32> values_c(static_cast<std::size_t>(value_count_c));
     VkResult result_complete_c =
@@ -118,7 +118,7 @@ TEST(test_layer_setting_env, EnvVar_TrimNamespace_OveriddenPrefix) {
     EXPECT_EQ(VK_SUCCESS, result_complete_c);
     EXPECT_EQ(VK_TRUE, values_c[0]);
     EXPECT_EQ(VK_FALSE, values_c[1]);
-    EXPECT_EQ(2, value_count_c);
+    EXPECT_EQ(2u, value_count_c);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -135,7 +135,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Bool) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<VkBool32> values(static_cast<uint32_t>(value_count));
 
@@ -145,7 +145,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Bool) {
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(VK_TRUE, values[0]);
     EXPECT_EQ(VK_FALSE, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -153,7 +153,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Bool) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(VK_TRUE, values[0]);
     EXPECT_EQ(VK_FALSE, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -170,7 +170,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Int32) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<std::int32_t> values(static_cast<uint32_t>(value_count));
 
@@ -180,7 +180,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Int32) {
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(0, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -188,7 +188,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Int32) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(-82, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -205,7 +205,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Int64) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT64, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<std::int64_t> values(static_cast<uint32_t>(value_count));
 
@@ -215,7 +215,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Int64) {
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(0, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -223,7 +223,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Int64) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(-82, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -240,7 +240,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Uint32) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<std::uint32_t> values(static_cast<uint32_t>(value_count));
 
@@ -248,17 +248,17 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Uint32) {
     VkResult result_incomplete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
-    EXPECT_EQ(76, values[0]);
-    EXPECT_EQ(0, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(76u, values[0]);
+    EXPECT_EQ(0u, values[1]);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(76, values[0]);
-    EXPECT_EQ(82, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(76u, values[0]);
+    EXPECT_EQ(82u, values[1]);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -275,7 +275,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Uint64) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT64, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<std::uint64_t> values(static_cast<uint32_t>(value_count));
 
@@ -285,7 +285,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Uint64) {
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(0, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -293,7 +293,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Uint64) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(82, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -310,7 +310,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Float) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<float> values(static_cast<uint32_t>(value_count));
 
@@ -319,7 +319,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Float) {
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -327,7 +327,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Float) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
     EXPECT_TRUE(std::abs(values[1] - -82.5f) <= 0.0001f);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -344,7 +344,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Double) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<double> values(static_cast<uint32_t>(value_count));
 
@@ -353,7 +353,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Double) {
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -361,7 +361,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Double) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
     EXPECT_TRUE(std::abs(values[1] - -82.5) <= 0.0001);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -378,7 +378,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Frameset) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<VkuFrameset> values(static_cast<uint32_t>(value_count));
 
@@ -386,22 +386,22 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_Frameset) {
     VkResult result_incomplete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
-    EXPECT_EQ(76, values[0].first);
-    EXPECT_EQ(100, values[0].count);
-    EXPECT_EQ(10, values[0].step);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(76u, values[0].first);
+    EXPECT_EQ(100u, values[0].count);
+    EXPECT_EQ(10u, values[0].step);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(76, values[0].first);
-    EXPECT_EQ(100, values[0].count);
-    EXPECT_EQ(10, values[0].step);
-    EXPECT_EQ(1, values[1].first);
-    EXPECT_EQ(100, values[1].count);
-    EXPECT_EQ(1, values[1].step);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(76u, values[0].first);
+    EXPECT_EQ(100u, values[0].count);
+    EXPECT_EQ(10u, values[0].step);
+    EXPECT_EQ(1u, values[1].first);
+    EXPECT_EQ(100u, values[1].count);
+    EXPECT_EQ(1u, values[1].step);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -418,7 +418,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_String) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<const char*> values(static_cast<uint32_t>(value_count));
 
@@ -428,7 +428,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_String) {
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_STREQ("VALUE_A", values[0]);
     EXPECT_STREQ(nullptr, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -436,7 +436,7 @@ TEST(test_layer_setting_env, vkuGetLayerSettingValues_String) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_STREQ("VALUE_A", values[0]);
     EXPECT_STREQ("VALUE_B", values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 
diff --git a/tests/test_setting_file.cpp b/tests/test_setting_file.cpp
index e6a8c89..4aeb6f3 100644
--- a/tests/test_setting_file.cpp
+++ b/tests/test_setting_file.cpp
@@ -25,7 +25,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Bool) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<VkBool32> values(static_cast<uint32_t>(value_count));
 
@@ -35,7 +35,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Bool) {
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(VK_TRUE, values[0]);
     EXPECT_EQ(VK_FALSE, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -43,7 +43,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Bool) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(VK_TRUE, values[0]);
     EXPECT_EQ(VK_FALSE, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -60,7 +60,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Int32) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<std::int32_t> values(static_cast<uint32_t>(value_count));
 
@@ -70,7 +70,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Int32) {
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(0, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -78,7 +78,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Int32) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(-82, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -95,7 +95,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Int64) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_INT64, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<std::int64_t> values(static_cast<uint32_t>(value_count));
 
@@ -105,7 +105,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Int64) {
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(0, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -113,7 +113,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Int64) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(-82, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -130,7 +130,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Uint32) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<std::uint32_t> values(static_cast<uint32_t>(value_count));
 
@@ -138,17 +138,17 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Uint32) {
     VkResult result_incomplete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
-    EXPECT_EQ(76, values[0]);
-    EXPECT_EQ(0, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(76u, values[0]);
+    EXPECT_EQ(0u, values[1]);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(76, values[0]);
-    EXPECT_EQ(82, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(76u, values[0]);
+    EXPECT_EQ(82u, values[1]);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -165,7 +165,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Uint64) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_UINT64, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<std::uint64_t> values(static_cast<uint32_t>(value_count));
 
@@ -175,7 +175,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Uint64) {
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(0, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -183,7 +183,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Uint64) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_EQ(76, values[0]);
     EXPECT_EQ(82, values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -200,7 +200,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Float) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<float> values(static_cast<uint32_t>(value_count));
 
@@ -209,7 +209,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Float) {
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -217,7 +217,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Float) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_TRUE(std::abs(values[0] - 76.1f) <= 0.0001f);
     EXPECT_TRUE(std::abs(values[1] - -82.5f) <= 0.0001f);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -234,7 +234,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Double) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<double> values(static_cast<uint32_t>(value_count));
 
@@ -243,7 +243,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Double) {
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -251,7 +251,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Double) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_TRUE(std::abs(values[0] - 76.1) <= 0.0001);
     EXPECT_TRUE(std::abs(values[1] - -82.5) <= 0.0001);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -268,7 +268,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Frameset) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<VkuFrameset> values(static_cast<uint32_t>(value_count));
 
@@ -276,22 +276,22 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_Frameset) {
     VkResult result_incomplete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &value_count, &values[0]);
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
-    EXPECT_EQ(76, values[0].first);
-    EXPECT_EQ(100, values[0].count);
-    EXPECT_EQ(10, values[0].step);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(76u, values[0].first);
+    EXPECT_EQ(100u, values[0].count);
+    EXPECT_EQ(10u, values[0].step);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_FRAMESET, &value_count, &values[0]);
     EXPECT_EQ(VK_SUCCESS, result_complete);
-    EXPECT_EQ(76, values[0].first);
-    EXPECT_EQ(100, values[0].count);
-    EXPECT_EQ(10, values[0].step);
-    EXPECT_EQ(1, values[1].first);
-    EXPECT_EQ(100, values[1].count);
-    EXPECT_EQ(1, values[1].step);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(76u, values[0].first);
+    EXPECT_EQ(100u, values[0].count);
+    EXPECT_EQ(10u, values[0].step);
+    EXPECT_EQ(1u, values[1].first);
+    EXPECT_EQ(100u, values[1].count);
+    EXPECT_EQ(1u, values[1].step);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
@@ -308,7 +308,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_String) {
     VkResult result_count =
         vkuGetLayerSettingValues(layerSettingSet, "my_setting", VKU_LAYER_SETTING_TYPE_STRING, &value_count, nullptr);
     EXPECT_EQ(VK_SUCCESS, result_count);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     std::vector<const char *> values(static_cast<uint32_t>(value_count));
 
@@ -318,7 +318,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_String) {
     EXPECT_EQ(VK_INCOMPLETE, result_incomplete);
     EXPECT_STREQ("VALUE_A", values[0]);
     EXPECT_STREQ(nullptr, values[1]);
-    EXPECT_EQ(1, value_count);
+    EXPECT_EQ(1u, value_count);
 
     value_count = 2;
     VkResult result_complete =
@@ -326,7 +326,7 @@ TEST(test_layer_setting_file, vkuGetLayerSettingValues_String) {
     EXPECT_EQ(VK_SUCCESS, result_complete);
     EXPECT_STREQ("VALUE_A", values[0]);
     EXPECT_STREQ("VALUE_B", values[1]);
-    EXPECT_EQ(2, value_count);
+    EXPECT_EQ(2u, value_count);
 
     vkuDestroyLayerSettingSet(layerSettingSet, nullptr);
 }
diff --git a/tests/test_setting_util.cpp b/tests/test_setting_util.cpp
index 394bb0e..0b45713 100644
--- a/tests/test_setting_util.cpp
+++ b/tests/test_setting_util.cpp
@@ -328,19 +328,19 @@ TEST(test_layer_settings_util, is_float) {
 }
 
 TEST(test_layer_settings_util, ToUint32) {
-    EXPECT_EQ(24, vl::ToUint32("24"));
-    EXPECT_EQ(3000300000, vl::ToUint32("3000300000"));
-    EXPECT_EQ(15, vl::ToUint32("0xF"));
-    EXPECT_EQ(15, vl::ToUint32("0XF"));
-    EXPECT_EQ(4294967295, vl::ToUint32("0xFFFFFFFF"));
+    EXPECT_EQ(24u, vl::ToUint32("24"));
+    EXPECT_EQ(3000300000u, vl::ToUint32("3000300000"));
+    EXPECT_EQ(15u, vl::ToUint32("0xF"));
+    EXPECT_EQ(15u, vl::ToUint32("0XF"));
+    EXPECT_EQ(4294967295u, vl::ToUint32("0xFFFFFFFF"));
 }
 
 TEST(test_layer_settings_util, ToUint64) {
-    EXPECT_EQ(24, vl::ToUint64("24"));
-    EXPECT_EQ(3000300000, vl::ToUint64("3000300000"));
-    EXPECT_EQ(15, vl::ToUint64("0xF"));
-    EXPECT_EQ(15, vl::ToUint64("0XF"));
-    EXPECT_EQ(4294967295, vl::ToUint64("0xFFFFFFFF"));
+    EXPECT_EQ(24ull, vl::ToUint64("24"));
+    EXPECT_EQ(3000300000ull, vl::ToUint64("3000300000"));
+    EXPECT_EQ(15ull, vl::ToUint64("0xF"));
+    EXPECT_EQ(15ull, vl::ToUint64("0XF"));
+    EXPECT_EQ(4294967295ull, vl::ToUint64("0xFFFFFFFF"));
     EXPECT_EQ(4294967296ull, vl::ToUint64("0x100000000"));
 }
 
@@ -408,173 +408,173 @@ TEST(test_layer_settings_util, to_framesets) {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("0");
         EXPECT_EQ(1, framesets.size());
 
-        EXPECT_EQ(0, framesets[0].first);
-        EXPECT_EQ(1, framesets[0].count);
-        EXPECT_EQ(1, framesets[0].step);
+        EXPECT_EQ(0u, framesets[0].first);
+        EXPECT_EQ(1u, framesets[0].count);
+        EXPECT_EQ(1u, framesets[0].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("76");
         EXPECT_EQ(1, framesets.size());
 
-        EXPECT_EQ(76, framesets[0].first);
-        EXPECT_EQ(1, framesets[0].count);
-        EXPECT_EQ(1, framesets[0].step);
+        EXPECT_EQ(76u, framesets[0].first);
+        EXPECT_EQ(1u, framesets[0].count);
+        EXPECT_EQ(1u, framesets[0].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("0-2");
         EXPECT_EQ(1, framesets.size());
 
-        EXPECT_EQ(0, framesets[0].first);
-        EXPECT_EQ(2, framesets[0].count);
-        EXPECT_EQ(1, framesets[0].step);
+        EXPECT_EQ(0u, framesets[0].first);
+        EXPECT_EQ(2u, framesets[0].count);
+        EXPECT_EQ(1u, framesets[0].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("0-2,6,7");
         EXPECT_EQ(3, framesets.size());
 
-        EXPECT_EQ(0, framesets[0].first);
-        EXPECT_EQ(2, framesets[0].count);
-        EXPECT_EQ(1, framesets[0].step);
+        EXPECT_EQ(0u, framesets[0].first);
+        EXPECT_EQ(2u, framesets[0].count);
+        EXPECT_EQ(1u, framesets[0].step);
 
-        EXPECT_EQ(6, framesets[1].first);
-        EXPECT_EQ(1, framesets[1].count);
-        EXPECT_EQ(1, framesets[1].step);
+        EXPECT_EQ(6u, framesets[1].first);
+        EXPECT_EQ(1u, framesets[1].count);
+        EXPECT_EQ(1u, framesets[1].step);
 
-        EXPECT_EQ(7, framesets[2].first);
-        EXPECT_EQ(1, framesets[2].count);
-        EXPECT_EQ(1, framesets[2].step);
+        EXPECT_EQ(7u, framesets[2].first);
+        EXPECT_EQ(1u, framesets[2].count);
+        EXPECT_EQ(1u, framesets[2].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("0-2,6-7");
         EXPECT_EQ(2, framesets.size());
 
-        EXPECT_EQ(0, framesets[0].first);
-        EXPECT_EQ(2, framesets[0].count);
-        EXPECT_EQ(1, framesets[0].step);
+        EXPECT_EQ(0u, framesets[0].first);
+        EXPECT_EQ(2u, framesets[0].count);
+        EXPECT_EQ(1u, framesets[0].step);
 
-        EXPECT_EQ(6, framesets[1].first);
-        EXPECT_EQ(7, framesets[1].count);
-        EXPECT_EQ(1, framesets[1].step);
+        EXPECT_EQ(6u, framesets[1].first);
+        EXPECT_EQ(7u, framesets[1].count);
+        EXPECT_EQ(1u, framesets[1].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("1-2,60,70");
         EXPECT_EQ(3, framesets.size());
 
-        EXPECT_EQ(1, framesets[0].first);
-        EXPECT_EQ(2, framesets[0].count);
-        EXPECT_EQ(1, framesets[0].step);
+        EXPECT_EQ(1u, framesets[0].first);
+        EXPECT_EQ(2u, framesets[0].count);
+        EXPECT_EQ(1u, framesets[0].step);
 
-        EXPECT_EQ(60, framesets[1].first);
-        EXPECT_EQ(1, framesets[1].count);
-        EXPECT_EQ(1, framesets[1].step);
+        EXPECT_EQ(60u, framesets[1].first);
+        EXPECT_EQ(1u, framesets[1].count);
+        EXPECT_EQ(1u, framesets[1].step);
 
-        EXPECT_EQ(70, framesets[2].first);
-        EXPECT_EQ(1, framesets[2].count);
-        EXPECT_EQ(1, framesets[2].step);
+        EXPECT_EQ(70u, framesets[2].first);
+        EXPECT_EQ(1u, framesets[2].count);
+        EXPECT_EQ(1u, framesets[2].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("10-20,60,70");
         EXPECT_EQ(3, framesets.size());
 
-        EXPECT_EQ(10, framesets[0].first);
-        EXPECT_EQ(20, framesets[0].count);
-        EXPECT_EQ(1, framesets[0].step);
+        EXPECT_EQ(10u, framesets[0].first);
+        EXPECT_EQ(20u, framesets[0].count);
+        EXPECT_EQ(1u, framesets[0].step);
 
-        EXPECT_EQ(60, framesets[1].first);
-        EXPECT_EQ(1, framesets[1].count);
-        EXPECT_EQ(1, framesets[1].step);
+        EXPECT_EQ(60u, framesets[1].first);
+        EXPECT_EQ(1u, framesets[1].count);
+        EXPECT_EQ(1u, framesets[1].step);
 
-        EXPECT_EQ(70, framesets[2].first);
-        EXPECT_EQ(1, framesets[2].count);
-        EXPECT_EQ(1, framesets[2].step);
+        EXPECT_EQ(70u, framesets[2].first);
+        EXPECT_EQ(1u, framesets[2].count);
+        EXPECT_EQ(1u, framesets[2].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("1-8-2");
         EXPECT_EQ(1, framesets.size());
 
-        EXPECT_EQ(1, framesets[0].first);
-        EXPECT_EQ(8, framesets[0].count);
-        EXPECT_EQ(2, framesets[0].step);
+        EXPECT_EQ(1u, framesets[0].first);
+        EXPECT_EQ(8u, framesets[0].count);
+        EXPECT_EQ(2u, framesets[0].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("1-8-2,0");
         EXPECT_EQ(2, framesets.size());
 
-        EXPECT_EQ(1, framesets[0].first);
-        EXPECT_EQ(8, framesets[0].count);
-        EXPECT_EQ(2, framesets[0].step);
+        EXPECT_EQ(1u, framesets[0].first);
+        EXPECT_EQ(8u, framesets[0].count);
+        EXPECT_EQ(2u, framesets[0].step);
 
-        EXPECT_EQ(0, framesets[1].first);
-        EXPECT_EQ(1, framesets[1].count);
-        EXPECT_EQ(1, framesets[1].step);
+        EXPECT_EQ(0u, framesets[1].first);
+        EXPECT_EQ(1u, framesets[1].count);
+        EXPECT_EQ(1u, framesets[1].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("1-8-2,10-20-5");
         EXPECT_EQ(2, framesets.size());
 
-        EXPECT_EQ(1, framesets[0].first);
-        EXPECT_EQ(8, framesets[0].count);
-        EXPECT_EQ(2, framesets[0].step);
+        EXPECT_EQ(1u, framesets[0].first);
+        EXPECT_EQ(8u, framesets[0].count);
+        EXPECT_EQ(2u, framesets[0].step);
 
-        EXPECT_EQ(10, framesets[1].first);
-        EXPECT_EQ(20, framesets[1].count);
-        EXPECT_EQ(5, framesets[1].step);
+        EXPECT_EQ(10u, framesets[1].first);
+        EXPECT_EQ(20u, framesets[1].count);
+        EXPECT_EQ(5u, framesets[1].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("1-8,10-20-5");
         EXPECT_EQ(2, framesets.size());
 
-        EXPECT_EQ(1, framesets[0].first);
-        EXPECT_EQ(8, framesets[0].count);
-        EXPECT_EQ(1, framesets[0].step);
+        EXPECT_EQ(1u, framesets[0].first);
+        EXPECT_EQ(8u, framesets[0].count);
+        EXPECT_EQ(1u, framesets[0].step);
 
-        EXPECT_EQ(10, framesets[1].first);
-        EXPECT_EQ(20, framesets[1].count);
-        EXPECT_EQ(5, framesets[1].step);
+        EXPECT_EQ(10u, framesets[1].first);
+        EXPECT_EQ(20u, framesets[1].count);
+        EXPECT_EQ(5u, framesets[1].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("1-8-2,10-20-1");
         EXPECT_EQ(2, framesets.size());
 
-        EXPECT_EQ(1, framesets[0].first);
-        EXPECT_EQ(8, framesets[0].count);
-        EXPECT_EQ(2, framesets[0].step);
+        EXPECT_EQ(1u, framesets[0].first);
+        EXPECT_EQ(8u, framesets[0].count);
+        EXPECT_EQ(2u, framesets[0].step);
 
-        EXPECT_EQ(10, framesets[1].first);
-        EXPECT_EQ(20, framesets[1].count);
-        EXPECT_EQ(1, framesets[1].step);
+        EXPECT_EQ(10u, framesets[1].first);
+        EXPECT_EQ(20u, framesets[1].count);
+        EXPECT_EQ(1u, framesets[1].step);
     }
 
     {
         std::vector<VkuFrameset> framesets = vl::ToFrameSets("1,2,3,4");
         EXPECT_EQ(4, framesets.size());
 
-        EXPECT_EQ(1, framesets[0].first);
-        EXPECT_EQ(1, framesets[0].count);
-        EXPECT_EQ(1, framesets[0].step);
+        EXPECT_EQ(1u, framesets[0].first);
+        EXPECT_EQ(1u, framesets[0].count);
+        EXPECT_EQ(1u, framesets[0].step);
 
-        EXPECT_EQ(2, framesets[1].first);
-        EXPECT_EQ(1, framesets[1].count);
-        EXPECT_EQ(1, framesets[1].step);
+        EXPECT_EQ(2u, framesets[1].first);
+        EXPECT_EQ(1u, framesets[1].count);
+        EXPECT_EQ(1u, framesets[1].step);
 
-        EXPECT_EQ(3, framesets[2].first);
-        EXPECT_EQ(1, framesets[2].count);
-        EXPECT_EQ(1, framesets[2].step);
+        EXPECT_EQ(3u, framesets[2].first);
+        EXPECT_EQ(1u, framesets[2].count);
+        EXPECT_EQ(1u, framesets[2].step);
 
-        EXPECT_EQ(4, framesets[3].first);
-        EXPECT_EQ(1, framesets[3].count);
-        EXPECT_EQ(1, framesets[3].step);
+        EXPECT_EQ(4u, framesets[3].first);
+        EXPECT_EQ(1u, framesets[3].count);
+        EXPECT_EQ(1u, framesets[3].step);
     }
 }
 
@@ -664,13 +664,13 @@ TEST(test_layer_settings_util, vkuGetUnknownSettings_SingleCreateInfo) {
 
     uint32_t unknown_settings_count = 0;
     vkuGetUnknownSettings(&create_info, setting_name_count, setting_names, &unknown_settings_count, nullptr);
-    EXPECT_EQ(2, unknown_settings_count);
+    EXPECT_EQ(2u, unknown_settings_count);
 
     std::vector<const char*> unknown_settings(unknown_settings_count);
 
     unknown_settings_count = 1;
     vkuGetUnknownSettings(&create_info, setting_name_count, setting_names, &unknown_settings_count, &unknown_settings[0]);
-    EXPECT_EQ(1, unknown_settings_count);
+    EXPECT_EQ(1u, unknown_settings_count);
     EXPECT_STREQ("bool_value", unknown_settings[0]);
 
     unknown_settings_count = 2;
@@ -777,13 +777,13 @@ TEST(test_layer_settings_util, vlGetUnknownSettings_MultipleCreateInfo) {
 
     uint32_t unknown_settings_count = 0;
     vkuGetUnknownSettings(&create_infoA, setting_name_count, setting_names, &unknown_settings_count, nullptr);
-    EXPECT_EQ(2, unknown_settings_count);
+    EXPECT_EQ(2u, unknown_settings_count);
 
     std::vector<const char*> unknown_settings(unknown_settings_count);
 
     unknown_settings_count = 1;
     vkuGetUnknownSettings(&create_infoA, setting_name_count, setting_names, &unknown_settings_count, &unknown_settings[0]);
-    EXPECT_EQ(1, unknown_settings_count);
+    EXPECT_EQ(1u, unknown_settings_count);
     EXPECT_STREQ("bool_value", unknown_settings[0]);
 
     unknown_settings_count = 2;

From a71907b8577c994b1c69adfa7315d55bbe79656e Mon Sep 17 00:00:00 2001
From: spencer-lunarg <spencer@lunarg.com>
Date: Thu, 26 Sep 2024 08:05:48 -0400
Subject: [PATCH 050/106] build: Update to header 1.3.296

---
 include/vulkan/utility/vk_dispatch_table.h  |   20 +
 include/vulkan/utility/vk_safe_struct.hpp   |  340 +++++
 include/vulkan/utility/vk_struct_helper.hpp |   18 +
 include/vulkan/vk_enum_string_helper.h      |  152 +++
 scripts/generators/safe_struct_generator.py |    4 +-
 scripts/known_good.json                     |    2 +-
 src/vulkan/vk_safe_struct_ext.cpp           | 1268 +++++++++++++++++++
 src/vulkan/vk_safe_struct_utils.cpp         |   36 +
 8 files changed, 1837 insertions(+), 3 deletions(-)

diff --git a/include/vulkan/utility/vk_dispatch_table.h b/include/vulkan/utility/vk_dispatch_table.h
index 75d7b01..443591e 100644
--- a/include/vulkan/utility/vk_dispatch_table.h
+++ b/include/vulkan/utility/vk_dispatch_table.h
@@ -726,6 +726,7 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkDestroyShaderEXT DestroyShaderEXT;
     PFN_vkGetShaderBinaryDataEXT GetShaderBinaryDataEXT;
     PFN_vkCmdBindShadersEXT CmdBindShadersEXT;
+    PFN_vkCmdSetDepthClampRangeEXT CmdSetDepthClampRangeEXT;
     PFN_vkGetFramebufferTilePropertiesQCOM GetFramebufferTilePropertiesQCOM;
     PFN_vkGetDynamicRenderingTilePropertiesQCOM GetDynamicRenderingTilePropertiesQCOM;
     PFN_vkSetLatencySleepModeNV SetLatencySleepModeNV;
@@ -737,6 +738,15 @@ typedef struct VkuDeviceDispatchTable_ {
 #ifdef VK_USE_PLATFORM_SCREEN_QNX
     PFN_vkGetScreenBufferPropertiesQNX GetScreenBufferPropertiesQNX;
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
+    PFN_vkGetGeneratedCommandsMemoryRequirementsEXT GetGeneratedCommandsMemoryRequirementsEXT;
+    PFN_vkCmdPreprocessGeneratedCommandsEXT CmdPreprocessGeneratedCommandsEXT;
+    PFN_vkCmdExecuteGeneratedCommandsEXT CmdExecuteGeneratedCommandsEXT;
+    PFN_vkCreateIndirectCommandsLayoutEXT CreateIndirectCommandsLayoutEXT;
+    PFN_vkDestroyIndirectCommandsLayoutEXT DestroyIndirectCommandsLayoutEXT;
+    PFN_vkCreateIndirectExecutionSetEXT CreateIndirectExecutionSetEXT;
+    PFN_vkDestroyIndirectExecutionSetEXT DestroyIndirectExecutionSetEXT;
+    PFN_vkUpdateIndirectExecutionSetPipelineEXT UpdateIndirectExecutionSetPipelineEXT;
+    PFN_vkUpdateIndirectExecutionSetShaderEXT UpdateIndirectExecutionSetShaderEXT;
     PFN_vkCreateAccelerationStructureKHR CreateAccelerationStructureKHR;
     PFN_vkDestroyAccelerationStructureKHR DestroyAccelerationStructureKHR;
     PFN_vkCmdBuildAccelerationStructuresKHR CmdBuildAccelerationStructuresKHR;
@@ -1328,6 +1338,7 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
     table->DestroyShaderEXT = (PFN_vkDestroyShaderEXT)gdpa(device, "vkDestroyShaderEXT");
     table->GetShaderBinaryDataEXT = (PFN_vkGetShaderBinaryDataEXT)gdpa(device, "vkGetShaderBinaryDataEXT");
     table->CmdBindShadersEXT = (PFN_vkCmdBindShadersEXT)gdpa(device, "vkCmdBindShadersEXT");
+    table->CmdSetDepthClampRangeEXT = (PFN_vkCmdSetDepthClampRangeEXT)gdpa(device, "vkCmdSetDepthClampRangeEXT");
     table->GetFramebufferTilePropertiesQCOM = (PFN_vkGetFramebufferTilePropertiesQCOM)gdpa(device, "vkGetFramebufferTilePropertiesQCOM");
     table->GetDynamicRenderingTilePropertiesQCOM = (PFN_vkGetDynamicRenderingTilePropertiesQCOM)gdpa(device, "vkGetDynamicRenderingTilePropertiesQCOM");
     table->SetLatencySleepModeNV = (PFN_vkSetLatencySleepModeNV)gdpa(device, "vkSetLatencySleepModeNV");
@@ -1339,6 +1350,15 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
 #ifdef VK_USE_PLATFORM_SCREEN_QNX
     table->GetScreenBufferPropertiesQNX = (PFN_vkGetScreenBufferPropertiesQNX)gdpa(device, "vkGetScreenBufferPropertiesQNX");
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
+    table->GetGeneratedCommandsMemoryRequirementsEXT = (PFN_vkGetGeneratedCommandsMemoryRequirementsEXT)gdpa(device, "vkGetGeneratedCommandsMemoryRequirementsEXT");
+    table->CmdPreprocessGeneratedCommandsEXT = (PFN_vkCmdPreprocessGeneratedCommandsEXT)gdpa(device, "vkCmdPreprocessGeneratedCommandsEXT");
+    table->CmdExecuteGeneratedCommandsEXT = (PFN_vkCmdExecuteGeneratedCommandsEXT)gdpa(device, "vkCmdExecuteGeneratedCommandsEXT");
+    table->CreateIndirectCommandsLayoutEXT = (PFN_vkCreateIndirectCommandsLayoutEXT)gdpa(device, "vkCreateIndirectCommandsLayoutEXT");
+    table->DestroyIndirectCommandsLayoutEXT = (PFN_vkDestroyIndirectCommandsLayoutEXT)gdpa(device, "vkDestroyIndirectCommandsLayoutEXT");
+    table->CreateIndirectExecutionSetEXT = (PFN_vkCreateIndirectExecutionSetEXT)gdpa(device, "vkCreateIndirectExecutionSetEXT");
+    table->DestroyIndirectExecutionSetEXT = (PFN_vkDestroyIndirectExecutionSetEXT)gdpa(device, "vkDestroyIndirectExecutionSetEXT");
+    table->UpdateIndirectExecutionSetPipelineEXT = (PFN_vkUpdateIndirectExecutionSetPipelineEXT)gdpa(device, "vkUpdateIndirectExecutionSetPipelineEXT");
+    table->UpdateIndirectExecutionSetShaderEXT = (PFN_vkUpdateIndirectExecutionSetShaderEXT)gdpa(device, "vkUpdateIndirectExecutionSetShaderEXT");
     table->CreateAccelerationStructureKHR = (PFN_vkCreateAccelerationStructureKHR)gdpa(device, "vkCreateAccelerationStructureKHR");
     table->DestroyAccelerationStructureKHR = (PFN_vkDestroyAccelerationStructureKHR)gdpa(device, "vkDestroyAccelerationStructureKHR");
     table->CmdBuildAccelerationStructuresKHR = (PFN_vkCmdBuildAccelerationStructuresKHR)gdpa(device, "vkCmdBuildAccelerationStructuresKHR");
diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index 487c50d..ea78bab 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -18404,6 +18404,304 @@ struct safe_VkPhysicalDeviceRayTracingValidationFeaturesNV {
         return reinterpret_cast<VkPhysicalDeviceRayTracingValidationFeaturesNV const*>(this);
     }
 };
+struct safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 deviceGeneratedCommands;
+    VkBool32 dynamicGeneratedPipelineLayout;
+
+    safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* in_struct,
+                                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(
+        const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT();
+    ~safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT();
+    void initialize(const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxIndirectPipelineCount;
+    uint32_t maxIndirectShaderObjectCount;
+    uint32_t maxIndirectSequenceCount;
+    uint32_t maxIndirectCommandsTokenCount;
+    uint32_t maxIndirectCommandsTokenOffset;
+    uint32_t maxIndirectCommandsIndirectStride;
+    VkIndirectCommandsInputModeFlagsEXT supportedIndirectCommandsInputModes;
+    VkShaderStageFlags supportedIndirectCommandsShaderStages;
+    VkShaderStageFlags supportedIndirectCommandsShaderStagesPipelineBinding;
+    VkShaderStageFlags supportedIndirectCommandsShaderStagesShaderBinding;
+    VkBool32 deviceGeneratedCommandsTransformFeedback;
+    VkBool32 deviceGeneratedCommandsMultiDrawIndirectCount;
+
+    safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT(const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT* in_struct,
+                                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT(
+        const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT& operator=(
+        const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT();
+    ~safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT();
+    void initialize(const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT*>(this);
+    }
+    VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT const*>(this);
+    }
+};
+struct safe_VkGeneratedCommandsMemoryRequirementsInfoEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkIndirectExecutionSetEXT indirectExecutionSet;
+    VkIndirectCommandsLayoutEXT indirectCommandsLayout;
+    uint32_t maxSequenceCount;
+    uint32_t maxDrawCount;
+
+    safe_VkGeneratedCommandsMemoryRequirementsInfoEXT(const VkGeneratedCommandsMemoryRequirementsInfoEXT* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkGeneratedCommandsMemoryRequirementsInfoEXT(const safe_VkGeneratedCommandsMemoryRequirementsInfoEXT& copy_src);
+    safe_VkGeneratedCommandsMemoryRequirementsInfoEXT& operator=(const safe_VkGeneratedCommandsMemoryRequirementsInfoEXT& copy_src);
+    safe_VkGeneratedCommandsMemoryRequirementsInfoEXT();
+    ~safe_VkGeneratedCommandsMemoryRequirementsInfoEXT();
+    void initialize(const VkGeneratedCommandsMemoryRequirementsInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkGeneratedCommandsMemoryRequirementsInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkGeneratedCommandsMemoryRequirementsInfoEXT* ptr() {
+        return reinterpret_cast<VkGeneratedCommandsMemoryRequirementsInfoEXT*>(this);
+    }
+    VkGeneratedCommandsMemoryRequirementsInfoEXT const* ptr() const {
+        return reinterpret_cast<VkGeneratedCommandsMemoryRequirementsInfoEXT const*>(this);
+    }
+};
+struct safe_VkIndirectExecutionSetPipelineInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipeline initialPipeline;
+    uint32_t maxPipelineCount;
+
+    safe_VkIndirectExecutionSetPipelineInfoEXT(const VkIndirectExecutionSetPipelineInfoEXT* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkIndirectExecutionSetPipelineInfoEXT(const safe_VkIndirectExecutionSetPipelineInfoEXT& copy_src);
+    safe_VkIndirectExecutionSetPipelineInfoEXT& operator=(const safe_VkIndirectExecutionSetPipelineInfoEXT& copy_src);
+    safe_VkIndirectExecutionSetPipelineInfoEXT();
+    ~safe_VkIndirectExecutionSetPipelineInfoEXT();
+    void initialize(const VkIndirectExecutionSetPipelineInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkIndirectExecutionSetPipelineInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkIndirectExecutionSetPipelineInfoEXT* ptr() { return reinterpret_cast<VkIndirectExecutionSetPipelineInfoEXT*>(this); }
+    VkIndirectExecutionSetPipelineInfoEXT const* ptr() const {
+        return reinterpret_cast<VkIndirectExecutionSetPipelineInfoEXT const*>(this);
+    }
+};
+struct safe_VkIndirectExecutionSetShaderLayoutInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t setLayoutCount;
+    VkDescriptorSetLayout* pSetLayouts{};
+
+    safe_VkIndirectExecutionSetShaderLayoutInfoEXT(const VkIndirectExecutionSetShaderLayoutInfoEXT* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkIndirectExecutionSetShaderLayoutInfoEXT(const safe_VkIndirectExecutionSetShaderLayoutInfoEXT& copy_src);
+    safe_VkIndirectExecutionSetShaderLayoutInfoEXT& operator=(const safe_VkIndirectExecutionSetShaderLayoutInfoEXT& copy_src);
+    safe_VkIndirectExecutionSetShaderLayoutInfoEXT();
+    ~safe_VkIndirectExecutionSetShaderLayoutInfoEXT();
+    void initialize(const VkIndirectExecutionSetShaderLayoutInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkIndirectExecutionSetShaderLayoutInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkIndirectExecutionSetShaderLayoutInfoEXT* ptr() { return reinterpret_cast<VkIndirectExecutionSetShaderLayoutInfoEXT*>(this); }
+    VkIndirectExecutionSetShaderLayoutInfoEXT const* ptr() const {
+        return reinterpret_cast<VkIndirectExecutionSetShaderLayoutInfoEXT const*>(this);
+    }
+};
+struct safe_VkIndirectExecutionSetShaderInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t shaderCount;
+    VkShaderEXT* pInitialShaders{};
+    safe_VkIndirectExecutionSetShaderLayoutInfoEXT* pSetLayoutInfos{};
+    uint32_t maxShaderCount;
+    uint32_t pushConstantRangeCount;
+    const VkPushConstantRange* pPushConstantRanges{};
+
+    safe_VkIndirectExecutionSetShaderInfoEXT(const VkIndirectExecutionSetShaderInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkIndirectExecutionSetShaderInfoEXT(const safe_VkIndirectExecutionSetShaderInfoEXT& copy_src);
+    safe_VkIndirectExecutionSetShaderInfoEXT& operator=(const safe_VkIndirectExecutionSetShaderInfoEXT& copy_src);
+    safe_VkIndirectExecutionSetShaderInfoEXT();
+    ~safe_VkIndirectExecutionSetShaderInfoEXT();
+    void initialize(const VkIndirectExecutionSetShaderInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkIndirectExecutionSetShaderInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkIndirectExecutionSetShaderInfoEXT* ptr() { return reinterpret_cast<VkIndirectExecutionSetShaderInfoEXT*>(this); }
+    VkIndirectExecutionSetShaderInfoEXT const* ptr() const {
+        return reinterpret_cast<VkIndirectExecutionSetShaderInfoEXT const*>(this);
+    }
+};
+struct safe_VkIndirectExecutionSetCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkIndirectExecutionSetInfoTypeEXT type;
+    VkIndirectExecutionSetInfoEXT info;
+
+    safe_VkIndirectExecutionSetCreateInfoEXT(const VkIndirectExecutionSetCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkIndirectExecutionSetCreateInfoEXT(const safe_VkIndirectExecutionSetCreateInfoEXT& copy_src);
+    safe_VkIndirectExecutionSetCreateInfoEXT& operator=(const safe_VkIndirectExecutionSetCreateInfoEXT& copy_src);
+    safe_VkIndirectExecutionSetCreateInfoEXT();
+    ~safe_VkIndirectExecutionSetCreateInfoEXT();
+    void initialize(const VkIndirectExecutionSetCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkIndirectExecutionSetCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkIndirectExecutionSetCreateInfoEXT* ptr() { return reinterpret_cast<VkIndirectExecutionSetCreateInfoEXT*>(this); }
+    VkIndirectExecutionSetCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkIndirectExecutionSetCreateInfoEXT const*>(this);
+    }
+};
+struct safe_VkGeneratedCommandsInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkShaderStageFlags shaderStages;
+    VkIndirectExecutionSetEXT indirectExecutionSet;
+    VkIndirectCommandsLayoutEXT indirectCommandsLayout;
+    VkDeviceAddress indirectAddress;
+    VkDeviceSize indirectAddressSize;
+    VkDeviceAddress preprocessAddress;
+    VkDeviceSize preprocessSize;
+    uint32_t maxSequenceCount;
+    VkDeviceAddress sequenceCountAddress;
+    uint32_t maxDrawCount;
+
+    safe_VkGeneratedCommandsInfoEXT(const VkGeneratedCommandsInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                    bool copy_pnext = true);
+    safe_VkGeneratedCommandsInfoEXT(const safe_VkGeneratedCommandsInfoEXT& copy_src);
+    safe_VkGeneratedCommandsInfoEXT& operator=(const safe_VkGeneratedCommandsInfoEXT& copy_src);
+    safe_VkGeneratedCommandsInfoEXT();
+    ~safe_VkGeneratedCommandsInfoEXT();
+    void initialize(const VkGeneratedCommandsInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkGeneratedCommandsInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkGeneratedCommandsInfoEXT* ptr() { return reinterpret_cast<VkGeneratedCommandsInfoEXT*>(this); }
+    VkGeneratedCommandsInfoEXT const* ptr() const { return reinterpret_cast<VkGeneratedCommandsInfoEXT const*>(this); }
+};
+struct safe_VkWriteIndirectExecutionSetPipelineEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t index;
+    VkPipeline pipeline;
+
+    safe_VkWriteIndirectExecutionSetPipelineEXT(const VkWriteIndirectExecutionSetPipelineEXT* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkWriteIndirectExecutionSetPipelineEXT(const safe_VkWriteIndirectExecutionSetPipelineEXT& copy_src);
+    safe_VkWriteIndirectExecutionSetPipelineEXT& operator=(const safe_VkWriteIndirectExecutionSetPipelineEXT& copy_src);
+    safe_VkWriteIndirectExecutionSetPipelineEXT();
+    ~safe_VkWriteIndirectExecutionSetPipelineEXT();
+    void initialize(const VkWriteIndirectExecutionSetPipelineEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkWriteIndirectExecutionSetPipelineEXT* copy_src, PNextCopyState* copy_state = {});
+    VkWriteIndirectExecutionSetPipelineEXT* ptr() { return reinterpret_cast<VkWriteIndirectExecutionSetPipelineEXT*>(this); }
+    VkWriteIndirectExecutionSetPipelineEXT const* ptr() const {
+        return reinterpret_cast<VkWriteIndirectExecutionSetPipelineEXT const*>(this);
+    }
+};
+struct safe_VkIndirectCommandsLayoutTokenEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkIndirectCommandsTokenTypeEXT type;
+    VkIndirectCommandsTokenDataEXT data;
+    uint32_t offset;
+
+    safe_VkIndirectCommandsLayoutTokenEXT(const VkIndirectCommandsLayoutTokenEXT* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkIndirectCommandsLayoutTokenEXT(const safe_VkIndirectCommandsLayoutTokenEXT& copy_src);
+    safe_VkIndirectCommandsLayoutTokenEXT& operator=(const safe_VkIndirectCommandsLayoutTokenEXT& copy_src);
+    safe_VkIndirectCommandsLayoutTokenEXT();
+    ~safe_VkIndirectCommandsLayoutTokenEXT();
+    void initialize(const VkIndirectCommandsLayoutTokenEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkIndirectCommandsLayoutTokenEXT* copy_src, PNextCopyState* copy_state = {});
+    VkIndirectCommandsLayoutTokenEXT* ptr() { return reinterpret_cast<VkIndirectCommandsLayoutTokenEXT*>(this); }
+    VkIndirectCommandsLayoutTokenEXT const* ptr() const { return reinterpret_cast<VkIndirectCommandsLayoutTokenEXT const*>(this); }
+};
+struct safe_VkIndirectCommandsLayoutCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkIndirectCommandsLayoutUsageFlagsEXT flags;
+    VkShaderStageFlags shaderStages;
+    uint32_t indirectStride;
+    VkPipelineLayout pipelineLayout;
+    uint32_t tokenCount;
+    safe_VkIndirectCommandsLayoutTokenEXT* pTokens{};
+
+    safe_VkIndirectCommandsLayoutCreateInfoEXT(const VkIndirectCommandsLayoutCreateInfoEXT* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkIndirectCommandsLayoutCreateInfoEXT(const safe_VkIndirectCommandsLayoutCreateInfoEXT& copy_src);
+    safe_VkIndirectCommandsLayoutCreateInfoEXT& operator=(const safe_VkIndirectCommandsLayoutCreateInfoEXT& copy_src);
+    safe_VkIndirectCommandsLayoutCreateInfoEXT();
+    ~safe_VkIndirectCommandsLayoutCreateInfoEXT();
+    void initialize(const VkIndirectCommandsLayoutCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkIndirectCommandsLayoutCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkIndirectCommandsLayoutCreateInfoEXT* ptr() { return reinterpret_cast<VkIndirectCommandsLayoutCreateInfoEXT*>(this); }
+    VkIndirectCommandsLayoutCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkIndirectCommandsLayoutCreateInfoEXT const*>(this);
+    }
+};
+struct safe_VkGeneratedCommandsPipelineInfoEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkPipeline pipeline;
+
+    safe_VkGeneratedCommandsPipelineInfoEXT(const VkGeneratedCommandsPipelineInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                            bool copy_pnext = true);
+    safe_VkGeneratedCommandsPipelineInfoEXT(const safe_VkGeneratedCommandsPipelineInfoEXT& copy_src);
+    safe_VkGeneratedCommandsPipelineInfoEXT& operator=(const safe_VkGeneratedCommandsPipelineInfoEXT& copy_src);
+    safe_VkGeneratedCommandsPipelineInfoEXT();
+    ~safe_VkGeneratedCommandsPipelineInfoEXT();
+    void initialize(const VkGeneratedCommandsPipelineInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkGeneratedCommandsPipelineInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkGeneratedCommandsPipelineInfoEXT* ptr() { return reinterpret_cast<VkGeneratedCommandsPipelineInfoEXT*>(this); }
+    VkGeneratedCommandsPipelineInfoEXT const* ptr() const {
+        return reinterpret_cast<VkGeneratedCommandsPipelineInfoEXT const*>(this);
+    }
+};
+struct safe_VkGeneratedCommandsShaderInfoEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t shaderCount;
+    VkShaderEXT* pShaders{};
+
+    safe_VkGeneratedCommandsShaderInfoEXT(const VkGeneratedCommandsShaderInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkGeneratedCommandsShaderInfoEXT(const safe_VkGeneratedCommandsShaderInfoEXT& copy_src);
+    safe_VkGeneratedCommandsShaderInfoEXT& operator=(const safe_VkGeneratedCommandsShaderInfoEXT& copy_src);
+    safe_VkGeneratedCommandsShaderInfoEXT();
+    ~safe_VkGeneratedCommandsShaderInfoEXT();
+    void initialize(const VkGeneratedCommandsShaderInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkGeneratedCommandsShaderInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkGeneratedCommandsShaderInfoEXT* ptr() { return reinterpret_cast<VkGeneratedCommandsShaderInfoEXT*>(this); }
+    VkGeneratedCommandsShaderInfoEXT const* ptr() const { return reinterpret_cast<VkGeneratedCommandsShaderInfoEXT const*>(this); }
+};
+struct safe_VkWriteIndirectExecutionSetShaderEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t index;
+    VkShaderEXT shader;
+
+    safe_VkWriteIndirectExecutionSetShaderEXT(const VkWriteIndirectExecutionSetShaderEXT* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkWriteIndirectExecutionSetShaderEXT(const safe_VkWriteIndirectExecutionSetShaderEXT& copy_src);
+    safe_VkWriteIndirectExecutionSetShaderEXT& operator=(const safe_VkWriteIndirectExecutionSetShaderEXT& copy_src);
+    safe_VkWriteIndirectExecutionSetShaderEXT();
+    ~safe_VkWriteIndirectExecutionSetShaderEXT();
+    void initialize(const VkWriteIndirectExecutionSetShaderEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkWriteIndirectExecutionSetShaderEXT* copy_src, PNextCopyState* copy_state = {});
+    VkWriteIndirectExecutionSetShaderEXT* ptr() { return reinterpret_cast<VkWriteIndirectExecutionSetShaderEXT*>(this); }
+    VkWriteIndirectExecutionSetShaderEXT const* ptr() const {
+        return reinterpret_cast<VkWriteIndirectExecutionSetShaderEXT const*>(this);
+    }
+};
 struct safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA {
     VkStructureType sType;
     void* pNext{};
@@ -18465,6 +18763,48 @@ struct safe_VkImageAlignmentControlCreateInfoMESA {
         return reinterpret_cast<VkImageAlignmentControlCreateInfoMESA const*>(this);
     }
 };
+struct safe_VkPhysicalDeviceDepthClampControlFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 depthClampControl;
+
+    safe_VkPhysicalDeviceDepthClampControlFeaturesEXT(const VkPhysicalDeviceDepthClampControlFeaturesEXT* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceDepthClampControlFeaturesEXT(const safe_VkPhysicalDeviceDepthClampControlFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceDepthClampControlFeaturesEXT& operator=(const safe_VkPhysicalDeviceDepthClampControlFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceDepthClampControlFeaturesEXT();
+    ~safe_VkPhysicalDeviceDepthClampControlFeaturesEXT();
+    void initialize(const VkPhysicalDeviceDepthClampControlFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDepthClampControlFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDepthClampControlFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDepthClampControlFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceDepthClampControlFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDepthClampControlFeaturesEXT const*>(this);
+    }
+};
+struct safe_VkPipelineViewportDepthClampControlCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDepthClampModeEXT depthClampMode;
+    const VkDepthClampRangeEXT* pDepthClampRange{};
+
+    safe_VkPipelineViewportDepthClampControlCreateInfoEXT(const VkPipelineViewportDepthClampControlCreateInfoEXT* in_struct,
+                                                          PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineViewportDepthClampControlCreateInfoEXT(const safe_VkPipelineViewportDepthClampControlCreateInfoEXT& copy_src);
+    safe_VkPipelineViewportDepthClampControlCreateInfoEXT& operator=(
+        const safe_VkPipelineViewportDepthClampControlCreateInfoEXT& copy_src);
+    safe_VkPipelineViewportDepthClampControlCreateInfoEXT();
+    ~safe_VkPipelineViewportDepthClampControlCreateInfoEXT();
+    void initialize(const VkPipelineViewportDepthClampControlCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineViewportDepthClampControlCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineViewportDepthClampControlCreateInfoEXT* ptr() {
+        return reinterpret_cast<VkPipelineViewportDepthClampControlCreateInfoEXT*>(this);
+    }
+    VkPipelineViewportDepthClampControlCreateInfoEXT const* ptr() const {
+        return reinterpret_cast<VkPipelineViewportDepthClampControlCreateInfoEXT const*>(this);
+    }
+};
 struct safe_VkAccelerationStructureGeometryTrianglesDataKHR {
     VkStructureType sType;
     const void* pNext{};
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index 1523516..c6395f7 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -965,9 +965,25 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceCommandBufferInherit
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingValidationFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT; }
+template <> inline VkStructureType GetSType<VkGeneratedCommandsMemoryRequirementsInfoEXT>() { return VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT; }
+template <> inline VkStructureType GetSType<VkIndirectExecutionSetPipelineInfoEXT>() { return VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT; }
+template <> inline VkStructureType GetSType<VkIndirectExecutionSetShaderLayoutInfoEXT>() { return VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT; }
+template <> inline VkStructureType GetSType<VkIndirectExecutionSetShaderInfoEXT>() { return VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT; }
+template <> inline VkStructureType GetSType<VkIndirectExecutionSetCreateInfoEXT>() { return VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT; }
+template <> inline VkStructureType GetSType<VkGeneratedCommandsInfoEXT>() { return VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT; }
+template <> inline VkStructureType GetSType<VkWriteIndirectExecutionSetPipelineEXT>() { return VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT; }
+template <> inline VkStructureType GetSType<VkIndirectCommandsLayoutTokenEXT>() { return VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT; }
+template <> inline VkStructureType GetSType<VkIndirectCommandsLayoutCreateInfoEXT>() { return VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT; }
+template <> inline VkStructureType GetSType<VkGeneratedCommandsPipelineInfoEXT>() { return VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT; }
+template <> inline VkStructureType GetSType<VkGeneratedCommandsShaderInfoEXT>() { return VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT; }
+template <> inline VkStructureType GetSType<VkWriteIndirectExecutionSetShaderEXT>() { return VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceImageAlignmentControlFeaturesMESA>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceImageAlignmentControlPropertiesMESA>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA; }
 template <> inline VkStructureType GetSType<VkImageAlignmentControlCreateInfoMESA>() { return VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceDepthClampControlFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT; }
+template <> inline VkStructureType GetSType<VkPipelineViewportDepthClampControlCreateInfoEXT>() { return VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryTrianglesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryAabbsDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryInstancesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR; }
@@ -1117,6 +1133,8 @@ template<> inline VkObjectType GetObjectType<VkBufferCollectionFUCHSIA>() { retu
 template<> inline VkObjectType GetObjectType<VkMicromapEXT>() { return VK_OBJECT_TYPE_MICROMAP_EXT; }
 template<> inline VkObjectType GetObjectType<VkOpticalFlowSessionNV>() { return VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV; }
 template<> inline VkObjectType GetObjectType<VkShaderEXT>() { return VK_OBJECT_TYPE_SHADER_EXT; }
+template<> inline VkObjectType GetObjectType<VkIndirectExecutionSetEXT>() { return VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT; }
+template<> inline VkObjectType GetObjectType<VkIndirectCommandsLayoutEXT>() { return VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT; }
 
 # else // 32 bit
 template<typename T> VkObjectType GetObjectType() {
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index ff68ccb..6cd51f6 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -1962,12 +1962,44 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT";
+        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT:
+            return "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT";
+        case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT:
+            return "VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT";
+        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT:
+            return "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT";
+        case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT:
+            return "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT";
+        case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT:
+            return "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT";
+        case VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT:
+            return "VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT";
+        case VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT:
+            return "VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT";
+        case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT:
+            return "VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT";
+        case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT:
+            return "VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT";
+        case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT:
+            return "VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT";
+        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT:
+            return "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT";
+        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT:
+            return "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA";
         case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA:
             return "VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT";
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT:
+            return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT";
         default:
             return "Unhandled VkStructureType";
     }
@@ -2150,6 +2182,10 @@ static inline const char* string_VkObjectType(VkObjectType input_value) {
             return "VK_OBJECT_TYPE_SHADER_EXT";
         case VK_OBJECT_TYPE_PIPELINE_BINARY_KHR:
             return "VK_OBJECT_TYPE_PIPELINE_BINARY_KHR";
+        case VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT:
+            return "VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT";
+        case VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT:
+            return "VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT";
         default:
             return "Unhandled VkObjectType";
     }
@@ -3156,6 +3192,8 @@ static inline const char* string_VkDynamicState(VkDynamicState input_value) {
             return "VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT";
         case VK_DYNAMIC_STATE_LINE_STIPPLE_KHR:
             return "VK_DYNAMIC_STATE_LINE_STIPPLE_KHR";
+        case VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT:
+            return "VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT";
         default:
             return "Unhandled VkDynamicState";
     }
@@ -4750,6 +4788,16 @@ static inline const char* string_VkShaderCodeTypeEXT(VkShaderCodeTypeEXT input_v
             return "Unhandled VkShaderCodeTypeEXT";
     }
 }
+static inline const char* string_VkDepthClampModeEXT(VkDepthClampModeEXT input_value) {
+    switch (input_value) {
+        case VK_DEPTH_CLAMP_MODE_VIEWPORT_RANGE_EXT:
+            return "VK_DEPTH_CLAMP_MODE_VIEWPORT_RANGE_EXT";
+        case VK_DEPTH_CLAMP_MODE_USER_DEFINED_RANGE_EXT:
+            return "VK_DEPTH_CLAMP_MODE_USER_DEFINED_RANGE_EXT";
+        default:
+            return "Unhandled VkDepthClampModeEXT";
+    }
+}
 static inline const char* string_VkRayTracingInvocationReorderModeNV(VkRayTracingInvocationReorderModeNV input_value) {
     switch (input_value) {
         case VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_NV:
@@ -4856,6 +4904,52 @@ static inline const char* string_VkLayeredDriverUnderlyingApiMSFT(VkLayeredDrive
             return "Unhandled VkLayeredDriverUnderlyingApiMSFT";
     }
 }
+static inline const char* string_VkIndirectExecutionSetInfoTypeEXT(VkIndirectExecutionSetInfoTypeEXT input_value) {
+    switch (input_value) {
+        case VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT:
+            return "VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT";
+        case VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT:
+            return "VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT";
+        default:
+            return "Unhandled VkIndirectExecutionSetInfoTypeEXT";
+    }
+}
+static inline const char* string_VkIndirectCommandsTokenTypeEXT(VkIndirectCommandsTokenTypeEXT input_value) {
+    switch (input_value) {
+        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT:
+            return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT";
+        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT:
+            return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT";
+        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT:
+            return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT";
+        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT:
+            return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT";
+        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT:
+            return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT";
+        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_EXT:
+            return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_EXT";
+        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_EXT:
+            return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_EXT";
+        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_COUNT_EXT:
+            return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_COUNT_EXT";
+        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_COUNT_EXT:
+            return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_COUNT_EXT";
+        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_EXT:
+            return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_EXT";
+        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT:
+            return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT";
+        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT:
+            return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT";
+        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT:
+            return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT";
+        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_EXT:
+            return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_EXT";
+        case VK_INDIRECT_COMMANDS_TOKEN_TYPE_TRACE_RAYS2_EXT:
+            return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_TRACE_RAYS2_EXT";
+        default:
+            return "Unhandled VkIndirectCommandsTokenTypeEXT";
+    }
+}
 static inline const char* string_VkBuildAccelerationStructureModeKHR(VkBuildAccelerationStructureModeKHR input_value) {
     switch (input_value) {
         case VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR:
@@ -8361,6 +8455,7 @@ static inline const char* string_VkPipelineCreateFlagBits2KHR(uint64_t input_val
     if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV) return "VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV";
     if (input_value == VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT) return "VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT";
     if (input_value == VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR) return "VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR";
+    if (input_value == VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT) return "VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT";
     return "Unhandled VkPipelineCreateFlagBits2KHR";
 }
 
@@ -8407,6 +8502,7 @@ static inline const char* string_VkBufferUsageFlagBits2KHR(uint64_t input_value)
     if (input_value == VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT";
     if (input_value == VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT) return "VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT";
     if (input_value == VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT) return "VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT";
+    if (input_value == VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT";
     return "Unhandled VkBufferUsageFlagBits2KHR";
 }
 
@@ -9403,6 +9499,8 @@ static inline const char* string_VkShaderCreateFlagBitsEXT(VkShaderCreateFlagBit
             return "VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT";
         case VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT:
             return "VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT";
+        case VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT:
+            return "VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT";
         default:
             return "Unhandled VkShaderCreateFlagBitsEXT";
     }
@@ -9424,6 +9522,60 @@ static inline std::string string_VkShaderCreateFlagsEXT(VkShaderCreateFlagsEXT i
     return ret;
 }
 #endif // __cplusplus
+static inline const char* string_VkIndirectCommandsInputModeFlagBitsEXT(VkIndirectCommandsInputModeFlagBitsEXT input_value) {
+    switch (input_value) {
+        case VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT:
+            return "VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT";
+        case VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT:
+            return "VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT";
+        default:
+            return "Unhandled VkIndirectCommandsInputModeFlagBitsEXT";
+    }
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkIndirectCommandsInputModeFlagsEXT(VkIndirectCommandsInputModeFlagsEXT input_value) {
+    std::string ret;
+    int index = 0;
+    while(input_value) {
+        if (input_value & 1) {
+            if( !ret.empty()) ret.append("|");
+            ret.append(string_VkIndirectCommandsInputModeFlagBitsEXT(static_cast<VkIndirectCommandsInputModeFlagBitsEXT>(1U << index)));
+        }
+        ++index;
+        input_value >>= 1;
+    }
+    if (ret.empty()) ret.append("VkIndirectCommandsInputModeFlagsEXT(0)");
+    return ret;
+}
+#endif // __cplusplus
+static inline const char* string_VkIndirectCommandsLayoutUsageFlagBitsEXT(VkIndirectCommandsLayoutUsageFlagBitsEXT input_value) {
+    switch (input_value) {
+        case VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_EXT:
+            return "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_EXT";
+        case VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_EXT:
+            return "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_EXT";
+        default:
+            return "Unhandled VkIndirectCommandsLayoutUsageFlagBitsEXT";
+    }
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkIndirectCommandsLayoutUsageFlagsEXT(VkIndirectCommandsLayoutUsageFlagsEXT input_value) {
+    std::string ret;
+    int index = 0;
+    while(input_value) {
+        if (input_value & 1) {
+            if( !ret.empty()) ret.append("|");
+            ret.append(string_VkIndirectCommandsLayoutUsageFlagBitsEXT(static_cast<VkIndirectCommandsLayoutUsageFlagBitsEXT>(1U << index)));
+        }
+        ++index;
+        input_value >>= 1;
+    }
+    if (ret.empty()) ret.append("VkIndirectCommandsLayoutUsageFlagsEXT(0)");
+    return ret;
+}
+#endif // __cplusplus
 static inline const char* string_VkAccelerationStructureCreateFlagBitsKHR(VkAccelerationStructureCreateFlagBitsKHR input_value) {
     switch (input_value) {
         case VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR:
diff --git a/scripts/generators/safe_struct_generator.py b/scripts/generators/safe_struct_generator.py
index f5b071f..e7d8086 100644
--- a/scripts/generators/safe_struct_generator.py
+++ b/scripts/generators/safe_struct_generator.py
@@ -41,8 +41,6 @@ class SafeStructOutputGenerator(BaseGenerator):
             'VkMicromapBuildInfoEXT',
             'VkAccelerationStructureTrianglesOpacityMicromapEXT',
             'VkAccelerationStructureTrianglesDisplacementMicromapNV',
-            # The VkDescriptorType field needs to handle every type which is something best done manually
-            'VkDescriptorDataEXT',
              # Special case because its pointers may be non-null but ignored
             'VkGraphicsPipelineCreateInfo',
             # Special case because it has custom construct parameters
@@ -61,6 +59,8 @@ class SafeStructOutputGenerator(BaseGenerator):
         # These 'data' union are decided by the 'type' in the same parent struct
         self.union_of_pointers = [
             'VkDescriptorDataEXT',
+            'VkIndirectCommandsTokenDataEXT',
+            'VkIndirectExecutionSetInfoEXT',
         ]
         self.union_of_pointer_callers = [
             'VkDescriptorGetInfoEXT',
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 73d7ede..4cf8298 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.3.295"
+            "commit": "v1.3.296"
         },
         {
             "name": "googletest",
diff --git a/src/vulkan/vk_safe_struct_ext.cpp b/src/vulkan/vk_safe_struct_ext.cpp
index 739ad53..7d78ba0 100644
--- a/src/vulkan/vk_safe_struct_ext.cpp
+++ b/src/vulkan/vk_safe_struct_ext.cpp
@@ -15326,6 +15326,1274 @@ void safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT::initialize(
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT::safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(
+    const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      deviceGeneratedCommands(in_struct->deviceGeneratedCommands),
+      dynamicGeneratedPipelineLayout(in_struct->dynamicGeneratedPipelineLayout) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT::safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT),
+      pNext(nullptr),
+      deviceGeneratedCommands(),
+      dynamicGeneratedPipelineLayout() {}
+
+safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT::safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(
+    const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    deviceGeneratedCommands = copy_src.deviceGeneratedCommands;
+    dynamicGeneratedPipelineLayout = copy_src.dynamicGeneratedPipelineLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT& safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    deviceGeneratedCommands = copy_src.deviceGeneratedCommands;
+    dynamicGeneratedPipelineLayout = copy_src.dynamicGeneratedPipelineLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT::~safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT::initialize(
+    const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    deviceGeneratedCommands = in_struct->deviceGeneratedCommands;
+    dynamicGeneratedPipelineLayout = in_struct->dynamicGeneratedPipelineLayout;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    deviceGeneratedCommands = copy_src->deviceGeneratedCommands;
+    dynamicGeneratedPipelineLayout = copy_src->dynamicGeneratedPipelineLayout;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT::safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT(
+    const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      maxIndirectPipelineCount(in_struct->maxIndirectPipelineCount),
+      maxIndirectShaderObjectCount(in_struct->maxIndirectShaderObjectCount),
+      maxIndirectSequenceCount(in_struct->maxIndirectSequenceCount),
+      maxIndirectCommandsTokenCount(in_struct->maxIndirectCommandsTokenCount),
+      maxIndirectCommandsTokenOffset(in_struct->maxIndirectCommandsTokenOffset),
+      maxIndirectCommandsIndirectStride(in_struct->maxIndirectCommandsIndirectStride),
+      supportedIndirectCommandsInputModes(in_struct->supportedIndirectCommandsInputModes),
+      supportedIndirectCommandsShaderStages(in_struct->supportedIndirectCommandsShaderStages),
+      supportedIndirectCommandsShaderStagesPipelineBinding(in_struct->supportedIndirectCommandsShaderStagesPipelineBinding),
+      supportedIndirectCommandsShaderStagesShaderBinding(in_struct->supportedIndirectCommandsShaderStagesShaderBinding),
+      deviceGeneratedCommandsTransformFeedback(in_struct->deviceGeneratedCommandsTransformFeedback),
+      deviceGeneratedCommandsMultiDrawIndirectCount(in_struct->deviceGeneratedCommandsMultiDrawIndirectCount) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT::safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT),
+      pNext(nullptr),
+      maxIndirectPipelineCount(),
+      maxIndirectShaderObjectCount(),
+      maxIndirectSequenceCount(),
+      maxIndirectCommandsTokenCount(),
+      maxIndirectCommandsTokenOffset(),
+      maxIndirectCommandsIndirectStride(),
+      supportedIndirectCommandsInputModes(),
+      supportedIndirectCommandsShaderStages(),
+      supportedIndirectCommandsShaderStagesPipelineBinding(),
+      supportedIndirectCommandsShaderStagesShaderBinding(),
+      deviceGeneratedCommandsTransformFeedback(),
+      deviceGeneratedCommandsMultiDrawIndirectCount() {}
+
+safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT::safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT(
+    const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    maxIndirectPipelineCount = copy_src.maxIndirectPipelineCount;
+    maxIndirectShaderObjectCount = copy_src.maxIndirectShaderObjectCount;
+    maxIndirectSequenceCount = copy_src.maxIndirectSequenceCount;
+    maxIndirectCommandsTokenCount = copy_src.maxIndirectCommandsTokenCount;
+    maxIndirectCommandsTokenOffset = copy_src.maxIndirectCommandsTokenOffset;
+    maxIndirectCommandsIndirectStride = copy_src.maxIndirectCommandsIndirectStride;
+    supportedIndirectCommandsInputModes = copy_src.supportedIndirectCommandsInputModes;
+    supportedIndirectCommandsShaderStages = copy_src.supportedIndirectCommandsShaderStages;
+    supportedIndirectCommandsShaderStagesPipelineBinding = copy_src.supportedIndirectCommandsShaderStagesPipelineBinding;
+    supportedIndirectCommandsShaderStagesShaderBinding = copy_src.supportedIndirectCommandsShaderStagesShaderBinding;
+    deviceGeneratedCommandsTransformFeedback = copy_src.deviceGeneratedCommandsTransformFeedback;
+    deviceGeneratedCommandsMultiDrawIndirectCount = copy_src.deviceGeneratedCommandsMultiDrawIndirectCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT& safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT::operator=(
+    const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxIndirectPipelineCount = copy_src.maxIndirectPipelineCount;
+    maxIndirectShaderObjectCount = copy_src.maxIndirectShaderObjectCount;
+    maxIndirectSequenceCount = copy_src.maxIndirectSequenceCount;
+    maxIndirectCommandsTokenCount = copy_src.maxIndirectCommandsTokenCount;
+    maxIndirectCommandsTokenOffset = copy_src.maxIndirectCommandsTokenOffset;
+    maxIndirectCommandsIndirectStride = copy_src.maxIndirectCommandsIndirectStride;
+    supportedIndirectCommandsInputModes = copy_src.supportedIndirectCommandsInputModes;
+    supportedIndirectCommandsShaderStages = copy_src.supportedIndirectCommandsShaderStages;
+    supportedIndirectCommandsShaderStagesPipelineBinding = copy_src.supportedIndirectCommandsShaderStagesPipelineBinding;
+    supportedIndirectCommandsShaderStagesShaderBinding = copy_src.supportedIndirectCommandsShaderStagesShaderBinding;
+    deviceGeneratedCommandsTransformFeedback = copy_src.deviceGeneratedCommandsTransformFeedback;
+    deviceGeneratedCommandsMultiDrawIndirectCount = copy_src.deviceGeneratedCommandsMultiDrawIndirectCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT::~safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT::initialize(
+    const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxIndirectPipelineCount = in_struct->maxIndirectPipelineCount;
+    maxIndirectShaderObjectCount = in_struct->maxIndirectShaderObjectCount;
+    maxIndirectSequenceCount = in_struct->maxIndirectSequenceCount;
+    maxIndirectCommandsTokenCount = in_struct->maxIndirectCommandsTokenCount;
+    maxIndirectCommandsTokenOffset = in_struct->maxIndirectCommandsTokenOffset;
+    maxIndirectCommandsIndirectStride = in_struct->maxIndirectCommandsIndirectStride;
+    supportedIndirectCommandsInputModes = in_struct->supportedIndirectCommandsInputModes;
+    supportedIndirectCommandsShaderStages = in_struct->supportedIndirectCommandsShaderStages;
+    supportedIndirectCommandsShaderStagesPipelineBinding = in_struct->supportedIndirectCommandsShaderStagesPipelineBinding;
+    supportedIndirectCommandsShaderStagesShaderBinding = in_struct->supportedIndirectCommandsShaderStagesShaderBinding;
+    deviceGeneratedCommandsTransformFeedback = in_struct->deviceGeneratedCommandsTransformFeedback;
+    deviceGeneratedCommandsMultiDrawIndirectCount = in_struct->deviceGeneratedCommandsMultiDrawIndirectCount;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT::initialize(
+    const safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxIndirectPipelineCount = copy_src->maxIndirectPipelineCount;
+    maxIndirectShaderObjectCount = copy_src->maxIndirectShaderObjectCount;
+    maxIndirectSequenceCount = copy_src->maxIndirectSequenceCount;
+    maxIndirectCommandsTokenCount = copy_src->maxIndirectCommandsTokenCount;
+    maxIndirectCommandsTokenOffset = copy_src->maxIndirectCommandsTokenOffset;
+    maxIndirectCommandsIndirectStride = copy_src->maxIndirectCommandsIndirectStride;
+    supportedIndirectCommandsInputModes = copy_src->supportedIndirectCommandsInputModes;
+    supportedIndirectCommandsShaderStages = copy_src->supportedIndirectCommandsShaderStages;
+    supportedIndirectCommandsShaderStagesPipelineBinding = copy_src->supportedIndirectCommandsShaderStagesPipelineBinding;
+    supportedIndirectCommandsShaderStagesShaderBinding = copy_src->supportedIndirectCommandsShaderStagesShaderBinding;
+    deviceGeneratedCommandsTransformFeedback = copy_src->deviceGeneratedCommandsTransformFeedback;
+    deviceGeneratedCommandsMultiDrawIndirectCount = copy_src->deviceGeneratedCommandsMultiDrawIndirectCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkGeneratedCommandsMemoryRequirementsInfoEXT::safe_VkGeneratedCommandsMemoryRequirementsInfoEXT(
+    const VkGeneratedCommandsMemoryRequirementsInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      indirectExecutionSet(in_struct->indirectExecutionSet),
+      indirectCommandsLayout(in_struct->indirectCommandsLayout),
+      maxSequenceCount(in_struct->maxSequenceCount),
+      maxDrawCount(in_struct->maxDrawCount) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkGeneratedCommandsMemoryRequirementsInfoEXT::safe_VkGeneratedCommandsMemoryRequirementsInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT),
+      pNext(nullptr),
+      indirectExecutionSet(),
+      indirectCommandsLayout(),
+      maxSequenceCount(),
+      maxDrawCount() {}
+
+safe_VkGeneratedCommandsMemoryRequirementsInfoEXT::safe_VkGeneratedCommandsMemoryRequirementsInfoEXT(
+    const safe_VkGeneratedCommandsMemoryRequirementsInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    indirectExecutionSet = copy_src.indirectExecutionSet;
+    indirectCommandsLayout = copy_src.indirectCommandsLayout;
+    maxSequenceCount = copy_src.maxSequenceCount;
+    maxDrawCount = copy_src.maxDrawCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkGeneratedCommandsMemoryRequirementsInfoEXT& safe_VkGeneratedCommandsMemoryRequirementsInfoEXT::operator=(
+    const safe_VkGeneratedCommandsMemoryRequirementsInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    indirectExecutionSet = copy_src.indirectExecutionSet;
+    indirectCommandsLayout = copy_src.indirectCommandsLayout;
+    maxSequenceCount = copy_src.maxSequenceCount;
+    maxDrawCount = copy_src.maxDrawCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkGeneratedCommandsMemoryRequirementsInfoEXT::~safe_VkGeneratedCommandsMemoryRequirementsInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkGeneratedCommandsMemoryRequirementsInfoEXT::initialize(const VkGeneratedCommandsMemoryRequirementsInfoEXT* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    indirectExecutionSet = in_struct->indirectExecutionSet;
+    indirectCommandsLayout = in_struct->indirectCommandsLayout;
+    maxSequenceCount = in_struct->maxSequenceCount;
+    maxDrawCount = in_struct->maxDrawCount;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkGeneratedCommandsMemoryRequirementsInfoEXT::initialize(
+    const safe_VkGeneratedCommandsMemoryRequirementsInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    indirectExecutionSet = copy_src->indirectExecutionSet;
+    indirectCommandsLayout = copy_src->indirectCommandsLayout;
+    maxSequenceCount = copy_src->maxSequenceCount;
+    maxDrawCount = copy_src->maxDrawCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkIndirectExecutionSetPipelineInfoEXT::safe_VkIndirectExecutionSetPipelineInfoEXT(
+    const VkIndirectExecutionSetPipelineInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), initialPipeline(in_struct->initialPipeline), maxPipelineCount(in_struct->maxPipelineCount) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkIndirectExecutionSetPipelineInfoEXT::safe_VkIndirectExecutionSetPipelineInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT), pNext(nullptr), initialPipeline(), maxPipelineCount() {}
+
+safe_VkIndirectExecutionSetPipelineInfoEXT::safe_VkIndirectExecutionSetPipelineInfoEXT(
+    const safe_VkIndirectExecutionSetPipelineInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    initialPipeline = copy_src.initialPipeline;
+    maxPipelineCount = copy_src.maxPipelineCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkIndirectExecutionSetPipelineInfoEXT& safe_VkIndirectExecutionSetPipelineInfoEXT::operator=(
+    const safe_VkIndirectExecutionSetPipelineInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    initialPipeline = copy_src.initialPipeline;
+    maxPipelineCount = copy_src.maxPipelineCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkIndirectExecutionSetPipelineInfoEXT::~safe_VkIndirectExecutionSetPipelineInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkIndirectExecutionSetPipelineInfoEXT::initialize(const VkIndirectExecutionSetPipelineInfoEXT* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    initialPipeline = in_struct->initialPipeline;
+    maxPipelineCount = in_struct->maxPipelineCount;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkIndirectExecutionSetPipelineInfoEXT::initialize(const safe_VkIndirectExecutionSetPipelineInfoEXT* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    initialPipeline = copy_src->initialPipeline;
+    maxPipelineCount = copy_src->maxPipelineCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkIndirectExecutionSetShaderLayoutInfoEXT::safe_VkIndirectExecutionSetShaderLayoutInfoEXT(
+    const VkIndirectExecutionSetShaderLayoutInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), setLayoutCount(in_struct->setLayoutCount), pSetLayouts(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (setLayoutCount && in_struct->pSetLayouts) {
+        pSetLayouts = new VkDescriptorSetLayout[setLayoutCount];
+        for (uint32_t i = 0; i < setLayoutCount; ++i) {
+            pSetLayouts[i] = in_struct->pSetLayouts[i];
+        }
+    }
+}
+
+safe_VkIndirectExecutionSetShaderLayoutInfoEXT::safe_VkIndirectExecutionSetShaderLayoutInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT),
+      pNext(nullptr),
+      setLayoutCount(),
+      pSetLayouts(nullptr) {}
+
+safe_VkIndirectExecutionSetShaderLayoutInfoEXT::safe_VkIndirectExecutionSetShaderLayoutInfoEXT(
+    const safe_VkIndirectExecutionSetShaderLayoutInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    setLayoutCount = copy_src.setLayoutCount;
+    pSetLayouts = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (setLayoutCount && copy_src.pSetLayouts) {
+        pSetLayouts = new VkDescriptorSetLayout[setLayoutCount];
+        for (uint32_t i = 0; i < setLayoutCount; ++i) {
+            pSetLayouts[i] = copy_src.pSetLayouts[i];
+        }
+    }
+}
+
+safe_VkIndirectExecutionSetShaderLayoutInfoEXT& safe_VkIndirectExecutionSetShaderLayoutInfoEXT::operator=(
+    const safe_VkIndirectExecutionSetShaderLayoutInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pSetLayouts) delete[] pSetLayouts;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    setLayoutCount = copy_src.setLayoutCount;
+    pSetLayouts = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (setLayoutCount && copy_src.pSetLayouts) {
+        pSetLayouts = new VkDescriptorSetLayout[setLayoutCount];
+        for (uint32_t i = 0; i < setLayoutCount; ++i) {
+            pSetLayouts[i] = copy_src.pSetLayouts[i];
+        }
+    }
+
+    return *this;
+}
+
+safe_VkIndirectExecutionSetShaderLayoutInfoEXT::~safe_VkIndirectExecutionSetShaderLayoutInfoEXT() {
+    if (pSetLayouts) delete[] pSetLayouts;
+    FreePnextChain(pNext);
+}
+
+void safe_VkIndirectExecutionSetShaderLayoutInfoEXT::initialize(const VkIndirectExecutionSetShaderLayoutInfoEXT* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pSetLayouts) delete[] pSetLayouts;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    setLayoutCount = in_struct->setLayoutCount;
+    pSetLayouts = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (setLayoutCount && in_struct->pSetLayouts) {
+        pSetLayouts = new VkDescriptorSetLayout[setLayoutCount];
+        for (uint32_t i = 0; i < setLayoutCount; ++i) {
+            pSetLayouts[i] = in_struct->pSetLayouts[i];
+        }
+    }
+}
+
+void safe_VkIndirectExecutionSetShaderLayoutInfoEXT::initialize(const safe_VkIndirectExecutionSetShaderLayoutInfoEXT* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    setLayoutCount = copy_src->setLayoutCount;
+    pSetLayouts = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (setLayoutCount && copy_src->pSetLayouts) {
+        pSetLayouts = new VkDescriptorSetLayout[setLayoutCount];
+        for (uint32_t i = 0; i < setLayoutCount; ++i) {
+            pSetLayouts[i] = copy_src->pSetLayouts[i];
+        }
+    }
+}
+
+safe_VkIndirectExecutionSetShaderInfoEXT::safe_VkIndirectExecutionSetShaderInfoEXT(
+    const VkIndirectExecutionSetShaderInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      shaderCount(in_struct->shaderCount),
+      pInitialShaders(nullptr),
+      pSetLayoutInfos(nullptr),
+      maxShaderCount(in_struct->maxShaderCount),
+      pushConstantRangeCount(in_struct->pushConstantRangeCount),
+      pPushConstantRanges(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (shaderCount && in_struct->pInitialShaders) {
+        pInitialShaders = new VkShaderEXT[shaderCount];
+        for (uint32_t i = 0; i < shaderCount; ++i) {
+            pInitialShaders[i] = in_struct->pInitialShaders[i];
+        }
+    }
+    if (shaderCount && in_struct->pSetLayoutInfos) {
+        pSetLayoutInfos = new safe_VkIndirectExecutionSetShaderLayoutInfoEXT[shaderCount];
+        for (uint32_t i = 0; i < shaderCount; ++i) {
+            pSetLayoutInfos[i].initialize(&in_struct->pSetLayoutInfos[i]);
+        }
+    }
+
+    if (in_struct->pPushConstantRanges) {
+        pPushConstantRanges = new VkPushConstantRange[in_struct->pushConstantRangeCount];
+        memcpy((void*)pPushConstantRanges, (void*)in_struct->pPushConstantRanges,
+               sizeof(VkPushConstantRange) * in_struct->pushConstantRangeCount);
+    }
+}
+
+safe_VkIndirectExecutionSetShaderInfoEXT::safe_VkIndirectExecutionSetShaderInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT),
+      pNext(nullptr),
+      shaderCount(),
+      pInitialShaders(nullptr),
+      pSetLayoutInfos(nullptr),
+      maxShaderCount(),
+      pushConstantRangeCount(),
+      pPushConstantRanges(nullptr) {}
+
+safe_VkIndirectExecutionSetShaderInfoEXT::safe_VkIndirectExecutionSetShaderInfoEXT(
+    const safe_VkIndirectExecutionSetShaderInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    shaderCount = copy_src.shaderCount;
+    pInitialShaders = nullptr;
+    pSetLayoutInfos = nullptr;
+    maxShaderCount = copy_src.maxShaderCount;
+    pushConstantRangeCount = copy_src.pushConstantRangeCount;
+    pPushConstantRanges = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (shaderCount && copy_src.pInitialShaders) {
+        pInitialShaders = new VkShaderEXT[shaderCount];
+        for (uint32_t i = 0; i < shaderCount; ++i) {
+            pInitialShaders[i] = copy_src.pInitialShaders[i];
+        }
+    }
+    if (shaderCount && copy_src.pSetLayoutInfos) {
+        pSetLayoutInfos = new safe_VkIndirectExecutionSetShaderLayoutInfoEXT[shaderCount];
+        for (uint32_t i = 0; i < shaderCount; ++i) {
+            pSetLayoutInfos[i].initialize(&copy_src.pSetLayoutInfos[i]);
+        }
+    }
+
+    if (copy_src.pPushConstantRanges) {
+        pPushConstantRanges = new VkPushConstantRange[copy_src.pushConstantRangeCount];
+        memcpy((void*)pPushConstantRanges, (void*)copy_src.pPushConstantRanges,
+               sizeof(VkPushConstantRange) * copy_src.pushConstantRangeCount);
+    }
+}
+
+safe_VkIndirectExecutionSetShaderInfoEXT& safe_VkIndirectExecutionSetShaderInfoEXT::operator=(
+    const safe_VkIndirectExecutionSetShaderInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pInitialShaders) delete[] pInitialShaders;
+    if (pSetLayoutInfos) delete[] pSetLayoutInfos;
+    if (pPushConstantRanges) delete[] pPushConstantRanges;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderCount = copy_src.shaderCount;
+    pInitialShaders = nullptr;
+    pSetLayoutInfos = nullptr;
+    maxShaderCount = copy_src.maxShaderCount;
+    pushConstantRangeCount = copy_src.pushConstantRangeCount;
+    pPushConstantRanges = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (shaderCount && copy_src.pInitialShaders) {
+        pInitialShaders = new VkShaderEXT[shaderCount];
+        for (uint32_t i = 0; i < shaderCount; ++i) {
+            pInitialShaders[i] = copy_src.pInitialShaders[i];
+        }
+    }
+    if (shaderCount && copy_src.pSetLayoutInfos) {
+        pSetLayoutInfos = new safe_VkIndirectExecutionSetShaderLayoutInfoEXT[shaderCount];
+        for (uint32_t i = 0; i < shaderCount; ++i) {
+            pSetLayoutInfos[i].initialize(&copy_src.pSetLayoutInfos[i]);
+        }
+    }
+
+    if (copy_src.pPushConstantRanges) {
+        pPushConstantRanges = new VkPushConstantRange[copy_src.pushConstantRangeCount];
+        memcpy((void*)pPushConstantRanges, (void*)copy_src.pPushConstantRanges,
+               sizeof(VkPushConstantRange) * copy_src.pushConstantRangeCount);
+    }
+
+    return *this;
+}
+
+safe_VkIndirectExecutionSetShaderInfoEXT::~safe_VkIndirectExecutionSetShaderInfoEXT() {
+    if (pInitialShaders) delete[] pInitialShaders;
+    if (pSetLayoutInfos) delete[] pSetLayoutInfos;
+    if (pPushConstantRanges) delete[] pPushConstantRanges;
+    FreePnextChain(pNext);
+}
+
+void safe_VkIndirectExecutionSetShaderInfoEXT::initialize(const VkIndirectExecutionSetShaderInfoEXT* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pInitialShaders) delete[] pInitialShaders;
+    if (pSetLayoutInfos) delete[] pSetLayoutInfos;
+    if (pPushConstantRanges) delete[] pPushConstantRanges;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderCount = in_struct->shaderCount;
+    pInitialShaders = nullptr;
+    pSetLayoutInfos = nullptr;
+    maxShaderCount = in_struct->maxShaderCount;
+    pushConstantRangeCount = in_struct->pushConstantRangeCount;
+    pPushConstantRanges = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (shaderCount && in_struct->pInitialShaders) {
+        pInitialShaders = new VkShaderEXT[shaderCount];
+        for (uint32_t i = 0; i < shaderCount; ++i) {
+            pInitialShaders[i] = in_struct->pInitialShaders[i];
+        }
+    }
+    if (shaderCount && in_struct->pSetLayoutInfos) {
+        pSetLayoutInfos = new safe_VkIndirectExecutionSetShaderLayoutInfoEXT[shaderCount];
+        for (uint32_t i = 0; i < shaderCount; ++i) {
+            pSetLayoutInfos[i].initialize(&in_struct->pSetLayoutInfos[i]);
+        }
+    }
+
+    if (in_struct->pPushConstantRanges) {
+        pPushConstantRanges = new VkPushConstantRange[in_struct->pushConstantRangeCount];
+        memcpy((void*)pPushConstantRanges, (void*)in_struct->pPushConstantRanges,
+               sizeof(VkPushConstantRange) * in_struct->pushConstantRangeCount);
+    }
+}
+
+void safe_VkIndirectExecutionSetShaderInfoEXT::initialize(const safe_VkIndirectExecutionSetShaderInfoEXT* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderCount = copy_src->shaderCount;
+    pInitialShaders = nullptr;
+    pSetLayoutInfos = nullptr;
+    maxShaderCount = copy_src->maxShaderCount;
+    pushConstantRangeCount = copy_src->pushConstantRangeCount;
+    pPushConstantRanges = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (shaderCount && copy_src->pInitialShaders) {
+        pInitialShaders = new VkShaderEXT[shaderCount];
+        for (uint32_t i = 0; i < shaderCount; ++i) {
+            pInitialShaders[i] = copy_src->pInitialShaders[i];
+        }
+    }
+    if (shaderCount && copy_src->pSetLayoutInfos) {
+        pSetLayoutInfos = new safe_VkIndirectExecutionSetShaderLayoutInfoEXT[shaderCount];
+        for (uint32_t i = 0; i < shaderCount; ++i) {
+            pSetLayoutInfos[i].initialize(&copy_src->pSetLayoutInfos[i]);
+        }
+    }
+
+    if (copy_src->pPushConstantRanges) {
+        pPushConstantRanges = new VkPushConstantRange[copy_src->pushConstantRangeCount];
+        memcpy((void*)pPushConstantRanges, (void*)copy_src->pPushConstantRanges,
+               sizeof(VkPushConstantRange) * copy_src->pushConstantRangeCount);
+    }
+}
+
+safe_VkIndirectExecutionSetCreateInfoEXT::safe_VkIndirectExecutionSetCreateInfoEXT(
+    const VkIndirectExecutionSetCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), type(in_struct->type), info(in_struct->info) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkIndirectExecutionSetCreateInfoEXT::safe_VkIndirectExecutionSetCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT), pNext(nullptr), type(), info() {}
+
+safe_VkIndirectExecutionSetCreateInfoEXT::safe_VkIndirectExecutionSetCreateInfoEXT(
+    const safe_VkIndirectExecutionSetCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    type = copy_src.type;
+    info = copy_src.info;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkIndirectExecutionSetCreateInfoEXT& safe_VkIndirectExecutionSetCreateInfoEXT::operator=(
+    const safe_VkIndirectExecutionSetCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    type = copy_src.type;
+    info = copy_src.info;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkIndirectExecutionSetCreateInfoEXT::~safe_VkIndirectExecutionSetCreateInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkIndirectExecutionSetCreateInfoEXT::initialize(const VkIndirectExecutionSetCreateInfoEXT* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    type = in_struct->type;
+    info = in_struct->info;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkIndirectExecutionSetCreateInfoEXT::initialize(const safe_VkIndirectExecutionSetCreateInfoEXT* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    type = copy_src->type;
+    info = copy_src->info;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkGeneratedCommandsInfoEXT::safe_VkGeneratedCommandsInfoEXT(const VkGeneratedCommandsInfoEXT* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      shaderStages(in_struct->shaderStages),
+      indirectExecutionSet(in_struct->indirectExecutionSet),
+      indirectCommandsLayout(in_struct->indirectCommandsLayout),
+      indirectAddress(in_struct->indirectAddress),
+      indirectAddressSize(in_struct->indirectAddressSize),
+      preprocessAddress(in_struct->preprocessAddress),
+      preprocessSize(in_struct->preprocessSize),
+      maxSequenceCount(in_struct->maxSequenceCount),
+      sequenceCountAddress(in_struct->sequenceCountAddress),
+      maxDrawCount(in_struct->maxDrawCount) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkGeneratedCommandsInfoEXT::safe_VkGeneratedCommandsInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT),
+      pNext(nullptr),
+      shaderStages(),
+      indirectExecutionSet(),
+      indirectCommandsLayout(),
+      indirectAddress(),
+      indirectAddressSize(),
+      preprocessAddress(),
+      preprocessSize(),
+      maxSequenceCount(),
+      sequenceCountAddress(),
+      maxDrawCount() {}
+
+safe_VkGeneratedCommandsInfoEXT::safe_VkGeneratedCommandsInfoEXT(const safe_VkGeneratedCommandsInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    shaderStages = copy_src.shaderStages;
+    indirectExecutionSet = copy_src.indirectExecutionSet;
+    indirectCommandsLayout = copy_src.indirectCommandsLayout;
+    indirectAddress = copy_src.indirectAddress;
+    indirectAddressSize = copy_src.indirectAddressSize;
+    preprocessAddress = copy_src.preprocessAddress;
+    preprocessSize = copy_src.preprocessSize;
+    maxSequenceCount = copy_src.maxSequenceCount;
+    sequenceCountAddress = copy_src.sequenceCountAddress;
+    maxDrawCount = copy_src.maxDrawCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkGeneratedCommandsInfoEXT& safe_VkGeneratedCommandsInfoEXT::operator=(const safe_VkGeneratedCommandsInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderStages = copy_src.shaderStages;
+    indirectExecutionSet = copy_src.indirectExecutionSet;
+    indirectCommandsLayout = copy_src.indirectCommandsLayout;
+    indirectAddress = copy_src.indirectAddress;
+    indirectAddressSize = copy_src.indirectAddressSize;
+    preprocessAddress = copy_src.preprocessAddress;
+    preprocessSize = copy_src.preprocessSize;
+    maxSequenceCount = copy_src.maxSequenceCount;
+    sequenceCountAddress = copy_src.sequenceCountAddress;
+    maxDrawCount = copy_src.maxDrawCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkGeneratedCommandsInfoEXT::~safe_VkGeneratedCommandsInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkGeneratedCommandsInfoEXT::initialize(const VkGeneratedCommandsInfoEXT* in_struct,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderStages = in_struct->shaderStages;
+    indirectExecutionSet = in_struct->indirectExecutionSet;
+    indirectCommandsLayout = in_struct->indirectCommandsLayout;
+    indirectAddress = in_struct->indirectAddress;
+    indirectAddressSize = in_struct->indirectAddressSize;
+    preprocessAddress = in_struct->preprocessAddress;
+    preprocessSize = in_struct->preprocessSize;
+    maxSequenceCount = in_struct->maxSequenceCount;
+    sequenceCountAddress = in_struct->sequenceCountAddress;
+    maxDrawCount = in_struct->maxDrawCount;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkGeneratedCommandsInfoEXT::initialize(const safe_VkGeneratedCommandsInfoEXT* copy_src,
+                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderStages = copy_src->shaderStages;
+    indirectExecutionSet = copy_src->indirectExecutionSet;
+    indirectCommandsLayout = copy_src->indirectCommandsLayout;
+    indirectAddress = copy_src->indirectAddress;
+    indirectAddressSize = copy_src->indirectAddressSize;
+    preprocessAddress = copy_src->preprocessAddress;
+    preprocessSize = copy_src->preprocessSize;
+    maxSequenceCount = copy_src->maxSequenceCount;
+    sequenceCountAddress = copy_src->sequenceCountAddress;
+    maxDrawCount = copy_src->maxDrawCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkWriteIndirectExecutionSetPipelineEXT::safe_VkWriteIndirectExecutionSetPipelineEXT(
+    const VkWriteIndirectExecutionSetPipelineEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), index(in_struct->index), pipeline(in_struct->pipeline) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkWriteIndirectExecutionSetPipelineEXT::safe_VkWriteIndirectExecutionSetPipelineEXT()
+    : sType(VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT), pNext(nullptr), index(), pipeline() {}
+
+safe_VkWriteIndirectExecutionSetPipelineEXT::safe_VkWriteIndirectExecutionSetPipelineEXT(
+    const safe_VkWriteIndirectExecutionSetPipelineEXT& copy_src) {
+    sType = copy_src.sType;
+    index = copy_src.index;
+    pipeline = copy_src.pipeline;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkWriteIndirectExecutionSetPipelineEXT& safe_VkWriteIndirectExecutionSetPipelineEXT::operator=(
+    const safe_VkWriteIndirectExecutionSetPipelineEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    index = copy_src.index;
+    pipeline = copy_src.pipeline;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkWriteIndirectExecutionSetPipelineEXT::~safe_VkWriteIndirectExecutionSetPipelineEXT() { FreePnextChain(pNext); }
+
+void safe_VkWriteIndirectExecutionSetPipelineEXT::initialize(const VkWriteIndirectExecutionSetPipelineEXT* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    index = in_struct->index;
+    pipeline = in_struct->pipeline;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkWriteIndirectExecutionSetPipelineEXT::initialize(const safe_VkWriteIndirectExecutionSetPipelineEXT* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    index = copy_src->index;
+    pipeline = copy_src->pipeline;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkIndirectCommandsLayoutTokenEXT::safe_VkIndirectCommandsLayoutTokenEXT(const VkIndirectCommandsLayoutTokenEXT* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType), type(in_struct->type), data(in_struct->data), offset(in_struct->offset) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkIndirectCommandsLayoutTokenEXT::safe_VkIndirectCommandsLayoutTokenEXT()
+    : sType(VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT), pNext(nullptr), type(), data(), offset() {}
+
+safe_VkIndirectCommandsLayoutTokenEXT::safe_VkIndirectCommandsLayoutTokenEXT(
+    const safe_VkIndirectCommandsLayoutTokenEXT& copy_src) {
+    sType = copy_src.sType;
+    type = copy_src.type;
+    data = copy_src.data;
+    offset = copy_src.offset;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkIndirectCommandsLayoutTokenEXT& safe_VkIndirectCommandsLayoutTokenEXT::operator=(
+    const safe_VkIndirectCommandsLayoutTokenEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    type = copy_src.type;
+    data = copy_src.data;
+    offset = copy_src.offset;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkIndirectCommandsLayoutTokenEXT::~safe_VkIndirectCommandsLayoutTokenEXT() { FreePnextChain(pNext); }
+
+void safe_VkIndirectCommandsLayoutTokenEXT::initialize(const VkIndirectCommandsLayoutTokenEXT* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    type = in_struct->type;
+    data = in_struct->data;
+    offset = in_struct->offset;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkIndirectCommandsLayoutTokenEXT::initialize(const safe_VkIndirectCommandsLayoutTokenEXT* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    type = copy_src->type;
+    data = copy_src->data;
+    offset = copy_src->offset;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkIndirectCommandsLayoutCreateInfoEXT::safe_VkIndirectCommandsLayoutCreateInfoEXT(
+    const VkIndirectCommandsLayoutCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      shaderStages(in_struct->shaderStages),
+      indirectStride(in_struct->indirectStride),
+      pipelineLayout(in_struct->pipelineLayout),
+      tokenCount(in_struct->tokenCount),
+      pTokens(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (tokenCount && in_struct->pTokens) {
+        pTokens = new safe_VkIndirectCommandsLayoutTokenEXT[tokenCount];
+        for (uint32_t i = 0; i < tokenCount; ++i) {
+            pTokens[i].initialize(&in_struct->pTokens[i]);
+        }
+    }
+}
+
+safe_VkIndirectCommandsLayoutCreateInfoEXT::safe_VkIndirectCommandsLayoutCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT),
+      pNext(nullptr),
+      flags(),
+      shaderStages(),
+      indirectStride(),
+      pipelineLayout(),
+      tokenCount(),
+      pTokens(nullptr) {}
+
+safe_VkIndirectCommandsLayoutCreateInfoEXT::safe_VkIndirectCommandsLayoutCreateInfoEXT(
+    const safe_VkIndirectCommandsLayoutCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    shaderStages = copy_src.shaderStages;
+    indirectStride = copy_src.indirectStride;
+    pipelineLayout = copy_src.pipelineLayout;
+    tokenCount = copy_src.tokenCount;
+    pTokens = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (tokenCount && copy_src.pTokens) {
+        pTokens = new safe_VkIndirectCommandsLayoutTokenEXT[tokenCount];
+        for (uint32_t i = 0; i < tokenCount; ++i) {
+            pTokens[i].initialize(&copy_src.pTokens[i]);
+        }
+    }
+}
+
+safe_VkIndirectCommandsLayoutCreateInfoEXT& safe_VkIndirectCommandsLayoutCreateInfoEXT::operator=(
+    const safe_VkIndirectCommandsLayoutCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pTokens) delete[] pTokens;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    shaderStages = copy_src.shaderStages;
+    indirectStride = copy_src.indirectStride;
+    pipelineLayout = copy_src.pipelineLayout;
+    tokenCount = copy_src.tokenCount;
+    pTokens = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (tokenCount && copy_src.pTokens) {
+        pTokens = new safe_VkIndirectCommandsLayoutTokenEXT[tokenCount];
+        for (uint32_t i = 0; i < tokenCount; ++i) {
+            pTokens[i].initialize(&copy_src.pTokens[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkIndirectCommandsLayoutCreateInfoEXT::~safe_VkIndirectCommandsLayoutCreateInfoEXT() {
+    if (pTokens) delete[] pTokens;
+    FreePnextChain(pNext);
+}
+
+void safe_VkIndirectCommandsLayoutCreateInfoEXT::initialize(const VkIndirectCommandsLayoutCreateInfoEXT* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pTokens) delete[] pTokens;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    shaderStages = in_struct->shaderStages;
+    indirectStride = in_struct->indirectStride;
+    pipelineLayout = in_struct->pipelineLayout;
+    tokenCount = in_struct->tokenCount;
+    pTokens = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (tokenCount && in_struct->pTokens) {
+        pTokens = new safe_VkIndirectCommandsLayoutTokenEXT[tokenCount];
+        for (uint32_t i = 0; i < tokenCount; ++i) {
+            pTokens[i].initialize(&in_struct->pTokens[i]);
+        }
+    }
+}
+
+void safe_VkIndirectCommandsLayoutCreateInfoEXT::initialize(const safe_VkIndirectCommandsLayoutCreateInfoEXT* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    shaderStages = copy_src->shaderStages;
+    indirectStride = copy_src->indirectStride;
+    pipelineLayout = copy_src->pipelineLayout;
+    tokenCount = copy_src->tokenCount;
+    pTokens = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (tokenCount && copy_src->pTokens) {
+        pTokens = new safe_VkIndirectCommandsLayoutTokenEXT[tokenCount];
+        for (uint32_t i = 0; i < tokenCount; ++i) {
+            pTokens[i].initialize(&copy_src->pTokens[i]);
+        }
+    }
+}
+
+safe_VkGeneratedCommandsPipelineInfoEXT::safe_VkGeneratedCommandsPipelineInfoEXT(
+    const VkGeneratedCommandsPipelineInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), pipeline(in_struct->pipeline) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkGeneratedCommandsPipelineInfoEXT::safe_VkGeneratedCommandsPipelineInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT), pNext(nullptr), pipeline() {}
+
+safe_VkGeneratedCommandsPipelineInfoEXT::safe_VkGeneratedCommandsPipelineInfoEXT(
+    const safe_VkGeneratedCommandsPipelineInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    pipeline = copy_src.pipeline;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkGeneratedCommandsPipelineInfoEXT& safe_VkGeneratedCommandsPipelineInfoEXT::operator=(
+    const safe_VkGeneratedCommandsPipelineInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pipeline = copy_src.pipeline;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkGeneratedCommandsPipelineInfoEXT::~safe_VkGeneratedCommandsPipelineInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkGeneratedCommandsPipelineInfoEXT::initialize(const VkGeneratedCommandsPipelineInfoEXT* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pipeline = in_struct->pipeline;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkGeneratedCommandsPipelineInfoEXT::initialize(const safe_VkGeneratedCommandsPipelineInfoEXT* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pipeline = copy_src->pipeline;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkGeneratedCommandsShaderInfoEXT::safe_VkGeneratedCommandsShaderInfoEXT(const VkGeneratedCommandsShaderInfoEXT* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType), shaderCount(in_struct->shaderCount), pShaders(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (shaderCount && in_struct->pShaders) {
+        pShaders = new VkShaderEXT[shaderCount];
+        for (uint32_t i = 0; i < shaderCount; ++i) {
+            pShaders[i] = in_struct->pShaders[i];
+        }
+    }
+}
+
+safe_VkGeneratedCommandsShaderInfoEXT::safe_VkGeneratedCommandsShaderInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT), pNext(nullptr), shaderCount(), pShaders(nullptr) {}
+
+safe_VkGeneratedCommandsShaderInfoEXT::safe_VkGeneratedCommandsShaderInfoEXT(
+    const safe_VkGeneratedCommandsShaderInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    shaderCount = copy_src.shaderCount;
+    pShaders = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (shaderCount && copy_src.pShaders) {
+        pShaders = new VkShaderEXT[shaderCount];
+        for (uint32_t i = 0; i < shaderCount; ++i) {
+            pShaders[i] = copy_src.pShaders[i];
+        }
+    }
+}
+
+safe_VkGeneratedCommandsShaderInfoEXT& safe_VkGeneratedCommandsShaderInfoEXT::operator=(
+    const safe_VkGeneratedCommandsShaderInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pShaders) delete[] pShaders;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderCount = copy_src.shaderCount;
+    pShaders = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (shaderCount && copy_src.pShaders) {
+        pShaders = new VkShaderEXT[shaderCount];
+        for (uint32_t i = 0; i < shaderCount; ++i) {
+            pShaders[i] = copy_src.pShaders[i];
+        }
+    }
+
+    return *this;
+}
+
+safe_VkGeneratedCommandsShaderInfoEXT::~safe_VkGeneratedCommandsShaderInfoEXT() {
+    if (pShaders) delete[] pShaders;
+    FreePnextChain(pNext);
+}
+
+void safe_VkGeneratedCommandsShaderInfoEXT::initialize(const VkGeneratedCommandsShaderInfoEXT* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pShaders) delete[] pShaders;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderCount = in_struct->shaderCount;
+    pShaders = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (shaderCount && in_struct->pShaders) {
+        pShaders = new VkShaderEXT[shaderCount];
+        for (uint32_t i = 0; i < shaderCount; ++i) {
+            pShaders[i] = in_struct->pShaders[i];
+        }
+    }
+}
+
+void safe_VkGeneratedCommandsShaderInfoEXT::initialize(const safe_VkGeneratedCommandsShaderInfoEXT* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderCount = copy_src->shaderCount;
+    pShaders = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (shaderCount && copy_src->pShaders) {
+        pShaders = new VkShaderEXT[shaderCount];
+        for (uint32_t i = 0; i < shaderCount; ++i) {
+            pShaders[i] = copy_src->pShaders[i];
+        }
+    }
+}
+
+safe_VkWriteIndirectExecutionSetShaderEXT::safe_VkWriteIndirectExecutionSetShaderEXT(
+    const VkWriteIndirectExecutionSetShaderEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), index(in_struct->index), shader(in_struct->shader) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkWriteIndirectExecutionSetShaderEXT::safe_VkWriteIndirectExecutionSetShaderEXT()
+    : sType(VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT), pNext(nullptr), index(), shader() {}
+
+safe_VkWriteIndirectExecutionSetShaderEXT::safe_VkWriteIndirectExecutionSetShaderEXT(
+    const safe_VkWriteIndirectExecutionSetShaderEXT& copy_src) {
+    sType = copy_src.sType;
+    index = copy_src.index;
+    shader = copy_src.shader;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkWriteIndirectExecutionSetShaderEXT& safe_VkWriteIndirectExecutionSetShaderEXT::operator=(
+    const safe_VkWriteIndirectExecutionSetShaderEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    index = copy_src.index;
+    shader = copy_src.shader;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkWriteIndirectExecutionSetShaderEXT::~safe_VkWriteIndirectExecutionSetShaderEXT() { FreePnextChain(pNext); }
+
+void safe_VkWriteIndirectExecutionSetShaderEXT::initialize(const VkWriteIndirectExecutionSetShaderEXT* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    index = in_struct->index;
+    shader = in_struct->shader;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkWriteIndirectExecutionSetShaderEXT::initialize(const safe_VkWriteIndirectExecutionSetShaderEXT* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    index = copy_src->index;
+    shader = copy_src->shader;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceDepthClampControlFeaturesEXT::safe_VkPhysicalDeviceDepthClampControlFeaturesEXT(
+    const VkPhysicalDeviceDepthClampControlFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), depthClampControl(in_struct->depthClampControl) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDepthClampControlFeaturesEXT::safe_VkPhysicalDeviceDepthClampControlFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT), pNext(nullptr), depthClampControl() {}
+
+safe_VkPhysicalDeviceDepthClampControlFeaturesEXT::safe_VkPhysicalDeviceDepthClampControlFeaturesEXT(
+    const safe_VkPhysicalDeviceDepthClampControlFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    depthClampControl = copy_src.depthClampControl;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDepthClampControlFeaturesEXT& safe_VkPhysicalDeviceDepthClampControlFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceDepthClampControlFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    depthClampControl = copy_src.depthClampControl;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDepthClampControlFeaturesEXT::~safe_VkPhysicalDeviceDepthClampControlFeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceDepthClampControlFeaturesEXT::initialize(const VkPhysicalDeviceDepthClampControlFeaturesEXT* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    depthClampControl = in_struct->depthClampControl;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDepthClampControlFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceDepthClampControlFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    depthClampControl = copy_src->depthClampControl;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineViewportDepthClampControlCreateInfoEXT::safe_VkPipelineViewportDepthClampControlCreateInfoEXT(
+    const VkPipelineViewportDepthClampControlCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), depthClampMode(in_struct->depthClampMode), pDepthClampRange(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pDepthClampRange) {
+        pDepthClampRange = new VkDepthClampRangeEXT(*in_struct->pDepthClampRange);
+    }
+}
+
+safe_VkPipelineViewportDepthClampControlCreateInfoEXT::safe_VkPipelineViewportDepthClampControlCreateInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT),
+      pNext(nullptr),
+      depthClampMode(),
+      pDepthClampRange(nullptr) {}
+
+safe_VkPipelineViewportDepthClampControlCreateInfoEXT::safe_VkPipelineViewportDepthClampControlCreateInfoEXT(
+    const safe_VkPipelineViewportDepthClampControlCreateInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    depthClampMode = copy_src.depthClampMode;
+    pDepthClampRange = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDepthClampRange) {
+        pDepthClampRange = new VkDepthClampRangeEXT(*copy_src.pDepthClampRange);
+    }
+}
+
+safe_VkPipelineViewportDepthClampControlCreateInfoEXT& safe_VkPipelineViewportDepthClampControlCreateInfoEXT::operator=(
+    const safe_VkPipelineViewportDepthClampControlCreateInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pDepthClampRange) delete pDepthClampRange;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    depthClampMode = copy_src.depthClampMode;
+    pDepthClampRange = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDepthClampRange) {
+        pDepthClampRange = new VkDepthClampRangeEXT(*copy_src.pDepthClampRange);
+    }
+
+    return *this;
+}
+
+safe_VkPipelineViewportDepthClampControlCreateInfoEXT::~safe_VkPipelineViewportDepthClampControlCreateInfoEXT() {
+    if (pDepthClampRange) delete pDepthClampRange;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineViewportDepthClampControlCreateInfoEXT::initialize(
+    const VkPipelineViewportDepthClampControlCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pDepthClampRange) delete pDepthClampRange;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    depthClampMode = in_struct->depthClampMode;
+    pDepthClampRange = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pDepthClampRange) {
+        pDepthClampRange = new VkDepthClampRangeEXT(*in_struct->pDepthClampRange);
+    }
+}
+
+void safe_VkPipelineViewportDepthClampControlCreateInfoEXT::initialize(
+    const safe_VkPipelineViewportDepthClampControlCreateInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    depthClampMode = copy_src->depthClampMode;
+    pDepthClampRange = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pDepthClampRange) {
+        pDepthClampRange = new VkDepthClampRangeEXT(*copy_src->pDepthClampRange);
+    }
+}
+
 safe_VkPhysicalDeviceMeshShaderFeaturesEXT::safe_VkPhysicalDeviceMeshShaderFeaturesEXT(
     const VkPhysicalDeviceMeshShaderFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType),
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index 3550dba..36e5749 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -1840,6 +1840,18 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
                 safe_pNext = new safe_VkPhysicalDeviceRayTracingValidationFeaturesNV(reinterpret_cast<const VkPhysicalDeviceRayTracingValidationFeaturesNV *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT:
+                safe_pNext = new safe_VkGeneratedCommandsPipelineInfoEXT(reinterpret_cast<const VkGeneratedCommandsPipelineInfoEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT:
+                safe_pNext = new safe_VkGeneratedCommandsShaderInfoEXT(reinterpret_cast<const VkGeneratedCommandsShaderInfoEXT *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA:
                 safe_pNext = new safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA(reinterpret_cast<const VkPhysicalDeviceImageAlignmentControlFeaturesMESA *>(pNext), copy_state, false);
                 break;
@@ -1849,6 +1861,12 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA:
                 safe_pNext = new safe_VkImageAlignmentControlCreateInfoMESA(reinterpret_cast<const VkImageAlignmentControlCreateInfoMESA *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceDepthClampControlFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceDepthClampControlFeaturesEXT *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT:
+                safe_pNext = new safe_VkPipelineViewportDepthClampControlCreateInfoEXT(reinterpret_cast<const VkPipelineViewportDepthClampControlCreateInfoEXT *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
                 safe_pNext = new safe_VkWriteDescriptorSetAccelerationStructureKHR(reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR *>(pNext), copy_state, false);
                 break;
@@ -3705,6 +3723,18 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
             delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingValidationFeaturesNV *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT:
+            delete reinterpret_cast<safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT:
+            delete reinterpret_cast<safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT:
+            delete reinterpret_cast<safe_VkGeneratedCommandsPipelineInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT:
+            delete reinterpret_cast<safe_VkGeneratedCommandsShaderInfoEXT *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA:
             delete reinterpret_cast<safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA *>(header);
             break;
@@ -3714,6 +3744,12 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA:
             delete reinterpret_cast<safe_VkImageAlignmentControlCreateInfoMESA *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT:
+            delete reinterpret_cast<safe_VkPhysicalDeviceDepthClampControlFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT:
+            delete reinterpret_cast<safe_VkPipelineViewportDepthClampControlCreateInfoEXT *>(header);
+            break;
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
             delete reinterpret_cast<safe_VkWriteDescriptorSetAccelerationStructureKHR *>(header);
             break;

From 1a35a3e51f1a47b86e0c56824880ca4bc189e519 Mon Sep 17 00:00:00 2001
From: vrepetsky <123964412+vrepetsky@users.noreply.github.com>
Date: Fri, 27 Sep 2024 12:22:00 +0100
Subject: [PATCH 051/106] Fix usage of __system_property_read_callback for
 Android<26

Modify the function for getting system properties on Android: *Use the new __system_property_read_callback API that appeared in Android O / API level 26 when available. It is the preferred way because it allows handling long property names and better property caching.
*When not available use the deprecated __system_property_get function.
---
 src/layer/layer_settings_manager.cpp | 40 +++++++++++++++++++++-------
 1 file changed, 30 insertions(+), 10 deletions(-)

diff --git a/src/layer/layer_settings_manager.cpp b/src/layer/layer_settings_manager.cpp
index 1678e25..1722cff 100644
--- a/src/layer/layer_settings_manager.cpp
+++ b/src/layer/layer_settings_manager.cpp
@@ -33,18 +33,38 @@
 #include <algorithm>
 
 #if defined(__ANDROID__)
+/* 
+ * Use the __system_property_read_callback API that appeared in
+ * Android API level 26. If not avaible use the old __system_property_get function.
+ */
+
+// Weak function declaration, used only when not decalered in the Android headers
+void __system_property_read_callback(const prop_info* info,
+                                     void (*callback)(void* cookie,
+                                                      const char* name,
+                                                      const char* value,
+                                                      uint32_t serial),
+                                     void* cookie) __attribute__((weak));
 static std::string GetAndroidProperty(const char *name) {
     std::string output;
-    const prop_info *pi = __system_property_find(name);
-    if (pi) {
-        __system_property_read_callback(
-            pi,
-            [](void *cookie, const char *name, const char *value, uint32_t serial) {
-                (void)name;
-                (void)serial;
-                reinterpret_cast<std::string *>(cookie)->assign(value);
-            },
-            reinterpret_cast<void *>(&output));
+    if(__system_property_read_callback != nullptr) {
+        const prop_info *pi = __system_property_find(name);
+        if (pi) {
+            __system_property_read_callback(
+                pi,
+                [](void *cookie, const char *name, const char *value, uint32_t serial) {
+                    (void)name;
+                    (void)serial;
+                    reinterpret_cast<std::string *>(cookie)->assign(value);
+                },
+                reinterpret_cast<void *>(&output));
+        }
+    } else {
+        char value_buf[PROP_VALUE_MAX] = "";
+        size_t len = static_cast<size_t>(__system_property_get(name, value_buf));
+        if (len > 0 && len < sizeof(value_buf)) {
+            output.assign(value_buf, len);
+        }
     }
     return output;
 }

From 0a786ee3e4fd3602f68ff0ffd9fdcb12e0efb646 Mon Sep 17 00:00:00 2001
From: vrepetsky <123964412+vrepetsky@users.noreply.github.com>
Date: Sun, 29 Sep 2024 14:55:39 +0100
Subject: [PATCH 052/106] Update layer_settings_manager.cpp

---
 src/layer/layer_settings_manager.cpp | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/src/layer/layer_settings_manager.cpp b/src/layer/layer_settings_manager.cpp
index 1722cff..391d339 100644
--- a/src/layer/layer_settings_manager.cpp
+++ b/src/layer/layer_settings_manager.cpp
@@ -33,21 +33,18 @@
 #include <algorithm>
 
 #if defined(__ANDROID__)
-/* 
+/*
  * Use the __system_property_read_callback API that appeared in
  * Android API level 26. If not avaible use the old __system_property_get function.
  */
 
 // Weak function declaration, used only when not decalered in the Android headers
-void __system_property_read_callback(const prop_info* info,
-                                     void (*callback)(void* cookie,
-                                                      const char* name,
-                                                      const char* value,
-                                                      uint32_t serial),
-                                     void* cookie) __attribute__((weak));
+void __system_property_read_callback(const prop_info *info,
+                                     void (*callback)(void *cookie, const char *name, const char *value, uint32_t serial),
+                                     void *cookie) __attribute__((weak));
 static std::string GetAndroidProperty(const char *name) {
     std::string output;
-    if(__system_property_read_callback != nullptr) {
+    if (__system_property_read_callback != nullptr) {
         const prop_info *pi = __system_property_find(name);
         if (pi) {
             __system_property_read_callback(

From 8c907ea21fe0147f791d79051b18e21bc8c4ede0 Mon Sep 17 00:00:00 2001
From: ziga-lunarg <ziga@lunarg.com>
Date: Fri, 4 Oct 2024 16:36:27 +0200
Subject: [PATCH 053/106] build: Update to header 1.3.297

---
 include/vulkan/utility/vk_safe_struct.hpp   | 23 +++++++++
 include/vulkan/utility/vk_struct_helper.hpp |  1 +
 include/vulkan/vk_enum_string_helper.h      |  4 ++
 scripts/known_good.json                     |  4 +-
 src/vulkan/vk_safe_struct_ext.cpp           | 53 +++++++++++++++++++++
 src/vulkan/vk_safe_struct_utils.cpp         |  6 +++
 6 files changed, 89 insertions(+), 2 deletions(-)

diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index ea78bab..42fda58 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -14797,6 +14797,29 @@ struct safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
         return reinterpret_cast<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const*>(this);
     }
 };
+struct safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 presentModeFifoLatestReady;
+
+    safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT(
+        const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT(
+        const safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT& copy_src);
+    safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT& operator=(
+        const safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT& copy_src);
+    safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT();
+    ~safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT();
+    void initialize(const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT*>(this);
+    }
+    VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT const*>(this);
+    }
+};
 #ifdef VK_USE_PLATFORM_FUCHSIA
 struct safe_VkImportMemoryZirconHandleInfoFUCHSIA {
     VkStructureType sType;
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index c6395f7..26efcc0 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -782,6 +782,7 @@ template <> inline VkStructureType GetSType<VkDeviceAddressBindingCallbackDataEX
 template <> inline VkStructureType GetSType<VkPhysicalDeviceDepthClipControlFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkPipelineViewportDepthClipControlCreateInfoEXT>() { return VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT; }
+template <> inline VkStructureType GetSType<VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT; }
 #ifdef VK_USE_PLATFORM_FUCHSIA
 template <> inline VkStructureType GetSType<VkImportMemoryZirconHandleInfoFUCHSIA>() { return VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA; }
 template <> inline VkStructureType GetSType<VkMemoryZirconHandlePropertiesFUCHSIA>() { return VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index 6cd51f6..48a4fc8 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -1490,6 +1490,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT";
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
             return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA";
         case VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA:
@@ -3676,6 +3678,8 @@ static inline const char* string_VkPresentModeKHR(VkPresentModeKHR input_value)
             return "VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR";
         case VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR:
             return "VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR";
+        case VK_PRESENT_MODE_FIFO_LATEST_READY_EXT:
+            return "VK_PRESENT_MODE_FIFO_LATEST_READY_EXT";
         default:
             return "Unhandled VkPresentModeKHR";
     }
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 4cf8298..38e5189 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.3.296"
+            "commit": "v1.3.297"
         },
         {
             "name": "googletest",
@@ -46,4 +46,4 @@
         "googletest": "GOOGLETEST_INSTALL_DIR",
         "magic_enum": "MAGIC_ENUM_INSTALL_DIR"
     }
-}
\ No newline at end of file
+}
diff --git a/src/vulkan/vk_safe_struct_ext.cpp b/src/vulkan/vk_safe_struct_ext.cpp
index 7d78ba0..26feba8 100644
--- a/src/vulkan/vk_safe_struct_ext.cpp
+++ b/src/vulkan/vk_safe_struct_ext.cpp
@@ -11455,6 +11455,59 @@ void safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT::initialize(
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT::safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT(
+    const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), presentModeFifoLatestReady(in_struct->presentModeFifoLatestReady) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT::safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT),
+      pNext(nullptr),
+      presentModeFifoLatestReady() {}
+
+safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT::safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT(
+    const safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    presentModeFifoLatestReady = copy_src.presentModeFifoLatestReady;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT& safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT::operator=(
+    const safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    presentModeFifoLatestReady = copy_src.presentModeFifoLatestReady;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT::~safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT::initialize(
+    const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    presentModeFifoLatestReady = in_struct->presentModeFifoLatestReady;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT::initialize(
+    const safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    presentModeFifoLatestReady = copy_src->presentModeFifoLatestReady;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkPipelinePropertiesIdentifierEXT::safe_VkPipelinePropertiesIdentifierEXT(const VkPipelinePropertiesIdentifierEXT* in_struct,
                                                                                [[maybe_unused]] PNextCopyState* copy_state,
                                                                                bool copy_pnext)
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index 36e5749..dd0b2b2 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -1436,6 +1436,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
                 safe_pNext = new safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(reinterpret_cast<const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT(reinterpret_cast<const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT *>(pNext), copy_state, false);
+                break;
 #ifdef VK_USE_PLATFORM_FUCHSIA
             case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
                 safe_pNext = new safe_VkImportMemoryZirconHandleInfoFUCHSIA(reinterpret_cast<const VkImportMemoryZirconHandleInfoFUCHSIA *>(pNext), copy_state, false);
@@ -3319,6 +3322,9 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
             delete reinterpret_cast<safe_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT:
+            delete reinterpret_cast<safe_VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT *>(header);
+            break;
 #ifdef VK_USE_PLATFORM_FUCHSIA
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
             delete reinterpret_cast<safe_VkImportMemoryZirconHandleInfoFUCHSIA *>(header);

From bfd85956e1b4c1c79842ce857fc7fb15adb8a573 Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Fri, 11 Oct 2024 09:02:49 -0700
Subject: [PATCH 054/106] build: Update to header 1.3.298

---
 include/vulkan/utility/vk_safe_struct.hpp |  9 +++-
 include/vulkan/vk_enum_string_helper.h    |  5 ++
 scripts/known_good.json                   |  4 +-
 src/vulkan/vk_safe_struct_vendor.cpp      | 64 +++++++++++++++++++----
 4 files changed, 68 insertions(+), 14 deletions(-)

diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index 42fda58..a4b0e99 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -10168,6 +10168,7 @@ struct safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX {
     VkStructureType sType;
     void* pNext{};
     VkBool32 shaderEnqueue;
+    VkBool32 shaderMeshEnqueue;
 
     safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX(const VkPhysicalDeviceShaderEnqueueFeaturesAMDX* in_struct,
                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
@@ -10190,6 +10191,8 @@ struct safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX {
     uint32_t maxExecutionGraphShaderPayloadSize;
     uint32_t maxExecutionGraphShaderPayloadCount;
     uint32_t executionGraphDispatchAddressAlignment;
+    uint32_t maxExecutionGraphWorkgroupCount[3];
+    uint32_t maxExecutionGraphWorkgroups;
 
     safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX(const VkPhysicalDeviceShaderEnqueuePropertiesAMDX* in_struct,
                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
@@ -10209,7 +10212,9 @@ struct safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX {
 struct safe_VkExecutionGraphPipelineScratchSizeAMDX {
     VkStructureType sType;
     void* pNext{};
-    VkDeviceSize size;
+    VkDeviceSize minSize;
+    VkDeviceSize maxSize;
+    VkDeviceSize sizeGranularity;
 
     safe_VkExecutionGraphPipelineScratchSizeAMDX(const VkExecutionGraphPipelineScratchSizeAMDX* in_struct,
                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
@@ -18485,7 +18490,7 @@ struct safe_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT {
 };
 struct safe_VkGeneratedCommandsMemoryRequirementsInfoEXT {
     VkStructureType sType;
-    void* pNext{};
+    const void* pNext{};
     VkIndirectExecutionSetEXT indirectExecutionSet;
     VkIndirectCommandsLayoutEXT indirectCommandsLayout;
     uint32_t maxSequenceCount;
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index 48a4fc8..9ff6e79 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -8429,6 +8429,9 @@ static inline const char* string_VkPipelineCreateFlagBits2KHR(uint64_t input_val
     if (input_value == VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR) return "VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR";
     if (input_value == VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR) return "VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR";
     if (input_value == VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR) return "VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR";
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    if (input_value == VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX) return "VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX";
+#endif  // VK_ENABLE_BETA_EXTENSIONS
     if (input_value == VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT) return "VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT";
     if (input_value == VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR) return "VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR";
     if (input_value == VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR) return "VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR";
@@ -8489,7 +8492,9 @@ static inline const char* string_VkBufferUsageFlagBits2KHR(uint64_t input_value)
     if (input_value == VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT_KHR) return "VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT_KHR";
     if (input_value == VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT_KHR) return "VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT_KHR";
     if (input_value == VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT_KHR) return "VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT_KHR";
+#ifdef VK_ENABLE_BETA_EXTENSIONS
     if (input_value == VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX) return "VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX";
+#endif  // VK_ENABLE_BETA_EXTENSIONS
     if (input_value == VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT) return "VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT";
     if (input_value == VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR) return "VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR";
     if (input_value == VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT";
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 38e5189..a36bba4 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.3.297"
+            "commit": "v1.3.298"
         },
         {
             "name": "googletest",
@@ -46,4 +46,4 @@
         "googletest": "GOOGLETEST_INSTALL_DIR",
         "magic_enum": "MAGIC_ENUM_INSTALL_DIR"
     }
-}
+}
\ No newline at end of file
diff --git a/src/vulkan/vk_safe_struct_vendor.cpp b/src/vulkan/vk_safe_struct_vendor.cpp
index b6696a8..de94266 100644
--- a/src/vulkan/vk_safe_struct_vendor.cpp
+++ b/src/vulkan/vk_safe_struct_vendor.cpp
@@ -2320,19 +2320,20 @@ void safe_VkAndroidHardwareBufferFormatProperties2ANDROID::initialize(
 
 safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX::safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX(
     const VkPhysicalDeviceShaderEnqueueFeaturesAMDX* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), shaderEnqueue(in_struct->shaderEnqueue) {
+    : sType(in_struct->sType), shaderEnqueue(in_struct->shaderEnqueue), shaderMeshEnqueue(in_struct->shaderMeshEnqueue) {
     if (copy_pnext) {
         pNext = SafePnextCopy(in_struct->pNext, copy_state);
     }
 }
 
 safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX::safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX()
-    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX), pNext(nullptr), shaderEnqueue() {}
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX), pNext(nullptr), shaderEnqueue(), shaderMeshEnqueue() {}
 
 safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX::safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX(
     const safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX& copy_src) {
     sType = copy_src.sType;
     shaderEnqueue = copy_src.shaderEnqueue;
+    shaderMeshEnqueue = copy_src.shaderMeshEnqueue;
     pNext = SafePnextCopy(copy_src.pNext);
 }
 
@@ -2344,6 +2345,7 @@ safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX& safe_VkPhysicalDeviceShaderEnque
 
     sType = copy_src.sType;
     shaderEnqueue = copy_src.shaderEnqueue;
+    shaderMeshEnqueue = copy_src.shaderMeshEnqueue;
     pNext = SafePnextCopy(copy_src.pNext);
 
     return *this;
@@ -2356,6 +2358,7 @@ void safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX::initialize(const VkPhysical
     FreePnextChain(pNext);
     sType = in_struct->sType;
     shaderEnqueue = in_struct->shaderEnqueue;
+    shaderMeshEnqueue = in_struct->shaderMeshEnqueue;
     pNext = SafePnextCopy(in_struct->pNext, copy_state);
 }
 
@@ -2363,6 +2366,7 @@ void safe_VkPhysicalDeviceShaderEnqueueFeaturesAMDX::initialize(const safe_VkPhy
                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
     sType = copy_src->sType;
     shaderEnqueue = copy_src->shaderEnqueue;
+    shaderMeshEnqueue = copy_src->shaderMeshEnqueue;
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
@@ -2373,10 +2377,14 @@ safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX::safe_VkPhysicalDeviceShaderEnq
       maxExecutionGraphShaderOutputNodes(in_struct->maxExecutionGraphShaderOutputNodes),
       maxExecutionGraphShaderPayloadSize(in_struct->maxExecutionGraphShaderPayloadSize),
       maxExecutionGraphShaderPayloadCount(in_struct->maxExecutionGraphShaderPayloadCount),
-      executionGraphDispatchAddressAlignment(in_struct->executionGraphDispatchAddressAlignment) {
+      executionGraphDispatchAddressAlignment(in_struct->executionGraphDispatchAddressAlignment),
+      maxExecutionGraphWorkgroups(in_struct->maxExecutionGraphWorkgroups) {
     if (copy_pnext) {
         pNext = SafePnextCopy(in_struct->pNext, copy_state);
     }
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxExecutionGraphWorkgroupCount[i] = in_struct->maxExecutionGraphWorkgroupCount[i];
+    }
 }
 
 safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX::safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX()
@@ -2386,7 +2394,8 @@ safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX::safe_VkPhysicalDeviceShaderEnq
       maxExecutionGraphShaderOutputNodes(),
       maxExecutionGraphShaderPayloadSize(),
       maxExecutionGraphShaderPayloadCount(),
-      executionGraphDispatchAddressAlignment() {}
+      executionGraphDispatchAddressAlignment(),
+      maxExecutionGraphWorkgroups() {}
 
 safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX::safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX(
     const safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX& copy_src) {
@@ -2396,7 +2405,12 @@ safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX::safe_VkPhysicalDeviceShaderEnq
     maxExecutionGraphShaderPayloadSize = copy_src.maxExecutionGraphShaderPayloadSize;
     maxExecutionGraphShaderPayloadCount = copy_src.maxExecutionGraphShaderPayloadCount;
     executionGraphDispatchAddressAlignment = copy_src.executionGraphDispatchAddressAlignment;
+    maxExecutionGraphWorkgroups = copy_src.maxExecutionGraphWorkgroups;
     pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxExecutionGraphWorkgroupCount[i] = copy_src.maxExecutionGraphWorkgroupCount[i];
+    }
 }
 
 safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX& safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX::operator=(
@@ -2411,8 +2425,13 @@ safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX& safe_VkPhysicalDeviceShaderEnq
     maxExecutionGraphShaderPayloadSize = copy_src.maxExecutionGraphShaderPayloadSize;
     maxExecutionGraphShaderPayloadCount = copy_src.maxExecutionGraphShaderPayloadCount;
     executionGraphDispatchAddressAlignment = copy_src.executionGraphDispatchAddressAlignment;
+    maxExecutionGraphWorkgroups = copy_src.maxExecutionGraphWorkgroups;
     pNext = SafePnextCopy(copy_src.pNext);
 
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxExecutionGraphWorkgroupCount[i] = copy_src.maxExecutionGraphWorkgroupCount[i];
+    }
+
     return *this;
 }
 
@@ -2427,7 +2446,12 @@ void safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX::initialize(const VkPhysic
     maxExecutionGraphShaderPayloadSize = in_struct->maxExecutionGraphShaderPayloadSize;
     maxExecutionGraphShaderPayloadCount = in_struct->maxExecutionGraphShaderPayloadCount;
     executionGraphDispatchAddressAlignment = in_struct->executionGraphDispatchAddressAlignment;
+    maxExecutionGraphWorkgroups = in_struct->maxExecutionGraphWorkgroups;
     pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxExecutionGraphWorkgroupCount[i] = in_struct->maxExecutionGraphWorkgroupCount[i];
+    }
 }
 
 void safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX::initialize(const safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX* copy_src,
@@ -2438,24 +2462,38 @@ void safe_VkPhysicalDeviceShaderEnqueuePropertiesAMDX::initialize(const safe_VkP
     maxExecutionGraphShaderPayloadSize = copy_src->maxExecutionGraphShaderPayloadSize;
     maxExecutionGraphShaderPayloadCount = copy_src->maxExecutionGraphShaderPayloadCount;
     executionGraphDispatchAddressAlignment = copy_src->executionGraphDispatchAddressAlignment;
+    maxExecutionGraphWorkgroups = copy_src->maxExecutionGraphWorkgroups;
     pNext = SafePnextCopy(copy_src->pNext);
+
+    for (uint32_t i = 0; i < 3; ++i) {
+        maxExecutionGraphWorkgroupCount[i] = copy_src->maxExecutionGraphWorkgroupCount[i];
+    }
 }
 
 safe_VkExecutionGraphPipelineScratchSizeAMDX::safe_VkExecutionGraphPipelineScratchSizeAMDX(
     const VkExecutionGraphPipelineScratchSizeAMDX* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), size(in_struct->size) {
+    : sType(in_struct->sType),
+      minSize(in_struct->minSize),
+      maxSize(in_struct->maxSize),
+      sizeGranularity(in_struct->sizeGranularity) {
     if (copy_pnext) {
         pNext = SafePnextCopy(in_struct->pNext, copy_state);
     }
 }
 
 safe_VkExecutionGraphPipelineScratchSizeAMDX::safe_VkExecutionGraphPipelineScratchSizeAMDX()
-    : sType(VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX), pNext(nullptr), size() {}
+    : sType(VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX),
+      pNext(nullptr),
+      minSize(),
+      maxSize(),
+      sizeGranularity() {}
 
 safe_VkExecutionGraphPipelineScratchSizeAMDX::safe_VkExecutionGraphPipelineScratchSizeAMDX(
     const safe_VkExecutionGraphPipelineScratchSizeAMDX& copy_src) {
     sType = copy_src.sType;
-    size = copy_src.size;
+    minSize = copy_src.minSize;
+    maxSize = copy_src.maxSize;
+    sizeGranularity = copy_src.sizeGranularity;
     pNext = SafePnextCopy(copy_src.pNext);
 }
 
@@ -2466,7 +2504,9 @@ safe_VkExecutionGraphPipelineScratchSizeAMDX& safe_VkExecutionGraphPipelineScrat
     FreePnextChain(pNext);
 
     sType = copy_src.sType;
-    size = copy_src.size;
+    minSize = copy_src.minSize;
+    maxSize = copy_src.maxSize;
+    sizeGranularity = copy_src.sizeGranularity;
     pNext = SafePnextCopy(copy_src.pNext);
 
     return *this;
@@ -2478,14 +2518,18 @@ void safe_VkExecutionGraphPipelineScratchSizeAMDX::initialize(const VkExecutionG
                                                               [[maybe_unused]] PNextCopyState* copy_state) {
     FreePnextChain(pNext);
     sType = in_struct->sType;
-    size = in_struct->size;
+    minSize = in_struct->minSize;
+    maxSize = in_struct->maxSize;
+    sizeGranularity = in_struct->sizeGranularity;
     pNext = SafePnextCopy(in_struct->pNext, copy_state);
 }
 
 void safe_VkExecutionGraphPipelineScratchSizeAMDX::initialize(const safe_VkExecutionGraphPipelineScratchSizeAMDX* copy_src,
                                                               [[maybe_unused]] PNextCopyState* copy_state) {
     sType = copy_src->sType;
-    size = copy_src->size;
+    minSize = copy_src->minSize;
+    maxSize = copy_src->maxSize;
+    sizeGranularity = copy_src->sizeGranularity;
     pNext = SafePnextCopy(copy_src->pNext);
 }
 

From b541be2eae6f22772015dc76d215c723693ae028 Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Fri, 18 Oct 2024 08:42:41 -0700
Subject: [PATCH 055/106] build: Update to header 1.3.299

---
 include/vulkan/utility/vk_dispatch_table.h  |   8 +-
 include/vulkan/utility/vk_safe_struct.hpp   | 232 ++++-----
 include/vulkan/utility/vk_struct_helper.hpp |  12 +-
 include/vulkan/vk_enum_string_helper.h      |  32 +-
 scripts/known_good.json                     |   2 +-
 src/vulkan/vk_safe_struct_ext.cpp           | 108 ++---
 src/vulkan/vk_safe_struct_khr.cpp           | 130 ++---
 src/vulkan/vk_safe_struct_utils.cpp         |  60 +--
 src/vulkan/vk_safe_struct_vendor.cpp        | 500 ++++++++++----------
 9 files changed, 542 insertions(+), 542 deletions(-)

diff --git a/include/vulkan/utility/vk_dispatch_table.h b/include/vulkan/utility/vk_dispatch_table.h
index 443591e..96e2faf 100644
--- a/include/vulkan/utility/vk_dispatch_table.h
+++ b/include/vulkan/utility/vk_dispatch_table.h
@@ -445,8 +445,6 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkCmdPipelineBarrier2KHR CmdPipelineBarrier2KHR;
     PFN_vkCmdWriteTimestamp2KHR CmdWriteTimestamp2KHR;
     PFN_vkQueueSubmit2KHR QueueSubmit2KHR;
-    PFN_vkCmdWriteBufferMarker2AMD CmdWriteBufferMarker2AMD;
-    PFN_vkGetQueueCheckpointData2NV GetQueueCheckpointData2NV;
     PFN_vkCmdCopyBuffer2KHR CmdCopyBuffer2KHR;
     PFN_vkCmdCopyImage2KHR CmdCopyImage2KHR;
     PFN_vkCmdCopyBufferToImage2KHR CmdCopyBufferToImage2KHR;
@@ -556,6 +554,7 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkCompileDeferredNV CompileDeferredNV;
     PFN_vkGetMemoryHostPointerPropertiesEXT GetMemoryHostPointerPropertiesEXT;
     PFN_vkCmdWriteBufferMarkerAMD CmdWriteBufferMarkerAMD;
+    PFN_vkCmdWriteBufferMarker2AMD CmdWriteBufferMarker2AMD;
     PFN_vkGetCalibratedTimestampsEXT GetCalibratedTimestampsEXT;
     PFN_vkCmdDrawMeshTasksNV CmdDrawMeshTasksNV;
     PFN_vkCmdDrawMeshTasksIndirectNV CmdDrawMeshTasksIndirectNV;
@@ -564,6 +563,7 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkCmdSetExclusiveScissorNV CmdSetExclusiveScissorNV;
     PFN_vkCmdSetCheckpointNV CmdSetCheckpointNV;
     PFN_vkGetQueueCheckpointDataNV GetQueueCheckpointDataNV;
+    PFN_vkGetQueueCheckpointData2NV GetQueueCheckpointData2NV;
     PFN_vkInitializePerformanceApiINTEL InitializePerformanceApiINTEL;
     PFN_vkUninitializePerformanceApiINTEL UninitializePerformanceApiINTEL;
     PFN_vkCmdSetPerformanceMarkerINTEL CmdSetPerformanceMarkerINTEL;
@@ -1057,8 +1057,6 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
     table->CmdPipelineBarrier2KHR = (PFN_vkCmdPipelineBarrier2KHR)gdpa(device, "vkCmdPipelineBarrier2KHR");
     table->CmdWriteTimestamp2KHR = (PFN_vkCmdWriteTimestamp2KHR)gdpa(device, "vkCmdWriteTimestamp2KHR");
     table->QueueSubmit2KHR = (PFN_vkQueueSubmit2KHR)gdpa(device, "vkQueueSubmit2KHR");
-    table->CmdWriteBufferMarker2AMD = (PFN_vkCmdWriteBufferMarker2AMD)gdpa(device, "vkCmdWriteBufferMarker2AMD");
-    table->GetQueueCheckpointData2NV = (PFN_vkGetQueueCheckpointData2NV)gdpa(device, "vkGetQueueCheckpointData2NV");
     table->CmdCopyBuffer2KHR = (PFN_vkCmdCopyBuffer2KHR)gdpa(device, "vkCmdCopyBuffer2KHR");
     table->CmdCopyImage2KHR = (PFN_vkCmdCopyImage2KHR)gdpa(device, "vkCmdCopyImage2KHR");
     table->CmdCopyBufferToImage2KHR = (PFN_vkCmdCopyBufferToImage2KHR)gdpa(device, "vkCmdCopyBufferToImage2KHR");
@@ -1168,6 +1166,7 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
     table->CompileDeferredNV = (PFN_vkCompileDeferredNV)gdpa(device, "vkCompileDeferredNV");
     table->GetMemoryHostPointerPropertiesEXT = (PFN_vkGetMemoryHostPointerPropertiesEXT)gdpa(device, "vkGetMemoryHostPointerPropertiesEXT");
     table->CmdWriteBufferMarkerAMD = (PFN_vkCmdWriteBufferMarkerAMD)gdpa(device, "vkCmdWriteBufferMarkerAMD");
+    table->CmdWriteBufferMarker2AMD = (PFN_vkCmdWriteBufferMarker2AMD)gdpa(device, "vkCmdWriteBufferMarker2AMD");
     table->GetCalibratedTimestampsEXT = (PFN_vkGetCalibratedTimestampsEXT)gdpa(device, "vkGetCalibratedTimestampsEXT");
     table->CmdDrawMeshTasksNV = (PFN_vkCmdDrawMeshTasksNV)gdpa(device, "vkCmdDrawMeshTasksNV");
     table->CmdDrawMeshTasksIndirectNV = (PFN_vkCmdDrawMeshTasksIndirectNV)gdpa(device, "vkCmdDrawMeshTasksIndirectNV");
@@ -1176,6 +1175,7 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
     table->CmdSetExclusiveScissorNV = (PFN_vkCmdSetExclusiveScissorNV)gdpa(device, "vkCmdSetExclusiveScissorNV");
     table->CmdSetCheckpointNV = (PFN_vkCmdSetCheckpointNV)gdpa(device, "vkCmdSetCheckpointNV");
     table->GetQueueCheckpointDataNV = (PFN_vkGetQueueCheckpointDataNV)gdpa(device, "vkGetQueueCheckpointDataNV");
+    table->GetQueueCheckpointData2NV = (PFN_vkGetQueueCheckpointData2NV)gdpa(device, "vkGetQueueCheckpointData2NV");
     table->InitializePerformanceApiINTEL = (PFN_vkInitializePerformanceApiINTEL)gdpa(device, "vkInitializePerformanceApiINTEL");
     table->UninitializePerformanceApiINTEL = (PFN_vkUninitializePerformanceApiINTEL)gdpa(device, "vkUninitializePerformanceApiINTEL");
     table->CmdSetPerformanceMarkerINTEL = (PFN_vkCmdSetPerformanceMarkerINTEL)gdpa(device, "vkCmdSetPerformanceMarkerINTEL");
diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index a4b0e99..bbf04a0 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -5882,88 +5882,6 @@ struct safe_VkVideoDecodeH264DpbSlotInfoKHR {
     VkVideoDecodeH264DpbSlotInfoKHR* ptr() { return reinterpret_cast<VkVideoDecodeH264DpbSlotInfoKHR*>(this); }
     VkVideoDecodeH264DpbSlotInfoKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeH264DpbSlotInfoKHR const*>(this); }
 };
-struct safe_VkRenderingFragmentShadingRateAttachmentInfoKHR {
-    VkStructureType sType;
-    const void* pNext{};
-    VkImageView imageView;
-    VkImageLayout imageLayout;
-    VkExtent2D shadingRateAttachmentTexelSize;
-
-    safe_VkRenderingFragmentShadingRateAttachmentInfoKHR(const VkRenderingFragmentShadingRateAttachmentInfoKHR* in_struct,
-                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkRenderingFragmentShadingRateAttachmentInfoKHR(const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& copy_src);
-    safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& operator=(
-        const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& copy_src);
-    safe_VkRenderingFragmentShadingRateAttachmentInfoKHR();
-    ~safe_VkRenderingFragmentShadingRateAttachmentInfoKHR();
-    void initialize(const VkRenderingFragmentShadingRateAttachmentInfoKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR* copy_src, PNextCopyState* copy_state = {});
-    VkRenderingFragmentShadingRateAttachmentInfoKHR* ptr() {
-        return reinterpret_cast<VkRenderingFragmentShadingRateAttachmentInfoKHR*>(this);
-    }
-    VkRenderingFragmentShadingRateAttachmentInfoKHR const* ptr() const {
-        return reinterpret_cast<VkRenderingFragmentShadingRateAttachmentInfoKHR const*>(this);
-    }
-};
-struct safe_VkRenderingFragmentDensityMapAttachmentInfoEXT {
-    VkStructureType sType;
-    const void* pNext{};
-    VkImageView imageView;
-    VkImageLayout imageLayout;
-
-    safe_VkRenderingFragmentDensityMapAttachmentInfoEXT(const VkRenderingFragmentDensityMapAttachmentInfoEXT* in_struct,
-                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkRenderingFragmentDensityMapAttachmentInfoEXT(const safe_VkRenderingFragmentDensityMapAttachmentInfoEXT& copy_src);
-    safe_VkRenderingFragmentDensityMapAttachmentInfoEXT& operator=(
-        const safe_VkRenderingFragmentDensityMapAttachmentInfoEXT& copy_src);
-    safe_VkRenderingFragmentDensityMapAttachmentInfoEXT();
-    ~safe_VkRenderingFragmentDensityMapAttachmentInfoEXT();
-    void initialize(const VkRenderingFragmentDensityMapAttachmentInfoEXT* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkRenderingFragmentDensityMapAttachmentInfoEXT* copy_src, PNextCopyState* copy_state = {});
-    VkRenderingFragmentDensityMapAttachmentInfoEXT* ptr() {
-        return reinterpret_cast<VkRenderingFragmentDensityMapAttachmentInfoEXT*>(this);
-    }
-    VkRenderingFragmentDensityMapAttachmentInfoEXT const* ptr() const {
-        return reinterpret_cast<VkRenderingFragmentDensityMapAttachmentInfoEXT const*>(this);
-    }
-};
-struct safe_VkAttachmentSampleCountInfoAMD {
-    VkStructureType sType;
-    const void* pNext{};
-    uint32_t colorAttachmentCount;
-    const VkSampleCountFlagBits* pColorAttachmentSamples{};
-    VkSampleCountFlagBits depthStencilAttachmentSamples;
-
-    safe_VkAttachmentSampleCountInfoAMD(const VkAttachmentSampleCountInfoAMD* in_struct, PNextCopyState* copy_state = {},
-                                        bool copy_pnext = true);
-    safe_VkAttachmentSampleCountInfoAMD(const safe_VkAttachmentSampleCountInfoAMD& copy_src);
-    safe_VkAttachmentSampleCountInfoAMD& operator=(const safe_VkAttachmentSampleCountInfoAMD& copy_src);
-    safe_VkAttachmentSampleCountInfoAMD();
-    ~safe_VkAttachmentSampleCountInfoAMD();
-    void initialize(const VkAttachmentSampleCountInfoAMD* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkAttachmentSampleCountInfoAMD* copy_src, PNextCopyState* copy_state = {});
-    VkAttachmentSampleCountInfoAMD* ptr() { return reinterpret_cast<VkAttachmentSampleCountInfoAMD*>(this); }
-    VkAttachmentSampleCountInfoAMD const* ptr() const { return reinterpret_cast<VkAttachmentSampleCountInfoAMD const*>(this); }
-};
-struct safe_VkMultiviewPerViewAttributesInfoNVX {
-    VkStructureType sType;
-    const void* pNext{};
-    VkBool32 perViewAttributes;
-    VkBool32 perViewAttributesPositionXOnly;
-
-    safe_VkMultiviewPerViewAttributesInfoNVX(const VkMultiviewPerViewAttributesInfoNVX* in_struct, PNextCopyState* copy_state = {},
-                                             bool copy_pnext = true);
-    safe_VkMultiviewPerViewAttributesInfoNVX(const safe_VkMultiviewPerViewAttributesInfoNVX& copy_src);
-    safe_VkMultiviewPerViewAttributesInfoNVX& operator=(const safe_VkMultiviewPerViewAttributesInfoNVX& copy_src);
-    safe_VkMultiviewPerViewAttributesInfoNVX();
-    ~safe_VkMultiviewPerViewAttributesInfoNVX();
-    void initialize(const VkMultiviewPerViewAttributesInfoNVX* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkMultiviewPerViewAttributesInfoNVX* copy_src, PNextCopyState* copy_state = {});
-    VkMultiviewPerViewAttributesInfoNVX* ptr() { return reinterpret_cast<VkMultiviewPerViewAttributesInfoNVX*>(this); }
-    VkMultiviewPerViewAttributesInfoNVX const* ptr() const {
-        return reinterpret_cast<VkMultiviewPerViewAttributesInfoNVX const*>(this);
-    }
-};
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 struct safe_VkImportMemoryWin32HandleInfoKHR {
     VkStructureType sType;
@@ -7009,6 +6927,29 @@ struct safe_VkPhysicalDeviceFragmentShadingRateKHR {
         return reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR const*>(this);
     }
 };
+struct safe_VkRenderingFragmentShadingRateAttachmentInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageView imageView;
+    VkImageLayout imageLayout;
+    VkExtent2D shadingRateAttachmentTexelSize;
+
+    safe_VkRenderingFragmentShadingRateAttachmentInfoKHR(const VkRenderingFragmentShadingRateAttachmentInfoKHR* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkRenderingFragmentShadingRateAttachmentInfoKHR(const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& copy_src);
+    safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& operator=(
+        const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& copy_src);
+    safe_VkRenderingFragmentShadingRateAttachmentInfoKHR();
+    ~safe_VkRenderingFragmentShadingRateAttachmentInfoKHR();
+    void initialize(const VkRenderingFragmentShadingRateAttachmentInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkRenderingFragmentShadingRateAttachmentInfoKHR* ptr() {
+        return reinterpret_cast<VkRenderingFragmentShadingRateAttachmentInfoKHR*>(this);
+    }
+    VkRenderingFragmentShadingRateAttachmentInfoKHR const* ptr() const {
+        return reinterpret_cast<VkRenderingFragmentShadingRateAttachmentInfoKHR const*>(this);
+    }
+};
 struct safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR {
     VkStructureType sType;
     void* pNext{};
@@ -7553,40 +7494,6 @@ struct safe_VkVideoEncodeSessionParametersFeedbackInfoKHR {
         return reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR const*>(this);
     }
 };
-struct safe_VkQueueFamilyCheckpointProperties2NV {
-    VkStructureType sType;
-    void* pNext{};
-    VkPipelineStageFlags2 checkpointExecutionStageMask;
-
-    safe_VkQueueFamilyCheckpointProperties2NV(const VkQueueFamilyCheckpointProperties2NV* in_struct,
-                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkQueueFamilyCheckpointProperties2NV(const safe_VkQueueFamilyCheckpointProperties2NV& copy_src);
-    safe_VkQueueFamilyCheckpointProperties2NV& operator=(const safe_VkQueueFamilyCheckpointProperties2NV& copy_src);
-    safe_VkQueueFamilyCheckpointProperties2NV();
-    ~safe_VkQueueFamilyCheckpointProperties2NV();
-    void initialize(const VkQueueFamilyCheckpointProperties2NV* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkQueueFamilyCheckpointProperties2NV* copy_src, PNextCopyState* copy_state = {});
-    VkQueueFamilyCheckpointProperties2NV* ptr() { return reinterpret_cast<VkQueueFamilyCheckpointProperties2NV*>(this); }
-    VkQueueFamilyCheckpointProperties2NV const* ptr() const {
-        return reinterpret_cast<VkQueueFamilyCheckpointProperties2NV const*>(this);
-    }
-};
-struct safe_VkCheckpointData2NV {
-    VkStructureType sType;
-    void* pNext{};
-    VkPipelineStageFlags2 stage;
-    void* pCheckpointMarker{};
-
-    safe_VkCheckpointData2NV(const VkCheckpointData2NV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkCheckpointData2NV(const safe_VkCheckpointData2NV& copy_src);
-    safe_VkCheckpointData2NV& operator=(const safe_VkCheckpointData2NV& copy_src);
-    safe_VkCheckpointData2NV();
-    ~safe_VkCheckpointData2NV();
-    void initialize(const VkCheckpointData2NV* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkCheckpointData2NV* copy_src, PNextCopyState* copy_state = {});
-    VkCheckpointData2NV* ptr() { return reinterpret_cast<VkCheckpointData2NV*>(this); }
-    VkCheckpointData2NV const* ptr() const { return reinterpret_cast<VkCheckpointData2NV const*>(this); }
-};
 struct safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR {
     VkStructureType sType;
     void* pNext{};
@@ -9703,6 +9610,25 @@ struct safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
         return reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const*>(this);
     }
 };
+struct safe_VkMultiviewPerViewAttributesInfoNVX {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 perViewAttributes;
+    VkBool32 perViewAttributesPositionXOnly;
+
+    safe_VkMultiviewPerViewAttributesInfoNVX(const VkMultiviewPerViewAttributesInfoNVX* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkMultiviewPerViewAttributesInfoNVX(const safe_VkMultiviewPerViewAttributesInfoNVX& copy_src);
+    safe_VkMultiviewPerViewAttributesInfoNVX& operator=(const safe_VkMultiviewPerViewAttributesInfoNVX& copy_src);
+    safe_VkMultiviewPerViewAttributesInfoNVX();
+    ~safe_VkMultiviewPerViewAttributesInfoNVX();
+    void initialize(const VkMultiviewPerViewAttributesInfoNVX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMultiviewPerViewAttributesInfoNVX* copy_src, PNextCopyState* copy_state = {});
+    VkMultiviewPerViewAttributesInfoNVX* ptr() { return reinterpret_cast<VkMultiviewPerViewAttributesInfoNVX*>(this); }
+    VkMultiviewPerViewAttributesInfoNVX const* ptr() const {
+        return reinterpret_cast<VkMultiviewPerViewAttributesInfoNVX const*>(this);
+    }
+};
 struct safe_VkPipelineViewportSwizzleStateCreateInfoNV {
     VkStructureType sType;
     const void* pNext{};
@@ -10287,6 +10213,24 @@ struct safe_VkPipelineShaderStageNodeCreateInfoAMDX {
     }
 };
 #endif  // VK_ENABLE_BETA_EXTENSIONS
+struct safe_VkAttachmentSampleCountInfoAMD {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t colorAttachmentCount;
+    const VkSampleCountFlagBits* pColorAttachmentSamples{};
+    VkSampleCountFlagBits depthStencilAttachmentSamples;
+
+    safe_VkAttachmentSampleCountInfoAMD(const VkAttachmentSampleCountInfoAMD* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkAttachmentSampleCountInfoAMD(const safe_VkAttachmentSampleCountInfoAMD& copy_src);
+    safe_VkAttachmentSampleCountInfoAMD& operator=(const safe_VkAttachmentSampleCountInfoAMD& copy_src);
+    safe_VkAttachmentSampleCountInfoAMD();
+    ~safe_VkAttachmentSampleCountInfoAMD();
+    void initialize(const VkAttachmentSampleCountInfoAMD* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAttachmentSampleCountInfoAMD* copy_src, PNextCopyState* copy_state = {});
+    VkAttachmentSampleCountInfoAMD* ptr() { return reinterpret_cast<VkAttachmentSampleCountInfoAMD*>(this); }
+    VkAttachmentSampleCountInfoAMD const* ptr() const { return reinterpret_cast<VkAttachmentSampleCountInfoAMD const*>(this); }
+};
 struct safe_VkSampleLocationsInfoEXT {
     VkStructureType sType;
     const void* pNext{};
@@ -11485,6 +11429,40 @@ struct safe_VkCheckpointDataNV {
     VkCheckpointDataNV* ptr() { return reinterpret_cast<VkCheckpointDataNV*>(this); }
     VkCheckpointDataNV const* ptr() const { return reinterpret_cast<VkCheckpointDataNV const*>(this); }
 };
+struct safe_VkQueueFamilyCheckpointProperties2NV {
+    VkStructureType sType;
+    void* pNext{};
+    VkPipelineStageFlags2 checkpointExecutionStageMask;
+
+    safe_VkQueueFamilyCheckpointProperties2NV(const VkQueueFamilyCheckpointProperties2NV* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkQueueFamilyCheckpointProperties2NV(const safe_VkQueueFamilyCheckpointProperties2NV& copy_src);
+    safe_VkQueueFamilyCheckpointProperties2NV& operator=(const safe_VkQueueFamilyCheckpointProperties2NV& copy_src);
+    safe_VkQueueFamilyCheckpointProperties2NV();
+    ~safe_VkQueueFamilyCheckpointProperties2NV();
+    void initialize(const VkQueueFamilyCheckpointProperties2NV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkQueueFamilyCheckpointProperties2NV* copy_src, PNextCopyState* copy_state = {});
+    VkQueueFamilyCheckpointProperties2NV* ptr() { return reinterpret_cast<VkQueueFamilyCheckpointProperties2NV*>(this); }
+    VkQueueFamilyCheckpointProperties2NV const* ptr() const {
+        return reinterpret_cast<VkQueueFamilyCheckpointProperties2NV const*>(this);
+    }
+};
+struct safe_VkCheckpointData2NV {
+    VkStructureType sType;
+    void* pNext{};
+    VkPipelineStageFlags2 stage;
+    void* pCheckpointMarker{};
+
+    safe_VkCheckpointData2NV(const VkCheckpointData2NV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkCheckpointData2NV(const safe_VkCheckpointData2NV& copy_src);
+    safe_VkCheckpointData2NV& operator=(const safe_VkCheckpointData2NV& copy_src);
+    safe_VkCheckpointData2NV();
+    ~safe_VkCheckpointData2NV();
+    void initialize(const VkCheckpointData2NV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCheckpointData2NV* copy_src, PNextCopyState* copy_state = {});
+    VkCheckpointData2NV* ptr() { return reinterpret_cast<VkCheckpointData2NV*>(this); }
+    VkCheckpointData2NV const* ptr() const { return reinterpret_cast<VkCheckpointData2NV const*>(this); }
+};
 struct safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
     VkStructureType sType;
     void* pNext{};
@@ -11778,6 +11756,28 @@ struct safe_VkRenderPassFragmentDensityMapCreateInfoEXT {
         return reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT const*>(this);
     }
 };
+struct safe_VkRenderingFragmentDensityMapAttachmentInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageView imageView;
+    VkImageLayout imageLayout;
+
+    safe_VkRenderingFragmentDensityMapAttachmentInfoEXT(const VkRenderingFragmentDensityMapAttachmentInfoEXT* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkRenderingFragmentDensityMapAttachmentInfoEXT(const safe_VkRenderingFragmentDensityMapAttachmentInfoEXT& copy_src);
+    safe_VkRenderingFragmentDensityMapAttachmentInfoEXT& operator=(
+        const safe_VkRenderingFragmentDensityMapAttachmentInfoEXT& copy_src);
+    safe_VkRenderingFragmentDensityMapAttachmentInfoEXT();
+    ~safe_VkRenderingFragmentDensityMapAttachmentInfoEXT();
+    void initialize(const VkRenderingFragmentDensityMapAttachmentInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderingFragmentDensityMapAttachmentInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkRenderingFragmentDensityMapAttachmentInfoEXT* ptr() {
+        return reinterpret_cast<VkRenderingFragmentDensityMapAttachmentInfoEXT*>(this);
+    }
+    VkRenderingFragmentDensityMapAttachmentInfoEXT const* ptr() const {
+        return reinterpret_cast<VkRenderingFragmentDensityMapAttachmentInfoEXT const*>(this);
+    }
+};
 struct safe_VkPhysicalDeviceShaderCoreProperties2AMD {
     VkStructureType sType;
     void* pNext{};
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index 26efcc0..d3c9266 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -312,10 +312,6 @@ template <> inline VkStructureType GetSType<VkVideoDecodeH264SessionParametersAd
 template <> inline VkStructureType GetSType<VkVideoDecodeH264SessionParametersCreateInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkVideoDecodeH264PictureInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkVideoDecodeH264DpbSlotInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkRenderingFragmentShadingRateAttachmentInfoKHR>() { return VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkRenderingFragmentDensityMapAttachmentInfoEXT>() { return VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT; }
-template <> inline VkStructureType GetSType<VkAttachmentSampleCountInfoAMD>() { return VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD; }
-template <> inline VkStructureType GetSType<VkMultiviewPerViewAttributesInfoNVX>() { return VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX; }
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 template <> inline VkStructureType GetSType<VkImportMemoryWin32HandleInfoKHR>() { return VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkExportMemoryWin32HandleInfoKHR>() { return VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR; }
@@ -378,6 +374,7 @@ template <> inline VkStructureType GetSType<VkPipelineFragmentShadingRateStateCr
 template <> inline VkStructureType GetSType<VkPhysicalDeviceFragmentShadingRateFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceFragmentShadingRatePropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceFragmentShadingRateKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR; }
+template <> inline VkStructureType GetSType<VkRenderingFragmentShadingRateAttachmentInfoKHR>() { return VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkRenderingAttachmentLocationInfoKHR>() { return VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkRenderingInputAttachmentIndexInfoKHR>() { return VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR; }
@@ -406,8 +403,6 @@ template <> inline VkStructureType GetSType<VkVideoEncodeQualityLevelPropertiesK
 template <> inline VkStructureType GetSType<VkVideoEncodeQualityLevelInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkVideoEncodeSessionParametersGetInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkVideoEncodeSessionParametersFeedbackInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkQueueFamilyCheckpointProperties2NV>() { return VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV; }
-template <> inline VkStructureType GetSType<VkCheckpointData2NV>() { return VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR; }
@@ -519,6 +514,7 @@ template <> inline VkStructureType GetSType<VkDisplayEventInfoEXT>() { return VK
 template <> inline VkStructureType GetSType<VkSwapchainCounterCreateInfoEXT>() { return VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkPresentTimesInfoGOOGLE>() { return VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX; }
+template <> inline VkStructureType GetSType<VkMultiviewPerViewAttributesInfoNVX>() { return VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX; }
 template <> inline VkStructureType GetSType<VkPipelineViewportSwizzleStateCreateInfoNV>() { return VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceDiscardRectanglePropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT; }
 template <> inline VkStructureType GetSType<VkPipelineDiscardRectangleStateCreateInfoEXT>() { return VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT; }
@@ -555,6 +551,7 @@ template <> inline VkStructureType GetSType<VkExecutionGraphPipelineScratchSizeA
 template <> inline VkStructureType GetSType<VkExecutionGraphPipelineCreateInfoAMDX>() { return VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX; }
 template <> inline VkStructureType GetSType<VkPipelineShaderStageNodeCreateInfoAMDX>() { return VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX; }
 #endif  // VK_ENABLE_BETA_EXTENSIONS
+template <> inline VkStructureType GetSType<VkAttachmentSampleCountInfoAMD>() { return VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD; }
 template <> inline VkStructureType GetSType<VkSampleLocationsInfoEXT>() { return VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkRenderPassSampleLocationsBeginInfoEXT>() { return VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkPipelineSampleLocationsStateCreateInfoEXT>() { return VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT; }
@@ -611,6 +608,8 @@ template <> inline VkStructureType GetSType<VkPipelineViewportExclusiveScissorSt
 template <> inline VkStructureType GetSType<VkPhysicalDeviceExclusiveScissorFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkQueueFamilyCheckpointPropertiesNV>() { return VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV; }
 template <> inline VkStructureType GetSType<VkCheckpointDataNV>() { return VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV; }
+template <> inline VkStructureType GetSType<VkQueueFamilyCheckpointProperties2NV>() { return VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV; }
+template <> inline VkStructureType GetSType<VkCheckpointData2NV>() { return VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL; }
 template <> inline VkStructureType GetSType<VkInitializePerformanceApiInfoINTEL>() { return VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL; }
 template <> inline VkStructureType GetSType<VkQueryPoolPerformanceQueryCreateInfoINTEL>() { return VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL; }
@@ -630,6 +629,7 @@ template <> inline VkStructureType GetSType<VkMetalSurfaceCreateInfoEXT>() { ret
 template <> inline VkStructureType GetSType<VkPhysicalDeviceFragmentDensityMapFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceFragmentDensityMapPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT; }
 template <> inline VkStructureType GetSType<VkRenderPassFragmentDensityMapCreateInfoEXT>() { return VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT; }
+template <> inline VkStructureType GetSType<VkRenderingFragmentDensityMapAttachmentInfoEXT>() { return VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderCoreProperties2AMD>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCoherentMemoryFeaturesAMD>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index 9ff6e79..457bb03 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -726,14 +726,6 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR";
         case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
             return "VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD";
-        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
-            return "VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR";
-        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
-            return "VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT";
-        case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
-            return "VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD";
-        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
-            return "VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX";
         case VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP:
             return "VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
@@ -816,6 +808,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX";
+        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
+            return "VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX";
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
             return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
@@ -916,6 +910,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX:
             return "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX";
 #endif  // VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
+            return "VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD";
         case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
             return "VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT";
         case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
@@ -1092,6 +1088,10 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV";
         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
             return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV";
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
+            return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV";
+        case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV:
+            return "VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL";
         case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
@@ -1122,6 +1122,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT";
         case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
             return "VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT";
+        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
+            return "VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT";
         case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
             return "VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR";
         case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
@@ -1132,6 +1134,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR";
+        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
@@ -1382,10 +1386,6 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT";
         case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT:
             return "VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT";
-        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
-            return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV";
-        case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV:
-            return "VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT:
@@ -6019,10 +6019,6 @@ static inline const char* string_VkPipelineCreateFlagBits(VkPipelineCreateFlagBi
             return "VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT";
         case VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT:
             return "VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT";
-        case VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR:
-            return "VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR";
-        case VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT:
-            return "VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT";
         case VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR:
             return "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR";
         case VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR:
@@ -6039,6 +6035,10 @@ static inline const char* string_VkPipelineCreateFlagBits(VkPipelineCreateFlagBi
             return "VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR";
         case VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV:
             return "VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV";
+        case VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT:
+            return "VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT";
+        case VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR:
+            return "VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR";
         case VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR:
             return "VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR";
         case VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR:
diff --git a/scripts/known_good.json b/scripts/known_good.json
index a36bba4..536f291 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.3.298"
+            "commit": "v1.3.299"
         },
         {
             "name": "googletest",
diff --git a/src/vulkan/vk_safe_struct_ext.cpp b/src/vulkan/vk_safe_struct_ext.cpp
index 26feba8..52d2613 100644
--- a/src/vulkan/vk_safe_struct_ext.cpp
+++ b/src/vulkan/vk_safe_struct_ext.cpp
@@ -21,60 +21,6 @@
 
 namespace vku {
 
-safe_VkRenderingFragmentDensityMapAttachmentInfoEXT::safe_VkRenderingFragmentDensityMapAttachmentInfoEXT(
-    const VkRenderingFragmentDensityMapAttachmentInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), imageView(in_struct->imageView), imageLayout(in_struct->imageLayout) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkRenderingFragmentDensityMapAttachmentInfoEXT::safe_VkRenderingFragmentDensityMapAttachmentInfoEXT()
-    : sType(VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT), pNext(nullptr), imageView(), imageLayout() {}
-
-safe_VkRenderingFragmentDensityMapAttachmentInfoEXT::safe_VkRenderingFragmentDensityMapAttachmentInfoEXT(
-    const safe_VkRenderingFragmentDensityMapAttachmentInfoEXT& copy_src) {
-    sType = copy_src.sType;
-    imageView = copy_src.imageView;
-    imageLayout = copy_src.imageLayout;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkRenderingFragmentDensityMapAttachmentInfoEXT& safe_VkRenderingFragmentDensityMapAttachmentInfoEXT::operator=(
-    const safe_VkRenderingFragmentDensityMapAttachmentInfoEXT& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    imageView = copy_src.imageView;
-    imageLayout = copy_src.imageLayout;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkRenderingFragmentDensityMapAttachmentInfoEXT::~safe_VkRenderingFragmentDensityMapAttachmentInfoEXT() {
-    FreePnextChain(pNext);
-}
-
-void safe_VkRenderingFragmentDensityMapAttachmentInfoEXT::initialize(
-    const VkRenderingFragmentDensityMapAttachmentInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    imageView = in_struct->imageView;
-    imageLayout = in_struct->imageLayout;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkRenderingFragmentDensityMapAttachmentInfoEXT::initialize(
-    const safe_VkRenderingFragmentDensityMapAttachmentInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    imageView = copy_src->imageView;
-    imageLayout = copy_src->imageLayout;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
 safe_VkSetDescriptorBufferOffsetsInfoEXT::safe_VkSetDescriptorBufferOffsetsInfoEXT(
     const VkSetDescriptorBufferOffsetsInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType),
@@ -4472,6 +4418,60 @@ void safe_VkRenderPassFragmentDensityMapCreateInfoEXT::initialize(const safe_VkR
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkRenderingFragmentDensityMapAttachmentInfoEXT::safe_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+    const VkRenderingFragmentDensityMapAttachmentInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), imageView(in_struct->imageView), imageLayout(in_struct->imageLayout) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkRenderingFragmentDensityMapAttachmentInfoEXT::safe_VkRenderingFragmentDensityMapAttachmentInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT), pNext(nullptr), imageView(), imageLayout() {}
+
+safe_VkRenderingFragmentDensityMapAttachmentInfoEXT::safe_VkRenderingFragmentDensityMapAttachmentInfoEXT(
+    const safe_VkRenderingFragmentDensityMapAttachmentInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    imageView = copy_src.imageView;
+    imageLayout = copy_src.imageLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkRenderingFragmentDensityMapAttachmentInfoEXT& safe_VkRenderingFragmentDensityMapAttachmentInfoEXT::operator=(
+    const safe_VkRenderingFragmentDensityMapAttachmentInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    imageView = copy_src.imageView;
+    imageLayout = copy_src.imageLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkRenderingFragmentDensityMapAttachmentInfoEXT::~safe_VkRenderingFragmentDensityMapAttachmentInfoEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkRenderingFragmentDensityMapAttachmentInfoEXT::initialize(
+    const VkRenderingFragmentDensityMapAttachmentInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    imageView = in_struct->imageView;
+    imageLayout = in_struct->imageLayout;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkRenderingFragmentDensityMapAttachmentInfoEXT::initialize(
+    const safe_VkRenderingFragmentDensityMapAttachmentInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imageView = copy_src->imageView;
+    imageLayout = copy_src->imageLayout;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT::safe_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
     const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
     bool copy_pnext)
diff --git a/src/vulkan/vk_safe_struct_khr.cpp b/src/vulkan/vk_safe_struct_khr.cpp
index 7ece3b2..994a7af 100644
--- a/src/vulkan/vk_safe_struct_khr.cpp
+++ b/src/vulkan/vk_safe_struct_khr.cpp
@@ -5304,71 +5304,6 @@ void safe_VkVideoDecodeH264DpbSlotInfoKHR::initialize(const safe_VkVideoDecodeH2
         pStdReferenceInfo = new StdVideoDecodeH264ReferenceInfo(*copy_src->pStdReferenceInfo);
     }
 }
-
-safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::safe_VkRenderingFragmentShadingRateAttachmentInfoKHR(
-    const VkRenderingFragmentShadingRateAttachmentInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType),
-      imageView(in_struct->imageView),
-      imageLayout(in_struct->imageLayout),
-      shadingRateAttachmentTexelSize(in_struct->shadingRateAttachmentTexelSize) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::safe_VkRenderingFragmentShadingRateAttachmentInfoKHR()
-    : sType(VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR),
-      pNext(nullptr),
-      imageView(),
-      imageLayout(),
-      shadingRateAttachmentTexelSize() {}
-
-safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::safe_VkRenderingFragmentShadingRateAttachmentInfoKHR(
-    const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& copy_src) {
-    sType = copy_src.sType;
-    imageView = copy_src.imageView;
-    imageLayout = copy_src.imageLayout;
-    shadingRateAttachmentTexelSize = copy_src.shadingRateAttachmentTexelSize;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::operator=(
-    const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    imageView = copy_src.imageView;
-    imageLayout = copy_src.imageLayout;
-    shadingRateAttachmentTexelSize = copy_src.shadingRateAttachmentTexelSize;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::~safe_VkRenderingFragmentShadingRateAttachmentInfoKHR() {
-    FreePnextChain(pNext);
-}
-
-void safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::initialize(
-    const VkRenderingFragmentShadingRateAttachmentInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    imageView = in_struct->imageView;
-    imageLayout = in_struct->imageLayout;
-    shadingRateAttachmentTexelSize = in_struct->shadingRateAttachmentTexelSize;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::initialize(
-    const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    imageView = copy_src->imageView;
-    imageLayout = copy_src->imageLayout;
-    shadingRateAttachmentTexelSize = copy_src->shadingRateAttachmentTexelSize;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 
 safe_VkImportMemoryWin32HandleInfoKHR::safe_VkImportMemoryWin32HandleInfoKHR(const VkImportMemoryWin32HandleInfoKHR* in_struct,
@@ -9207,6 +9142,71 @@ void safe_VkPhysicalDeviceFragmentShadingRateKHR::initialize(const safe_VkPhysic
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::safe_VkRenderingFragmentShadingRateAttachmentInfoKHR(
+    const VkRenderingFragmentShadingRateAttachmentInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      imageView(in_struct->imageView),
+      imageLayout(in_struct->imageLayout),
+      shadingRateAttachmentTexelSize(in_struct->shadingRateAttachmentTexelSize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::safe_VkRenderingFragmentShadingRateAttachmentInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR),
+      pNext(nullptr),
+      imageView(),
+      imageLayout(),
+      shadingRateAttachmentTexelSize() {}
+
+safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::safe_VkRenderingFragmentShadingRateAttachmentInfoKHR(
+    const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    imageView = copy_src.imageView;
+    imageLayout = copy_src.imageLayout;
+    shadingRateAttachmentTexelSize = copy_src.shadingRateAttachmentTexelSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::operator=(
+    const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    imageView = copy_src.imageView;
+    imageLayout = copy_src.imageLayout;
+    shadingRateAttachmentTexelSize = copy_src.shadingRateAttachmentTexelSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::~safe_VkRenderingFragmentShadingRateAttachmentInfoKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::initialize(
+    const VkRenderingFragmentShadingRateAttachmentInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    imageView = in_struct->imageView;
+    imageLayout = in_struct->imageLayout;
+    shadingRateAttachmentTexelSize = in_struct->shadingRateAttachmentTexelSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::initialize(
+    const safe_VkRenderingFragmentShadingRateAttachmentInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imageView = copy_src->imageView;
+    imageLayout = copy_src->imageLayout;
+    shadingRateAttachmentTexelSize = copy_src->shadingRateAttachmentTexelSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR(
     const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
     bool copy_pnext)
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index dd0b2b2..d8750d8 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -516,18 +516,6 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR:
                 safe_pNext = new safe_VkVideoDecodeH264DpbSlotInfoKHR(reinterpret_cast<const VkVideoDecodeH264DpbSlotInfoKHR *>(pNext), copy_state, false);
                 break;
-            case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
-                safe_pNext = new safe_VkRenderingFragmentShadingRateAttachmentInfoKHR(reinterpret_cast<const VkRenderingFragmentShadingRateAttachmentInfoKHR *>(pNext), copy_state, false);
-                break;
-            case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
-                safe_pNext = new safe_VkRenderingFragmentDensityMapAttachmentInfoEXT(reinterpret_cast<const VkRenderingFragmentDensityMapAttachmentInfoEXT *>(pNext), copy_state, false);
-                break;
-            case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
-                safe_pNext = new safe_VkAttachmentSampleCountInfoAMD(reinterpret_cast<const VkAttachmentSampleCountInfoAMD *>(pNext), copy_state, false);
-                break;
-            case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
-                safe_pNext = new safe_VkMultiviewPerViewAttributesInfoNVX(reinterpret_cast<const VkMultiviewPerViewAttributesInfoNVX *>(pNext), copy_state, false);
-                break;
 #ifdef VK_USE_PLATFORM_WIN32_KHR
             case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
                 safe_pNext = new safe_VkImportMemoryWin32HandleInfoKHR(reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR *>(pNext), copy_state, false);
@@ -626,6 +614,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
                 safe_pNext = new safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(reinterpret_cast<const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
+                safe_pNext = new safe_VkRenderingFragmentShadingRateAttachmentInfoKHR(reinterpret_cast<const VkRenderingFragmentShadingRateAttachmentInfoKHR *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR:
                 safe_pNext = new safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR *>(pNext), copy_state, false);
                 break;
@@ -671,9 +662,6 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR:
                 safe_pNext = new safe_VkVideoEncodeQualityLevelInfoKHR(reinterpret_cast<const VkVideoEncodeQualityLevelInfoKHR *>(pNext), copy_state, false);
                 break;
-            case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
-                safe_pNext = new safe_VkQueueFamilyCheckpointProperties2NV(reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV *>(pNext), copy_state, false);
-                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
                 safe_pNext = new safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *>(pNext), copy_state, false);
                 break;
@@ -889,6 +877,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
                 safe_pNext = new safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
+                safe_pNext = new safe_VkMultiviewPerViewAttributesInfoNVX(reinterpret_cast<const VkMultiviewPerViewAttributesInfoNVX *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
                 safe_pNext = new safe_VkPipelineViewportSwizzleStateCreateInfoNV(reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV *>(pNext), copy_state, false);
                 break;
@@ -950,6 +941,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
                 safe_pNext = new safe_VkPipelineShaderStageNodeCreateInfoAMDX(reinterpret_cast<const VkPipelineShaderStageNodeCreateInfoAMDX *>(pNext), copy_state, false);
                 break;
 #endif  // VK_ENABLE_BETA_EXTENSIONS
+            case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
+                safe_pNext = new safe_VkAttachmentSampleCountInfoAMD(reinterpret_cast<const VkAttachmentSampleCountInfoAMD *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
                 safe_pNext = new safe_VkSampleLocationsInfoEXT(reinterpret_cast<const VkSampleLocationsInfoEXT *>(pNext), copy_state, false);
                 break;
@@ -1072,6 +1066,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
                 safe_pNext = new safe_VkQueueFamilyCheckpointPropertiesNV(reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
+                safe_pNext = new safe_VkQueueFamilyCheckpointProperties2NV(reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
                 safe_pNext = new safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *>(pNext), copy_state, false);
                 break;
@@ -1096,6 +1093,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
                 safe_pNext = new safe_VkRenderPassFragmentDensityMapCreateInfoEXT(reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
+                safe_pNext = new safe_VkRenderingFragmentDensityMapAttachmentInfoEXT(reinterpret_cast<const VkRenderingFragmentDensityMapAttachmentInfoEXT *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
                 safe_pNext = new safe_VkPhysicalDeviceShaderCoreProperties2AMD(reinterpret_cast<const VkPhysicalDeviceShaderCoreProperties2AMD *>(pNext), copy_state, false);
                 break;
@@ -2402,18 +2402,6 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR:
             delete reinterpret_cast<safe_VkVideoDecodeH264DpbSlotInfoKHR *>(header);
             break;
-        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
-            delete reinterpret_cast<safe_VkRenderingFragmentShadingRateAttachmentInfoKHR *>(header);
-            break;
-        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
-            delete reinterpret_cast<safe_VkRenderingFragmentDensityMapAttachmentInfoEXT *>(header);
-            break;
-        case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
-            delete reinterpret_cast<safe_VkAttachmentSampleCountInfoAMD *>(header);
-            break;
-        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
-            delete reinterpret_cast<safe_VkMultiviewPerViewAttributesInfoNVX *>(header);
-            break;
 #ifdef VK_USE_PLATFORM_WIN32_KHR
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
             delete reinterpret_cast<safe_VkImportMemoryWin32HandleInfoKHR *>(header);
@@ -2512,6 +2500,9 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
             delete reinterpret_cast<safe_VkPhysicalDeviceFragmentShadingRatePropertiesKHR *>(header);
             break;
+        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
+            delete reinterpret_cast<safe_VkRenderingFragmentShadingRateAttachmentInfoKHR *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR:
             delete reinterpret_cast<safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR *>(header);
             break;
@@ -2557,9 +2548,6 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR:
             delete reinterpret_cast<safe_VkVideoEncodeQualityLevelInfoKHR *>(header);
             break;
-        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
-            delete reinterpret_cast<safe_VkQueueFamilyCheckpointProperties2NV *>(header);
-            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
             delete reinterpret_cast<safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *>(header);
             break;
@@ -2775,6 +2763,9 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
             delete reinterpret_cast<safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX *>(header);
             break;
+        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
+            delete reinterpret_cast<safe_VkMultiviewPerViewAttributesInfoNVX *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
             delete reinterpret_cast<safe_VkPipelineViewportSwizzleStateCreateInfoNV *>(header);
             break;
@@ -2836,6 +2827,9 @@ void FreePnextChain(const void *pNext) {
             delete reinterpret_cast<safe_VkPipelineShaderStageNodeCreateInfoAMDX *>(header);
             break;
 #endif  // VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
+            delete reinterpret_cast<safe_VkAttachmentSampleCountInfoAMD *>(header);
+            break;
         case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
             delete reinterpret_cast<safe_VkSampleLocationsInfoEXT *>(header);
             break;
@@ -2958,6 +2952,9 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
             delete reinterpret_cast<safe_VkQueueFamilyCheckpointPropertiesNV *>(header);
             break;
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
+            delete reinterpret_cast<safe_VkQueueFamilyCheckpointProperties2NV *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
             delete reinterpret_cast<safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *>(header);
             break;
@@ -2982,6 +2979,9 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
             delete reinterpret_cast<safe_VkRenderPassFragmentDensityMapCreateInfoEXT *>(header);
             break;
+        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
+            delete reinterpret_cast<safe_VkRenderingFragmentDensityMapAttachmentInfoEXT *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
             delete reinterpret_cast<safe_VkPhysicalDeviceShaderCoreProperties2AMD *>(header);
             break;
diff --git a/src/vulkan/vk_safe_struct_vendor.cpp b/src/vulkan/vk_safe_struct_vendor.cpp
index de94266..f086422 100644
--- a/src/vulkan/vk_safe_struct_vendor.cpp
+++ b/src/vulkan/vk_safe_struct_vendor.cpp
@@ -21,256 +21,6 @@
 
 namespace vku {
 
-safe_VkAttachmentSampleCountInfoAMD::safe_VkAttachmentSampleCountInfoAMD(const VkAttachmentSampleCountInfoAMD* in_struct,
-                                                                         [[maybe_unused]] PNextCopyState* copy_state,
-                                                                         bool copy_pnext)
-    : sType(in_struct->sType),
-      colorAttachmentCount(in_struct->colorAttachmentCount),
-      pColorAttachmentSamples(nullptr),
-      depthStencilAttachmentSamples(in_struct->depthStencilAttachmentSamples) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-    if (in_struct->pColorAttachmentSamples) {
-        pColorAttachmentSamples = new VkSampleCountFlagBits[in_struct->colorAttachmentCount];
-        memcpy((void*)pColorAttachmentSamples, (void*)in_struct->pColorAttachmentSamples,
-               sizeof(VkSampleCountFlagBits) * in_struct->colorAttachmentCount);
-    }
-}
-
-safe_VkAttachmentSampleCountInfoAMD::safe_VkAttachmentSampleCountInfoAMD()
-    : sType(VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD),
-      pNext(nullptr),
-      colorAttachmentCount(),
-      pColorAttachmentSamples(nullptr),
-      depthStencilAttachmentSamples() {}
-
-safe_VkAttachmentSampleCountInfoAMD::safe_VkAttachmentSampleCountInfoAMD(const safe_VkAttachmentSampleCountInfoAMD& copy_src) {
-    sType = copy_src.sType;
-    colorAttachmentCount = copy_src.colorAttachmentCount;
-    pColorAttachmentSamples = nullptr;
-    depthStencilAttachmentSamples = copy_src.depthStencilAttachmentSamples;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    if (copy_src.pColorAttachmentSamples) {
-        pColorAttachmentSamples = new VkSampleCountFlagBits[copy_src.colorAttachmentCount];
-        memcpy((void*)pColorAttachmentSamples, (void*)copy_src.pColorAttachmentSamples,
-               sizeof(VkSampleCountFlagBits) * copy_src.colorAttachmentCount);
-    }
-}
-
-safe_VkAttachmentSampleCountInfoAMD& safe_VkAttachmentSampleCountInfoAMD::operator=(
-    const safe_VkAttachmentSampleCountInfoAMD& copy_src) {
-    if (&copy_src == this) return *this;
-
-    if (pColorAttachmentSamples) delete[] pColorAttachmentSamples;
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    colorAttachmentCount = copy_src.colorAttachmentCount;
-    pColorAttachmentSamples = nullptr;
-    depthStencilAttachmentSamples = copy_src.depthStencilAttachmentSamples;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    if (copy_src.pColorAttachmentSamples) {
-        pColorAttachmentSamples = new VkSampleCountFlagBits[copy_src.colorAttachmentCount];
-        memcpy((void*)pColorAttachmentSamples, (void*)copy_src.pColorAttachmentSamples,
-               sizeof(VkSampleCountFlagBits) * copy_src.colorAttachmentCount);
-    }
-
-    return *this;
-}
-
-safe_VkAttachmentSampleCountInfoAMD::~safe_VkAttachmentSampleCountInfoAMD() {
-    if (pColorAttachmentSamples) delete[] pColorAttachmentSamples;
-    FreePnextChain(pNext);
-}
-
-void safe_VkAttachmentSampleCountInfoAMD::initialize(const VkAttachmentSampleCountInfoAMD* in_struct,
-                                                     [[maybe_unused]] PNextCopyState* copy_state) {
-    if (pColorAttachmentSamples) delete[] pColorAttachmentSamples;
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    colorAttachmentCount = in_struct->colorAttachmentCount;
-    pColorAttachmentSamples = nullptr;
-    depthStencilAttachmentSamples = in_struct->depthStencilAttachmentSamples;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-
-    if (in_struct->pColorAttachmentSamples) {
-        pColorAttachmentSamples = new VkSampleCountFlagBits[in_struct->colorAttachmentCount];
-        memcpy((void*)pColorAttachmentSamples, (void*)in_struct->pColorAttachmentSamples,
-               sizeof(VkSampleCountFlagBits) * in_struct->colorAttachmentCount);
-    }
-}
-
-void safe_VkAttachmentSampleCountInfoAMD::initialize(const safe_VkAttachmentSampleCountInfoAMD* copy_src,
-                                                     [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    colorAttachmentCount = copy_src->colorAttachmentCount;
-    pColorAttachmentSamples = nullptr;
-    depthStencilAttachmentSamples = copy_src->depthStencilAttachmentSamples;
-    pNext = SafePnextCopy(copy_src->pNext);
-
-    if (copy_src->pColorAttachmentSamples) {
-        pColorAttachmentSamples = new VkSampleCountFlagBits[copy_src->colorAttachmentCount];
-        memcpy((void*)pColorAttachmentSamples, (void*)copy_src->pColorAttachmentSamples,
-               sizeof(VkSampleCountFlagBits) * copy_src->colorAttachmentCount);
-    }
-}
-
-safe_VkMultiviewPerViewAttributesInfoNVX::safe_VkMultiviewPerViewAttributesInfoNVX(
-    const VkMultiviewPerViewAttributesInfoNVX* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType),
-      perViewAttributes(in_struct->perViewAttributes),
-      perViewAttributesPositionXOnly(in_struct->perViewAttributesPositionXOnly) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkMultiviewPerViewAttributesInfoNVX::safe_VkMultiviewPerViewAttributesInfoNVX()
-    : sType(VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX),
-      pNext(nullptr),
-      perViewAttributes(),
-      perViewAttributesPositionXOnly() {}
-
-safe_VkMultiviewPerViewAttributesInfoNVX::safe_VkMultiviewPerViewAttributesInfoNVX(
-    const safe_VkMultiviewPerViewAttributesInfoNVX& copy_src) {
-    sType = copy_src.sType;
-    perViewAttributes = copy_src.perViewAttributes;
-    perViewAttributesPositionXOnly = copy_src.perViewAttributesPositionXOnly;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkMultiviewPerViewAttributesInfoNVX& safe_VkMultiviewPerViewAttributesInfoNVX::operator=(
-    const safe_VkMultiviewPerViewAttributesInfoNVX& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    perViewAttributes = copy_src.perViewAttributes;
-    perViewAttributesPositionXOnly = copy_src.perViewAttributesPositionXOnly;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkMultiviewPerViewAttributesInfoNVX::~safe_VkMultiviewPerViewAttributesInfoNVX() { FreePnextChain(pNext); }
-
-void safe_VkMultiviewPerViewAttributesInfoNVX::initialize(const VkMultiviewPerViewAttributesInfoNVX* in_struct,
-                                                          [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    perViewAttributes = in_struct->perViewAttributes;
-    perViewAttributesPositionXOnly = in_struct->perViewAttributesPositionXOnly;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkMultiviewPerViewAttributesInfoNVX::initialize(const safe_VkMultiviewPerViewAttributesInfoNVX* copy_src,
-                                                          [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    perViewAttributes = copy_src->perViewAttributes;
-    perViewAttributesPositionXOnly = copy_src->perViewAttributesPositionXOnly;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkQueueFamilyCheckpointProperties2NV::safe_VkQueueFamilyCheckpointProperties2NV(
-    const VkQueueFamilyCheckpointProperties2NV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), checkpointExecutionStageMask(in_struct->checkpointExecutionStageMask) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkQueueFamilyCheckpointProperties2NV::safe_VkQueueFamilyCheckpointProperties2NV()
-    : sType(VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV), pNext(nullptr), checkpointExecutionStageMask() {}
-
-safe_VkQueueFamilyCheckpointProperties2NV::safe_VkQueueFamilyCheckpointProperties2NV(
-    const safe_VkQueueFamilyCheckpointProperties2NV& copy_src) {
-    sType = copy_src.sType;
-    checkpointExecutionStageMask = copy_src.checkpointExecutionStageMask;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkQueueFamilyCheckpointProperties2NV& safe_VkQueueFamilyCheckpointProperties2NV::operator=(
-    const safe_VkQueueFamilyCheckpointProperties2NV& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    checkpointExecutionStageMask = copy_src.checkpointExecutionStageMask;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkQueueFamilyCheckpointProperties2NV::~safe_VkQueueFamilyCheckpointProperties2NV() { FreePnextChain(pNext); }
-
-void safe_VkQueueFamilyCheckpointProperties2NV::initialize(const VkQueueFamilyCheckpointProperties2NV* in_struct,
-                                                           [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    checkpointExecutionStageMask = in_struct->checkpointExecutionStageMask;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkQueueFamilyCheckpointProperties2NV::initialize(const safe_VkQueueFamilyCheckpointProperties2NV* copy_src,
-                                                           [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    checkpointExecutionStageMask = copy_src->checkpointExecutionStageMask;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkCheckpointData2NV::safe_VkCheckpointData2NV(const VkCheckpointData2NV* in_struct,
-                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), stage(in_struct->stage), pCheckpointMarker(in_struct->pCheckpointMarker) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkCheckpointData2NV::safe_VkCheckpointData2NV()
-    : sType(VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV), pNext(nullptr), stage(), pCheckpointMarker(nullptr) {}
-
-safe_VkCheckpointData2NV::safe_VkCheckpointData2NV(const safe_VkCheckpointData2NV& copy_src) {
-    sType = copy_src.sType;
-    stage = copy_src.stage;
-    pCheckpointMarker = copy_src.pCheckpointMarker;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkCheckpointData2NV& safe_VkCheckpointData2NV::operator=(const safe_VkCheckpointData2NV& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    stage = copy_src.stage;
-    pCheckpointMarker = copy_src.pCheckpointMarker;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkCheckpointData2NV::~safe_VkCheckpointData2NV() { FreePnextChain(pNext); }
-
-void safe_VkCheckpointData2NV::initialize(const VkCheckpointData2NV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    stage = in_struct->stage;
-    pCheckpointMarker = in_struct->pCheckpointMarker;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkCheckpointData2NV::initialize(const safe_VkCheckpointData2NV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    stage = copy_src->stage;
-    pCheckpointMarker = copy_src->pCheckpointMarker;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
 safe_VkPipelineRasterizationStateRasterizationOrderAMD::safe_VkPipelineRasterizationStateRasterizationOrderAMD(
     const VkPipelineRasterizationStateRasterizationOrderAMD* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
     bool copy_pnext)
@@ -1738,6 +1488,63 @@ void safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::initialize(
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkMultiviewPerViewAttributesInfoNVX::safe_VkMultiviewPerViewAttributesInfoNVX(
+    const VkMultiviewPerViewAttributesInfoNVX* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      perViewAttributes(in_struct->perViewAttributes),
+      perViewAttributesPositionXOnly(in_struct->perViewAttributesPositionXOnly) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMultiviewPerViewAttributesInfoNVX::safe_VkMultiviewPerViewAttributesInfoNVX()
+    : sType(VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX),
+      pNext(nullptr),
+      perViewAttributes(),
+      perViewAttributesPositionXOnly() {}
+
+safe_VkMultiviewPerViewAttributesInfoNVX::safe_VkMultiviewPerViewAttributesInfoNVX(
+    const safe_VkMultiviewPerViewAttributesInfoNVX& copy_src) {
+    sType = copy_src.sType;
+    perViewAttributes = copy_src.perViewAttributes;
+    perViewAttributesPositionXOnly = copy_src.perViewAttributesPositionXOnly;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMultiviewPerViewAttributesInfoNVX& safe_VkMultiviewPerViewAttributesInfoNVX::operator=(
+    const safe_VkMultiviewPerViewAttributesInfoNVX& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    perViewAttributes = copy_src.perViewAttributes;
+    perViewAttributesPositionXOnly = copy_src.perViewAttributesPositionXOnly;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMultiviewPerViewAttributesInfoNVX::~safe_VkMultiviewPerViewAttributesInfoNVX() { FreePnextChain(pNext); }
+
+void safe_VkMultiviewPerViewAttributesInfoNVX::initialize(const VkMultiviewPerViewAttributesInfoNVX* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    perViewAttributes = in_struct->perViewAttributes;
+    perViewAttributesPositionXOnly = in_struct->perViewAttributesPositionXOnly;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMultiviewPerViewAttributesInfoNVX::initialize(const safe_VkMultiviewPerViewAttributesInfoNVX* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    perViewAttributes = copy_src->perViewAttributes;
+    perViewAttributesPositionXOnly = copy_src->perViewAttributesPositionXOnly;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkPipelineViewportSwizzleStateCreateInfoNV::safe_VkPipelineViewportSwizzleStateCreateInfoNV(
     const VkPipelineViewportSwizzleStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType), flags(in_struct->flags), viewportCount(in_struct->viewportCount), pViewportSwizzles(nullptr) {
@@ -2758,6 +2565,103 @@ void safe_VkPipelineShaderStageNodeCreateInfoAMDX::initialize(const safe_VkPipel
 }
 #endif  // VK_ENABLE_BETA_EXTENSIONS
 
+safe_VkAttachmentSampleCountInfoAMD::safe_VkAttachmentSampleCountInfoAMD(const VkAttachmentSampleCountInfoAMD* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType),
+      colorAttachmentCount(in_struct->colorAttachmentCount),
+      pColorAttachmentSamples(nullptr),
+      depthStencilAttachmentSamples(in_struct->depthStencilAttachmentSamples) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pColorAttachmentSamples) {
+        pColorAttachmentSamples = new VkSampleCountFlagBits[in_struct->colorAttachmentCount];
+        memcpy((void*)pColorAttachmentSamples, (void*)in_struct->pColorAttachmentSamples,
+               sizeof(VkSampleCountFlagBits) * in_struct->colorAttachmentCount);
+    }
+}
+
+safe_VkAttachmentSampleCountInfoAMD::safe_VkAttachmentSampleCountInfoAMD()
+    : sType(VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD),
+      pNext(nullptr),
+      colorAttachmentCount(),
+      pColorAttachmentSamples(nullptr),
+      depthStencilAttachmentSamples() {}
+
+safe_VkAttachmentSampleCountInfoAMD::safe_VkAttachmentSampleCountInfoAMD(const safe_VkAttachmentSampleCountInfoAMD& copy_src) {
+    sType = copy_src.sType;
+    colorAttachmentCount = copy_src.colorAttachmentCount;
+    pColorAttachmentSamples = nullptr;
+    depthStencilAttachmentSamples = copy_src.depthStencilAttachmentSamples;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pColorAttachmentSamples) {
+        pColorAttachmentSamples = new VkSampleCountFlagBits[copy_src.colorAttachmentCount];
+        memcpy((void*)pColorAttachmentSamples, (void*)copy_src.pColorAttachmentSamples,
+               sizeof(VkSampleCountFlagBits) * copy_src.colorAttachmentCount);
+    }
+}
+
+safe_VkAttachmentSampleCountInfoAMD& safe_VkAttachmentSampleCountInfoAMD::operator=(
+    const safe_VkAttachmentSampleCountInfoAMD& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pColorAttachmentSamples) delete[] pColorAttachmentSamples;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    colorAttachmentCount = copy_src.colorAttachmentCount;
+    pColorAttachmentSamples = nullptr;
+    depthStencilAttachmentSamples = copy_src.depthStencilAttachmentSamples;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pColorAttachmentSamples) {
+        pColorAttachmentSamples = new VkSampleCountFlagBits[copy_src.colorAttachmentCount];
+        memcpy((void*)pColorAttachmentSamples, (void*)copy_src.pColorAttachmentSamples,
+               sizeof(VkSampleCountFlagBits) * copy_src.colorAttachmentCount);
+    }
+
+    return *this;
+}
+
+safe_VkAttachmentSampleCountInfoAMD::~safe_VkAttachmentSampleCountInfoAMD() {
+    if (pColorAttachmentSamples) delete[] pColorAttachmentSamples;
+    FreePnextChain(pNext);
+}
+
+void safe_VkAttachmentSampleCountInfoAMD::initialize(const VkAttachmentSampleCountInfoAMD* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pColorAttachmentSamples) delete[] pColorAttachmentSamples;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    colorAttachmentCount = in_struct->colorAttachmentCount;
+    pColorAttachmentSamples = nullptr;
+    depthStencilAttachmentSamples = in_struct->depthStencilAttachmentSamples;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pColorAttachmentSamples) {
+        pColorAttachmentSamples = new VkSampleCountFlagBits[in_struct->colorAttachmentCount];
+        memcpy((void*)pColorAttachmentSamples, (void*)in_struct->pColorAttachmentSamples,
+               sizeof(VkSampleCountFlagBits) * in_struct->colorAttachmentCount);
+    }
+}
+
+void safe_VkAttachmentSampleCountInfoAMD::initialize(const safe_VkAttachmentSampleCountInfoAMD* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    colorAttachmentCount = copy_src->colorAttachmentCount;
+    pColorAttachmentSamples = nullptr;
+    depthStencilAttachmentSamples = copy_src->depthStencilAttachmentSamples;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pColorAttachmentSamples) {
+        pColorAttachmentSamples = new VkSampleCountFlagBits[copy_src->colorAttachmentCount];
+        memcpy((void*)pColorAttachmentSamples, (void*)copy_src->pColorAttachmentSamples,
+               sizeof(VkSampleCountFlagBits) * copy_src->colorAttachmentCount);
+    }
+}
+
 safe_VkPipelineCoverageToColorStateCreateInfoNV::safe_VkPipelineCoverageToColorStateCreateInfoNV(
     const VkPipelineCoverageToColorStateCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType),
@@ -5328,6 +5232,102 @@ void safe_VkCheckpointDataNV::initialize(const safe_VkCheckpointDataNV* copy_src
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkQueueFamilyCheckpointProperties2NV::safe_VkQueueFamilyCheckpointProperties2NV(
+    const VkQueueFamilyCheckpointProperties2NV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), checkpointExecutionStageMask(in_struct->checkpointExecutionStageMask) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkQueueFamilyCheckpointProperties2NV::safe_VkQueueFamilyCheckpointProperties2NV()
+    : sType(VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV), pNext(nullptr), checkpointExecutionStageMask() {}
+
+safe_VkQueueFamilyCheckpointProperties2NV::safe_VkQueueFamilyCheckpointProperties2NV(
+    const safe_VkQueueFamilyCheckpointProperties2NV& copy_src) {
+    sType = copy_src.sType;
+    checkpointExecutionStageMask = copy_src.checkpointExecutionStageMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkQueueFamilyCheckpointProperties2NV& safe_VkQueueFamilyCheckpointProperties2NV::operator=(
+    const safe_VkQueueFamilyCheckpointProperties2NV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    checkpointExecutionStageMask = copy_src.checkpointExecutionStageMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkQueueFamilyCheckpointProperties2NV::~safe_VkQueueFamilyCheckpointProperties2NV() { FreePnextChain(pNext); }
+
+void safe_VkQueueFamilyCheckpointProperties2NV::initialize(const VkQueueFamilyCheckpointProperties2NV* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    checkpointExecutionStageMask = in_struct->checkpointExecutionStageMask;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkQueueFamilyCheckpointProperties2NV::initialize(const safe_VkQueueFamilyCheckpointProperties2NV* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    checkpointExecutionStageMask = copy_src->checkpointExecutionStageMask;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkCheckpointData2NV::safe_VkCheckpointData2NV(const VkCheckpointData2NV* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), stage(in_struct->stage), pCheckpointMarker(in_struct->pCheckpointMarker) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkCheckpointData2NV::safe_VkCheckpointData2NV()
+    : sType(VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV), pNext(nullptr), stage(), pCheckpointMarker(nullptr) {}
+
+safe_VkCheckpointData2NV::safe_VkCheckpointData2NV(const safe_VkCheckpointData2NV& copy_src) {
+    sType = copy_src.sType;
+    stage = copy_src.stage;
+    pCheckpointMarker = copy_src.pCheckpointMarker;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkCheckpointData2NV& safe_VkCheckpointData2NV::operator=(const safe_VkCheckpointData2NV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    stage = copy_src.stage;
+    pCheckpointMarker = copy_src.pCheckpointMarker;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkCheckpointData2NV::~safe_VkCheckpointData2NV() { FreePnextChain(pNext); }
+
+void safe_VkCheckpointData2NV::initialize(const VkCheckpointData2NV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    stage = in_struct->stage;
+    pCheckpointMarker = in_struct->pCheckpointMarker;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkCheckpointData2NV::initialize(const safe_VkCheckpointData2NV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stage = copy_src->stage;
+    pCheckpointMarker = copy_src->pCheckpointMarker;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
     const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
     bool copy_pnext)

From dcb6173f7463ed233696e18eb9992cbe11262af0 Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Fri, 25 Oct 2024 08:28:44 -0700
Subject: [PATCH 056/106] build: Update to header 1.3.300

---
 include/vulkan/utility/vk_dispatch_table.h  |   2 +
 include/vulkan/utility/vk_safe_struct.hpp   |  79 ++++++
 include/vulkan/utility/vk_struct_helper.hpp |   3 +
 include/vulkan/vk_enum_string_helper.h      |   6 +
 scripts/known_good.json                     |   2 +-
 src/vulkan/vk_safe_struct_utils.cpp         |  12 +
 src/vulkan/vk_safe_struct_vendor.cpp        | 260 ++++++++++++++++++++
 7 files changed, 363 insertions(+), 1 deletion(-)

diff --git a/include/vulkan/utility/vk_dispatch_table.h b/include/vulkan/utility/vk_dispatch_table.h
index 96e2faf..3d81ed5 100644
--- a/include/vulkan/utility/vk_dispatch_table.h
+++ b/include/vulkan/utility/vk_dispatch_table.h
@@ -161,6 +161,7 @@ typedef struct VkuInstanceDispatchTable_ {
     PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX GetPhysicalDeviceScreenPresentationSupportQNX;
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
     PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV GetPhysicalDeviceOpticalFlowImageFormatsNV;
+    PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV;
 } VkuInstanceDispatchTable;
 
 // Device function pointer dispatch table
@@ -1526,5 +1527,6 @@ static inline void vkuInitInstanceDispatchTable(VkInstance instance, VkuInstance
     table->GetPhysicalDeviceScreenPresentationSupportQNX = (PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX)gipa(instance, "vkGetPhysicalDeviceScreenPresentationSupportQNX");
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
     table->GetPhysicalDeviceOpticalFlowImageFormatsNV = (PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV)gipa(instance, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV");
+    table->GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = (PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV)gipa(instance, "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV");
 }
 // clang-format on
diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index bbf04a0..7731700 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -18833,6 +18833,85 @@ struct safe_VkPipelineViewportDepthClampControlCreateInfoEXT {
         return reinterpret_cast<VkPipelineViewportDepthClampControlCreateInfoEXT const*>(this);
     }
 };
+struct safe_VkCooperativeMatrixFlexibleDimensionsPropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t MGranularity;
+    uint32_t NGranularity;
+    uint32_t KGranularity;
+    VkComponentTypeKHR AType;
+    VkComponentTypeKHR BType;
+    VkComponentTypeKHR CType;
+    VkComponentTypeKHR ResultType;
+    VkBool32 saturatingAccumulation;
+    VkScopeKHR scope;
+    uint32_t workgroupInvocations;
+
+    safe_VkCooperativeMatrixFlexibleDimensionsPropertiesNV(const VkCooperativeMatrixFlexibleDimensionsPropertiesNV* in_struct,
+                                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkCooperativeMatrixFlexibleDimensionsPropertiesNV(const safe_VkCooperativeMatrixFlexibleDimensionsPropertiesNV& copy_src);
+    safe_VkCooperativeMatrixFlexibleDimensionsPropertiesNV& operator=(
+        const safe_VkCooperativeMatrixFlexibleDimensionsPropertiesNV& copy_src);
+    safe_VkCooperativeMatrixFlexibleDimensionsPropertiesNV();
+    ~safe_VkCooperativeMatrixFlexibleDimensionsPropertiesNV();
+    void initialize(const VkCooperativeMatrixFlexibleDimensionsPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCooperativeMatrixFlexibleDimensionsPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkCooperativeMatrixFlexibleDimensionsPropertiesNV* ptr() {
+        return reinterpret_cast<VkCooperativeMatrixFlexibleDimensionsPropertiesNV*>(this);
+    }
+    VkCooperativeMatrixFlexibleDimensionsPropertiesNV const* ptr() const {
+        return reinterpret_cast<VkCooperativeMatrixFlexibleDimensionsPropertiesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceCooperativeMatrix2FeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 cooperativeMatrixWorkgroupScope;
+    VkBool32 cooperativeMatrixFlexibleDimensions;
+    VkBool32 cooperativeMatrixReductions;
+    VkBool32 cooperativeMatrixConversions;
+    VkBool32 cooperativeMatrixPerElementOperations;
+    VkBool32 cooperativeMatrixTensorAddressing;
+    VkBool32 cooperativeMatrixBlockLoads;
+
+    safe_VkPhysicalDeviceCooperativeMatrix2FeaturesNV(const VkPhysicalDeviceCooperativeMatrix2FeaturesNV* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceCooperativeMatrix2FeaturesNV(const safe_VkPhysicalDeviceCooperativeMatrix2FeaturesNV& copy_src);
+    safe_VkPhysicalDeviceCooperativeMatrix2FeaturesNV& operator=(const safe_VkPhysicalDeviceCooperativeMatrix2FeaturesNV& copy_src);
+    safe_VkPhysicalDeviceCooperativeMatrix2FeaturesNV();
+    ~safe_VkPhysicalDeviceCooperativeMatrix2FeaturesNV();
+    void initialize(const VkPhysicalDeviceCooperativeMatrix2FeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceCooperativeMatrix2FeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCooperativeMatrix2FeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceCooperativeMatrix2FeaturesNV*>(this);
+    }
+    VkPhysicalDeviceCooperativeMatrix2FeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCooperativeMatrix2FeaturesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t cooperativeMatrixWorkgroupScopeMaxWorkgroupSize;
+    uint32_t cooperativeMatrixFlexibleDimensionsMaxDimension;
+    uint32_t cooperativeMatrixWorkgroupScopeReservedSharedMemory;
+
+    safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV(const VkPhysicalDeviceCooperativeMatrix2PropertiesNV* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV(const safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV& copy_src);
+    safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV& operator=(
+        const safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV& copy_src);
+    safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV();
+    ~safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV();
+    void initialize(const VkPhysicalDeviceCooperativeMatrix2PropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCooperativeMatrix2PropertiesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceCooperativeMatrix2PropertiesNV*>(this);
+    }
+    VkPhysicalDeviceCooperativeMatrix2PropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCooperativeMatrix2PropertiesNV const*>(this);
+    }
+};
 struct safe_VkAccelerationStructureGeometryTrianglesDataKHR {
     VkStructureType sType;
     const void* pNext{};
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index d3c9266..ddba89b 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -985,6 +985,9 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceImageAlignmentContro
 template <> inline VkStructureType GetSType<VkImageAlignmentControlCreateInfoMESA>() { return VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceDepthClampControlFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkPipelineViewportDepthClampControlCreateInfoEXT>() { return VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT; }
+template <> inline VkStructureType GetSType<VkCooperativeMatrixFlexibleDimensionsPropertiesNV>() { return VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeMatrix2FeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeMatrix2PropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryTrianglesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryAabbsDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryInstancesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index 457bb03..340cba0 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -2002,6 +2002,12 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT";
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT:
             return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV";
+        case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV:
+            return "VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV";
         default:
             return "Unhandled VkStructureType";
     }
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 536f291..7a5d211 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.3.299"
+            "commit": "v1.3.300"
         },
         {
             "name": "googletest",
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index d8750d8..f0c9df7 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -1870,6 +1870,12 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT:
                 safe_pNext = new safe_VkPipelineViewportDepthClampControlCreateInfoEXT(reinterpret_cast<const VkPipelineViewportDepthClampControlCreateInfoEXT *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceCooperativeMatrix2FeaturesNV(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrix2FeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrix2PropertiesNV *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
                 safe_pNext = new safe_VkWriteDescriptorSetAccelerationStructureKHR(reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR *>(pNext), copy_state, false);
                 break;
@@ -3756,6 +3762,12 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT:
             delete reinterpret_cast<safe_VkPipelineViewportDepthClampControlCreateInfoEXT *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV:
+            delete reinterpret_cast<safe_VkPhysicalDeviceCooperativeMatrix2FeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV:
+            delete reinterpret_cast<safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV *>(header);
+            break;
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
             delete reinterpret_cast<safe_VkWriteDescriptorSetAccelerationStructureKHR *>(header);
             break;
diff --git a/src/vulkan/vk_safe_struct_vendor.cpp b/src/vulkan/vk_safe_struct_vendor.cpp
index f086422..3fa04eb 100644
--- a/src/vulkan/vk_safe_struct_vendor.cpp
+++ b/src/vulkan/vk_safe_struct_vendor.cpp
@@ -15465,6 +15465,266 @@ void safe_VkImageAlignmentControlCreateInfoMESA::initialize(const safe_VkImageAl
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkCooperativeMatrixFlexibleDimensionsPropertiesNV::safe_VkCooperativeMatrixFlexibleDimensionsPropertiesNV(
+    const VkCooperativeMatrixFlexibleDimensionsPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      MGranularity(in_struct->MGranularity),
+      NGranularity(in_struct->NGranularity),
+      KGranularity(in_struct->KGranularity),
+      AType(in_struct->AType),
+      BType(in_struct->BType),
+      CType(in_struct->CType),
+      ResultType(in_struct->ResultType),
+      saturatingAccumulation(in_struct->saturatingAccumulation),
+      scope(in_struct->scope),
+      workgroupInvocations(in_struct->workgroupInvocations) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkCooperativeMatrixFlexibleDimensionsPropertiesNV::safe_VkCooperativeMatrixFlexibleDimensionsPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV),
+      pNext(nullptr),
+      MGranularity(),
+      NGranularity(),
+      KGranularity(),
+      AType(),
+      BType(),
+      CType(),
+      ResultType(),
+      saturatingAccumulation(),
+      scope(),
+      workgroupInvocations() {}
+
+safe_VkCooperativeMatrixFlexibleDimensionsPropertiesNV::safe_VkCooperativeMatrixFlexibleDimensionsPropertiesNV(
+    const safe_VkCooperativeMatrixFlexibleDimensionsPropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    MGranularity = copy_src.MGranularity;
+    NGranularity = copy_src.NGranularity;
+    KGranularity = copy_src.KGranularity;
+    AType = copy_src.AType;
+    BType = copy_src.BType;
+    CType = copy_src.CType;
+    ResultType = copy_src.ResultType;
+    saturatingAccumulation = copy_src.saturatingAccumulation;
+    scope = copy_src.scope;
+    workgroupInvocations = copy_src.workgroupInvocations;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkCooperativeMatrixFlexibleDimensionsPropertiesNV& safe_VkCooperativeMatrixFlexibleDimensionsPropertiesNV::operator=(
+    const safe_VkCooperativeMatrixFlexibleDimensionsPropertiesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    MGranularity = copy_src.MGranularity;
+    NGranularity = copy_src.NGranularity;
+    KGranularity = copy_src.KGranularity;
+    AType = copy_src.AType;
+    BType = copy_src.BType;
+    CType = copy_src.CType;
+    ResultType = copy_src.ResultType;
+    saturatingAccumulation = copy_src.saturatingAccumulation;
+    scope = copy_src.scope;
+    workgroupInvocations = copy_src.workgroupInvocations;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkCooperativeMatrixFlexibleDimensionsPropertiesNV::~safe_VkCooperativeMatrixFlexibleDimensionsPropertiesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkCooperativeMatrixFlexibleDimensionsPropertiesNV::initialize(
+    const VkCooperativeMatrixFlexibleDimensionsPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    MGranularity = in_struct->MGranularity;
+    NGranularity = in_struct->NGranularity;
+    KGranularity = in_struct->KGranularity;
+    AType = in_struct->AType;
+    BType = in_struct->BType;
+    CType = in_struct->CType;
+    ResultType = in_struct->ResultType;
+    saturatingAccumulation = in_struct->saturatingAccumulation;
+    scope = in_struct->scope;
+    workgroupInvocations = in_struct->workgroupInvocations;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkCooperativeMatrixFlexibleDimensionsPropertiesNV::initialize(
+    const safe_VkCooperativeMatrixFlexibleDimensionsPropertiesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    MGranularity = copy_src->MGranularity;
+    NGranularity = copy_src->NGranularity;
+    KGranularity = copy_src->KGranularity;
+    AType = copy_src->AType;
+    BType = copy_src->BType;
+    CType = copy_src->CType;
+    ResultType = copy_src->ResultType;
+    saturatingAccumulation = copy_src->saturatingAccumulation;
+    scope = copy_src->scope;
+    workgroupInvocations = copy_src->workgroupInvocations;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceCooperativeMatrix2FeaturesNV::safe_VkPhysicalDeviceCooperativeMatrix2FeaturesNV(
+    const VkPhysicalDeviceCooperativeMatrix2FeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      cooperativeMatrixWorkgroupScope(in_struct->cooperativeMatrixWorkgroupScope),
+      cooperativeMatrixFlexibleDimensions(in_struct->cooperativeMatrixFlexibleDimensions),
+      cooperativeMatrixReductions(in_struct->cooperativeMatrixReductions),
+      cooperativeMatrixConversions(in_struct->cooperativeMatrixConversions),
+      cooperativeMatrixPerElementOperations(in_struct->cooperativeMatrixPerElementOperations),
+      cooperativeMatrixTensorAddressing(in_struct->cooperativeMatrixTensorAddressing),
+      cooperativeMatrixBlockLoads(in_struct->cooperativeMatrixBlockLoads) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceCooperativeMatrix2FeaturesNV::safe_VkPhysicalDeviceCooperativeMatrix2FeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV),
+      pNext(nullptr),
+      cooperativeMatrixWorkgroupScope(),
+      cooperativeMatrixFlexibleDimensions(),
+      cooperativeMatrixReductions(),
+      cooperativeMatrixConversions(),
+      cooperativeMatrixPerElementOperations(),
+      cooperativeMatrixTensorAddressing(),
+      cooperativeMatrixBlockLoads() {}
+
+safe_VkPhysicalDeviceCooperativeMatrix2FeaturesNV::safe_VkPhysicalDeviceCooperativeMatrix2FeaturesNV(
+    const safe_VkPhysicalDeviceCooperativeMatrix2FeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    cooperativeMatrixWorkgroupScope = copy_src.cooperativeMatrixWorkgroupScope;
+    cooperativeMatrixFlexibleDimensions = copy_src.cooperativeMatrixFlexibleDimensions;
+    cooperativeMatrixReductions = copy_src.cooperativeMatrixReductions;
+    cooperativeMatrixConversions = copy_src.cooperativeMatrixConversions;
+    cooperativeMatrixPerElementOperations = copy_src.cooperativeMatrixPerElementOperations;
+    cooperativeMatrixTensorAddressing = copy_src.cooperativeMatrixTensorAddressing;
+    cooperativeMatrixBlockLoads = copy_src.cooperativeMatrixBlockLoads;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceCooperativeMatrix2FeaturesNV& safe_VkPhysicalDeviceCooperativeMatrix2FeaturesNV::operator=(
+    const safe_VkPhysicalDeviceCooperativeMatrix2FeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    cooperativeMatrixWorkgroupScope = copy_src.cooperativeMatrixWorkgroupScope;
+    cooperativeMatrixFlexibleDimensions = copy_src.cooperativeMatrixFlexibleDimensions;
+    cooperativeMatrixReductions = copy_src.cooperativeMatrixReductions;
+    cooperativeMatrixConversions = copy_src.cooperativeMatrixConversions;
+    cooperativeMatrixPerElementOperations = copy_src.cooperativeMatrixPerElementOperations;
+    cooperativeMatrixTensorAddressing = copy_src.cooperativeMatrixTensorAddressing;
+    cooperativeMatrixBlockLoads = copy_src.cooperativeMatrixBlockLoads;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceCooperativeMatrix2FeaturesNV::~safe_VkPhysicalDeviceCooperativeMatrix2FeaturesNV() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceCooperativeMatrix2FeaturesNV::initialize(const VkPhysicalDeviceCooperativeMatrix2FeaturesNV* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    cooperativeMatrixWorkgroupScope = in_struct->cooperativeMatrixWorkgroupScope;
+    cooperativeMatrixFlexibleDimensions = in_struct->cooperativeMatrixFlexibleDimensions;
+    cooperativeMatrixReductions = in_struct->cooperativeMatrixReductions;
+    cooperativeMatrixConversions = in_struct->cooperativeMatrixConversions;
+    cooperativeMatrixPerElementOperations = in_struct->cooperativeMatrixPerElementOperations;
+    cooperativeMatrixTensorAddressing = in_struct->cooperativeMatrixTensorAddressing;
+    cooperativeMatrixBlockLoads = in_struct->cooperativeMatrixBlockLoads;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceCooperativeMatrix2FeaturesNV::initialize(
+    const safe_VkPhysicalDeviceCooperativeMatrix2FeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    cooperativeMatrixWorkgroupScope = copy_src->cooperativeMatrixWorkgroupScope;
+    cooperativeMatrixFlexibleDimensions = copy_src->cooperativeMatrixFlexibleDimensions;
+    cooperativeMatrixReductions = copy_src->cooperativeMatrixReductions;
+    cooperativeMatrixConversions = copy_src->cooperativeMatrixConversions;
+    cooperativeMatrixPerElementOperations = copy_src->cooperativeMatrixPerElementOperations;
+    cooperativeMatrixTensorAddressing = copy_src->cooperativeMatrixTensorAddressing;
+    cooperativeMatrixBlockLoads = copy_src->cooperativeMatrixBlockLoads;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV::safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV(
+    const VkPhysicalDeviceCooperativeMatrix2PropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      cooperativeMatrixWorkgroupScopeMaxWorkgroupSize(in_struct->cooperativeMatrixWorkgroupScopeMaxWorkgroupSize),
+      cooperativeMatrixFlexibleDimensionsMaxDimension(in_struct->cooperativeMatrixFlexibleDimensionsMaxDimension),
+      cooperativeMatrixWorkgroupScopeReservedSharedMemory(in_struct->cooperativeMatrixWorkgroupScopeReservedSharedMemory) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV::safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV),
+      pNext(nullptr),
+      cooperativeMatrixWorkgroupScopeMaxWorkgroupSize(),
+      cooperativeMatrixFlexibleDimensionsMaxDimension(),
+      cooperativeMatrixWorkgroupScopeReservedSharedMemory() {}
+
+safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV::safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV(
+    const safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    cooperativeMatrixWorkgroupScopeMaxWorkgroupSize = copy_src.cooperativeMatrixWorkgroupScopeMaxWorkgroupSize;
+    cooperativeMatrixFlexibleDimensionsMaxDimension = copy_src.cooperativeMatrixFlexibleDimensionsMaxDimension;
+    cooperativeMatrixWorkgroupScopeReservedSharedMemory = copy_src.cooperativeMatrixWorkgroupScopeReservedSharedMemory;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV& safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV::operator=(
+    const safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    cooperativeMatrixWorkgroupScopeMaxWorkgroupSize = copy_src.cooperativeMatrixWorkgroupScopeMaxWorkgroupSize;
+    cooperativeMatrixFlexibleDimensionsMaxDimension = copy_src.cooperativeMatrixFlexibleDimensionsMaxDimension;
+    cooperativeMatrixWorkgroupScopeReservedSharedMemory = copy_src.cooperativeMatrixWorkgroupScopeReservedSharedMemory;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV::~safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV::initialize(
+    const VkPhysicalDeviceCooperativeMatrix2PropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    cooperativeMatrixWorkgroupScopeMaxWorkgroupSize = in_struct->cooperativeMatrixWorkgroupScopeMaxWorkgroupSize;
+    cooperativeMatrixFlexibleDimensionsMaxDimension = in_struct->cooperativeMatrixFlexibleDimensionsMaxDimension;
+    cooperativeMatrixWorkgroupScopeReservedSharedMemory = in_struct->cooperativeMatrixWorkgroupScopeReservedSharedMemory;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV::initialize(
+    const safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    cooperativeMatrixWorkgroupScopeMaxWorkgroupSize = copy_src->cooperativeMatrixWorkgroupScopeMaxWorkgroupSize;
+    cooperativeMatrixFlexibleDimensionsMaxDimension = copy_src->cooperativeMatrixFlexibleDimensionsMaxDimension;
+    cooperativeMatrixWorkgroupScopeReservedSharedMemory = copy_src->cooperativeMatrixWorkgroupScopeReservedSharedMemory;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 }  // namespace vku
 
 // NOLINTEND

From a42c1fbb7abf5af670e34f679eb96901e367dd21 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?M=C3=A1t=C3=A9=20Ferenc=20Nagy-Egri?= <mate@rastergrid.com>
Date: Mon, 28 Oct 2024 14:52:02 +0100
Subject: [PATCH 057/106] scripts: Handle remote URL change in update_deps.py

Without going through an intricate dance with git to change the remote
URL of a repository, it's simplest to just nuke the cloned folder, as
we have to do a clean clone anyway.
---
 scripts/update_deps.py | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/scripts/update_deps.py b/scripts/update_deps.py
index 57f0ef5..7165d9f 100755
--- a/scripts/update_deps.py
+++ b/scripts/update_deps.py
@@ -415,8 +415,15 @@ class GoodRepo(object):
         if VERBOSE:
             print('Checking out {n} in {d}'.format(n=self.name, d=self.repo_dir))
 
-        if self._args.do_clean_repo:
+        if os.path.exists(os.path.join(self.repo_dir, '.git')):
+            url_changed = command_output(['git', 'config', '--get', 'remote.origin.url'], self.repo_dir).strip() != self.url
+        else:
+            url_changed = False
+
+        if self._args.do_clean_repo or url_changed:
             if os.path.isdir(self.repo_dir):
+                if VERBOSE:
+                    print('Clearing directory {d}'.format(d=self.repo_dir))
                 shutil.rmtree(self.repo_dir, onerror = on_rm_error)
         if not os.path.exists(os.path.join(self.repo_dir, '.git')):
             self.Clone()

From 89fda4557228aa75327e13855da78ea317dc40c1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?M=C3=A1t=C3=A9=20Ferenc=20Nagy-Egri?= <mate@rastergrid.com>
Date: Mon, 28 Oct 2024 14:48:35 +0100
Subject: [PATCH 058/106] scripts: Fix user self-hosting dependency in
 update_deps.py

The documentation states that users can override where to take a
dependency from via variables like VULKAN_HEADERS_INSTALL_DIR, however
the helper.cmake written by the scripts/CMakeLists.txt FORCE updates
the cache variable to the location inside known_good.json, practically
overwriting the user-provided path given on the CLI using -D, also
going into the cache.
---
 scripts/update_deps.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/update_deps.py b/scripts/update_deps.py
index 7165d9f..461e575 100755
--- a/scripts/update_deps.py
+++ b/scripts/update_deps.py
@@ -622,7 +622,7 @@ def CreateHelper(args, repos, filename):
             if repo.api is not None and repo.api != args.api:
                 continue
             if install_names and repo.name in install_names and repo.on_build_platform:
-                helper_file.write('set({var} "{dir}" CACHE STRING "" FORCE)\n'
+                helper_file.write('set({var} "{dir}" CACHE STRING "")\n'
                                   .format(
                                       var=install_names[repo.name],
                                       dir=escape(repo.install_dir)))

From 9123b8c04b378c1b81899314e3060a80f255a24b Mon Sep 17 00:00:00 2001
From: Takuto Ikuta <atetubou@gmail.com>
Date: Mon, 28 Oct 2024 15:10:09 +0900
Subject: [PATCH 059/106] Add a missing header for `std::strtoul`

---
 src/layer/vk_layer_settings_helper.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/layer/vk_layer_settings_helper.cpp b/src/layer/vk_layer_settings_helper.cpp
index a408782..0736679 100644
--- a/src/layer/vk_layer_settings_helper.cpp
+++ b/src/layer/vk_layer_settings_helper.cpp
@@ -8,6 +8,8 @@
 // - Christophe Riccio <christophe@lunarg.com>
 #include "vulkan/layer/vk_layer_settings.hpp"
 
+#include <cstdlib>
+
 static std::string Merge(const std::vector<std::string> &strings) {
     std::string result;
 

From b78b8d9be17df0210de4351acac7702014e6f171 Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Mon, 4 Nov 2024 09:28:28 -0700
Subject: [PATCH 060/106] build: Update to header 1.3.301

---
 include/vulkan/utility/vk_safe_struct.hpp   |  35 +++++++
 include/vulkan/utility/vk_struct_helper.hpp |   2 +
 include/vulkan/vk_enum_string_helper.h      |   4 +
 scripts/known_good.json                     |   2 +-
 src/vulkan/vk_safe_struct_utils.cpp         |  12 +++
 src/vulkan/vk_safe_struct_vendor.cpp        | 103 ++++++++++++++++++++
 6 files changed, 157 insertions(+), 1 deletion(-)

diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index 7731700..768615b 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -18833,6 +18833,41 @@ struct safe_VkPipelineViewportDepthClampControlCreateInfoEXT {
         return reinterpret_cast<VkPipelineViewportDepthClampControlCreateInfoEXT const*>(this);
     }
 };
+struct safe_VkPhysicalDeviceHdrVividFeaturesHUAWEI {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 hdrVivid;
+
+    safe_VkPhysicalDeviceHdrVividFeaturesHUAWEI(const VkPhysicalDeviceHdrVividFeaturesHUAWEI* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceHdrVividFeaturesHUAWEI(const safe_VkPhysicalDeviceHdrVividFeaturesHUAWEI& copy_src);
+    safe_VkPhysicalDeviceHdrVividFeaturesHUAWEI& operator=(const safe_VkPhysicalDeviceHdrVividFeaturesHUAWEI& copy_src);
+    safe_VkPhysicalDeviceHdrVividFeaturesHUAWEI();
+    ~safe_VkPhysicalDeviceHdrVividFeaturesHUAWEI();
+    void initialize(const VkPhysicalDeviceHdrVividFeaturesHUAWEI* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceHdrVividFeaturesHUAWEI* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceHdrVividFeaturesHUAWEI* ptr() { return reinterpret_cast<VkPhysicalDeviceHdrVividFeaturesHUAWEI*>(this); }
+    VkPhysicalDeviceHdrVividFeaturesHUAWEI const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceHdrVividFeaturesHUAWEI const*>(this);
+    }
+};
+struct safe_VkHdrVividDynamicMetadataHUAWEI {
+    VkStructureType sType;
+    const void* pNext{};
+    size_t dynamicMetadataSize;
+    const void* pDynamicMetadata{};
+
+    safe_VkHdrVividDynamicMetadataHUAWEI(const VkHdrVividDynamicMetadataHUAWEI* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkHdrVividDynamicMetadataHUAWEI(const safe_VkHdrVividDynamicMetadataHUAWEI& copy_src);
+    safe_VkHdrVividDynamicMetadataHUAWEI& operator=(const safe_VkHdrVividDynamicMetadataHUAWEI& copy_src);
+    safe_VkHdrVividDynamicMetadataHUAWEI();
+    ~safe_VkHdrVividDynamicMetadataHUAWEI();
+    void initialize(const VkHdrVividDynamicMetadataHUAWEI* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkHdrVividDynamicMetadataHUAWEI* copy_src, PNextCopyState* copy_state = {});
+    VkHdrVividDynamicMetadataHUAWEI* ptr() { return reinterpret_cast<VkHdrVividDynamicMetadataHUAWEI*>(this); }
+    VkHdrVividDynamicMetadataHUAWEI const* ptr() const { return reinterpret_cast<VkHdrVividDynamicMetadataHUAWEI const*>(this); }
+};
 struct safe_VkCooperativeMatrixFlexibleDimensionsPropertiesNV {
     VkStructureType sType;
     void* pNext{};
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index ddba89b..1c711b5 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -985,6 +985,8 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceImageAlignmentContro
 template <> inline VkStructureType GetSType<VkImageAlignmentControlCreateInfoMESA>() { return VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceDepthClampControlFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkPipelineViewportDepthClampControlCreateInfoEXT>() { return VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceHdrVividFeaturesHUAWEI>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI; }
+template <> inline VkStructureType GetSType<VkHdrVividDynamicMetadataHUAWEI>() { return VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI; }
 template <> inline VkStructureType GetSType<VkCooperativeMatrixFlexibleDimensionsPropertiesNV>() { return VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeMatrix2FeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeMatrix2PropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index 340cba0..058eada 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -2002,6 +2002,10 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT";
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT:
             return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI";
+        case VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI:
+            return "VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV";
         case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV:
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 7a5d211..cbf87bf 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.3.300"
+            "commit": "v1.3.301"
         },
         {
             "name": "googletest",
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index f0c9df7..3f0b37c 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -1870,6 +1870,12 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT:
                 safe_pNext = new safe_VkPipelineViewportDepthClampControlCreateInfoEXT(reinterpret_cast<const VkPipelineViewportDepthClampControlCreateInfoEXT *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI:
+                safe_pNext = new safe_VkPhysicalDeviceHdrVividFeaturesHUAWEI(reinterpret_cast<const VkPhysicalDeviceHdrVividFeaturesHUAWEI *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI:
+                safe_pNext = new safe_VkHdrVividDynamicMetadataHUAWEI(reinterpret_cast<const VkHdrVividDynamicMetadataHUAWEI *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV:
                 safe_pNext = new safe_VkPhysicalDeviceCooperativeMatrix2FeaturesNV(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrix2FeaturesNV *>(pNext), copy_state, false);
                 break;
@@ -3762,6 +3768,12 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT:
             delete reinterpret_cast<safe_VkPipelineViewportDepthClampControlCreateInfoEXT *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI:
+            delete reinterpret_cast<safe_VkPhysicalDeviceHdrVividFeaturesHUAWEI *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI:
+            delete reinterpret_cast<safe_VkHdrVividDynamicMetadataHUAWEI *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV:
             delete reinterpret_cast<safe_VkPhysicalDeviceCooperativeMatrix2FeaturesNV *>(header);
             break;
diff --git a/src/vulkan/vk_safe_struct_vendor.cpp b/src/vulkan/vk_safe_struct_vendor.cpp
index 3fa04eb..bb764f1 100644
--- a/src/vulkan/vk_safe_struct_vendor.cpp
+++ b/src/vulkan/vk_safe_struct_vendor.cpp
@@ -15465,6 +15465,109 @@ void safe_VkImageAlignmentControlCreateInfoMESA::initialize(const safe_VkImageAl
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkPhysicalDeviceHdrVividFeaturesHUAWEI::safe_VkPhysicalDeviceHdrVividFeaturesHUAWEI(
+    const VkPhysicalDeviceHdrVividFeaturesHUAWEI* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), hdrVivid(in_struct->hdrVivid) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceHdrVividFeaturesHUAWEI::safe_VkPhysicalDeviceHdrVividFeaturesHUAWEI()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI), pNext(nullptr), hdrVivid() {}
+
+safe_VkPhysicalDeviceHdrVividFeaturesHUAWEI::safe_VkPhysicalDeviceHdrVividFeaturesHUAWEI(
+    const safe_VkPhysicalDeviceHdrVividFeaturesHUAWEI& copy_src) {
+    sType = copy_src.sType;
+    hdrVivid = copy_src.hdrVivid;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceHdrVividFeaturesHUAWEI& safe_VkPhysicalDeviceHdrVividFeaturesHUAWEI::operator=(
+    const safe_VkPhysicalDeviceHdrVividFeaturesHUAWEI& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    hdrVivid = copy_src.hdrVivid;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceHdrVividFeaturesHUAWEI::~safe_VkPhysicalDeviceHdrVividFeaturesHUAWEI() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceHdrVividFeaturesHUAWEI::initialize(const VkPhysicalDeviceHdrVividFeaturesHUAWEI* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    hdrVivid = in_struct->hdrVivid;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceHdrVividFeaturesHUAWEI::initialize(const safe_VkPhysicalDeviceHdrVividFeaturesHUAWEI* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    hdrVivid = copy_src->hdrVivid;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkHdrVividDynamicMetadataHUAWEI::safe_VkHdrVividDynamicMetadataHUAWEI(const VkHdrVividDynamicMetadataHUAWEI* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), dynamicMetadataSize(in_struct->dynamicMetadataSize), pDynamicMetadata(in_struct->pDynamicMetadata) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkHdrVividDynamicMetadataHUAWEI::safe_VkHdrVividDynamicMetadataHUAWEI()
+    : sType(VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI),
+      pNext(nullptr),
+      dynamicMetadataSize(),
+      pDynamicMetadata(nullptr) {}
+
+safe_VkHdrVividDynamicMetadataHUAWEI::safe_VkHdrVividDynamicMetadataHUAWEI(const safe_VkHdrVividDynamicMetadataHUAWEI& copy_src) {
+    sType = copy_src.sType;
+    dynamicMetadataSize = copy_src.dynamicMetadataSize;
+    pDynamicMetadata = copy_src.pDynamicMetadata;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkHdrVividDynamicMetadataHUAWEI& safe_VkHdrVividDynamicMetadataHUAWEI::operator=(
+    const safe_VkHdrVividDynamicMetadataHUAWEI& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    dynamicMetadataSize = copy_src.dynamicMetadataSize;
+    pDynamicMetadata = copy_src.pDynamicMetadata;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkHdrVividDynamicMetadataHUAWEI::~safe_VkHdrVividDynamicMetadataHUAWEI() { FreePnextChain(pNext); }
+
+void safe_VkHdrVividDynamicMetadataHUAWEI::initialize(const VkHdrVividDynamicMetadataHUAWEI* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    dynamicMetadataSize = in_struct->dynamicMetadataSize;
+    pDynamicMetadata = in_struct->pDynamicMetadata;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkHdrVividDynamicMetadataHUAWEI::initialize(const safe_VkHdrVividDynamicMetadataHUAWEI* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    dynamicMetadataSize = copy_src->dynamicMetadataSize;
+    pDynamicMetadata = copy_src->pDynamicMetadata;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkCooperativeMatrixFlexibleDimensionsPropertiesNV::safe_VkCooperativeMatrixFlexibleDimensionsPropertiesNV(
     const VkCooperativeMatrixFlexibleDimensionsPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
     bool copy_pnext)

From 9697d82a5703beb5d484fa508cdf01c2207356ab Mon Sep 17 00:00:00 2001
From: Spencer Fricke <115671160+spencer-lunarg@users.noreply.github.com>
Date: Mon, 4 Nov 2024 17:00:25 -0700
Subject: [PATCH 061/106] ci: Build dependency for Github Actions

---
 .github/workflows/ci.yml | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index c2946e2..afb3350 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,6 +1,6 @@
-# Copyright 2023 The Khronos Group Inc.
-# Copyright 2023 Valve Corporation
-# Copyright 2023 LunarG, Inc.
+# Copyright 2023-2024 The Khronos Group Inc.
+# Copyright 2023-2024 Valve Corporation
+# Copyright 2023-2024 LunarG, Inc.
 #
 # SPDX-License-Identifier: Apache-2.0
 
@@ -14,6 +14,8 @@ on:
 
 jobs:
   build_and_test:
+    # Use chromium as a test build, so don't run this job unless something simple works first
+    needs: chromium
     runs-on: ${{matrix.os}}
     strategy:
       matrix:
@@ -43,6 +45,8 @@ jobs:
         working-directory: build/
 
   windows-arm64:
+    # Use chromium as a test build, so don't run this job unless something simple works first
+    needs: chromium
     runs-on: windows-latest
     env:
       CMAKE_GENERATOR: Ninja
@@ -56,6 +60,8 @@ jobs:
       - run: cmake --install build --prefix build/install
  
   android:
+    # Use chromium as a test build, so don't run this job unless something simple works first
+    needs: chromium
     runs-on: ubuntu-22.04
     strategy:
       matrix:
@@ -90,6 +96,7 @@ jobs:
 
   # Test to ensure we don't accidentally break the Chromium build.
   chromium:
+    needs: generate_source
     runs-on: ubuntu-22.04
     steps:
       - uses: actions/checkout@v4

From 87ab6b39a97d084a2ef27db85e3cbaf5d2622a09 Mon Sep 17 00:00:00 2001
From: Jeremy Gebben <jeremyg@lunarg.com>
Date: Tue, 5 Nov 2024 08:42:11 -0700
Subject: [PATCH 062/106] scripts: Make generate_source.py look harder for
 vk.xml

Allow the registry path argument to also be the base directory
containing the Vulkan-Headers repo (eg. ./external) to save
redundant typing.
---
 scripts/generate_source.py | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/scripts/generate_source.py b/scripts/generate_source.py
index ee9fc36..01cf652 100755
--- a/scripts/generate_source.py
+++ b/scripts/generate_source.py
@@ -163,6 +163,12 @@ def main(argv):
     args = parser.parse_args(argv)
 
     registry = os.path.abspath(os.path.join(args.registry,  'vk.xml'))
+    if not os.path.isfile(registry):
+        registry = os.path.abspath(os.path.join(args.registry, 'Vulkan-Headers/registry/vk.xml'))
+        if not os.path.isfile(registry):
+            print(f'cannot find vk.xml in {args.registry}')
+            return -1
+
     RunGenerators(args.api, registry, args.target)
 
     return 0

From 247accd4ed34bb80c745a9c844a59cdc992bd7e9 Mon Sep 17 00:00:00 2001
From: Eric Werness <ewerness@nvidia.com>
Date: Wed, 13 Nov 2024 16:35:13 -0800
Subject: [PATCH 063/106] Traverse geometry pNext for safe structs

---
 src/vulkan/vk_safe_struct_manual.cpp | 49 ++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)

diff --git a/src/vulkan/vk_safe_struct_manual.cpp b/src/vulkan/vk_safe_struct_manual.cpp
index 2975fa8..9a4620f 100644
--- a/src/vulkan/vk_safe_struct_manual.cpp
+++ b/src/vulkan/vk_safe_struct_manual.cpp
@@ -47,6 +47,13 @@ safe_VkAccelerationStructureGeometryKHR::safe_VkAccelerationStructureGeometryKHR
     : sType(in_struct->sType), geometryType(in_struct->geometryType), geometry(in_struct->geometry), flags(in_struct->flags) {
     if (copy_pnext) {
         pNext = SafePnextCopy(in_struct->pNext, copy_state);
+        if (geometryType == VK_GEOMETRY_TYPE_INSTANCES_KHR) {
+            geometry.instances.pNext = SafePnextCopy(in_struct->geometry.instances.pNext, copy_state);
+        } else if (geometryType == VK_GEOMETRY_TYPE_TRIANGLES_KHR) {
+            geometry.triangles.pNext = SafePnextCopy(in_struct->geometry.triangles.pNext, copy_state);
+        } else if (geometryType == VK_GEOMETRY_TYPE_AABBS_KHR) {
+            geometry.aabbs.pNext = SafePnextCopy(in_struct->geometry.aabbs.pNext, copy_state);
+        }
     }
     if (is_host && geometryType == VK_GEOMETRY_TYPE_INSTANCES_KHR) {
         if (geometry.instances.arrayOfPointers) {
@@ -93,6 +100,13 @@ safe_VkAccelerationStructureGeometryKHR::safe_VkAccelerationStructureGeometryKHR
     flags = copy_src.flags;
 
     pNext = SafePnextCopy(copy_src.pNext);
+    if (geometryType == VK_GEOMETRY_TYPE_INSTANCES_KHR) {
+        geometry.instances.pNext = SafePnextCopy(copy_src.geometry.instances.pNext);
+    } else if (geometryType == VK_GEOMETRY_TYPE_TRIANGLES_KHR) {
+        geometry.triangles.pNext = SafePnextCopy(copy_src.geometry.triangles.pNext);
+    } else if (geometryType == VK_GEOMETRY_TYPE_AABBS_KHR) {
+        geometry.aabbs.pNext = SafePnextCopy(copy_src.geometry.aabbs.pNext);
+    }
     auto src_iter = GetAccelStructGeomHostAllocMap().find(&copy_src);
     if (src_iter != GetAccelStructGeomHostAllocMap().end()) {
         auto& src_alloc = src_iter->second;
@@ -133,6 +147,13 @@ safe_VkAccelerationStructureGeometryKHR& safe_VkAccelerationStructureGeometryKHR
         delete iter->second;
     }
     FreePnextChain(pNext);
+    if (geometryType == VK_GEOMETRY_TYPE_INSTANCES_KHR) {
+        FreePnextChain(geometry.instances.pNext);
+    } else if (geometryType == VK_GEOMETRY_TYPE_TRIANGLES_KHR) {
+        FreePnextChain(geometry.triangles.pNext);
+    } else if (geometryType == VK_GEOMETRY_TYPE_AABBS_KHR) {
+        FreePnextChain(geometry.aabbs.pNext);
+    }
 
     sType = copy_src.sType;
     geometryType = copy_src.geometryType;
@@ -140,6 +161,13 @@ safe_VkAccelerationStructureGeometryKHR& safe_VkAccelerationStructureGeometryKHR
     flags = copy_src.flags;
 
     pNext = SafePnextCopy(copy_src.pNext);
+    if (geometryType == VK_GEOMETRY_TYPE_INSTANCES_KHR) {
+        geometry.instances.pNext = SafePnextCopy(copy_src.geometry.instances.pNext);
+    } else if (geometryType == VK_GEOMETRY_TYPE_TRIANGLES_KHR) {
+        geometry.triangles.pNext = SafePnextCopy(copy_src.geometry.triangles.pNext);
+    } else if (geometryType == VK_GEOMETRY_TYPE_AABBS_KHR) {
+        geometry.aabbs.pNext = SafePnextCopy(copy_src.geometry.aabbs.pNext);
+    }
     auto src_iter = GetAccelStructGeomHostAllocMap().find(&copy_src);
     if (src_iter != GetAccelStructGeomHostAllocMap().end()) {
         auto& src_alloc = src_iter->second;
@@ -179,6 +207,13 @@ safe_VkAccelerationStructureGeometryKHR::~safe_VkAccelerationStructureGeometryKH
         delete iter->second;
     }
     FreePnextChain(pNext);
+    if (geometryType == VK_GEOMETRY_TYPE_INSTANCES_KHR) {
+        FreePnextChain(geometry.instances.pNext);
+    } else if (geometryType == VK_GEOMETRY_TYPE_TRIANGLES_KHR) {
+        FreePnextChain(geometry.triangles.pNext);
+    } else if (geometryType == VK_GEOMETRY_TYPE_AABBS_KHR) {
+        FreePnextChain(geometry.aabbs.pNext);
+    }
 }
 
 void safe_VkAccelerationStructureGeometryKHR::initialize(const VkAccelerationStructureGeometryKHR* in_struct, const bool is_host,
@@ -189,6 +224,13 @@ void safe_VkAccelerationStructureGeometryKHR::initialize(const VkAccelerationStr
         delete iter->second;
     }
     FreePnextChain(pNext);
+    if (geometryType == VK_GEOMETRY_TYPE_INSTANCES_KHR) {
+        FreePnextChain(geometry.instances.pNext);
+    } else if (geometryType == VK_GEOMETRY_TYPE_TRIANGLES_KHR) {
+        FreePnextChain(geometry.triangles.pNext);
+    } else if (geometryType == VK_GEOMETRY_TYPE_AABBS_KHR) {
+        FreePnextChain(geometry.aabbs.pNext);
+    }
     sType = in_struct->sType;
     geometryType = in_struct->geometryType;
     geometry = in_struct->geometry;
@@ -237,6 +279,13 @@ void safe_VkAccelerationStructureGeometryKHR::initialize(const safe_VkAccelerati
     flags = copy_src->flags;
 
     pNext = SafePnextCopy(copy_src->pNext);
+    if (geometryType == VK_GEOMETRY_TYPE_INSTANCES_KHR) {
+        geometry.instances.pNext = SafePnextCopy(copy_src->geometry.instances.pNext, copy_state);
+    } else if (geometryType == VK_GEOMETRY_TYPE_TRIANGLES_KHR) {
+        geometry.triangles.pNext = SafePnextCopy(copy_src->geometry.triangles.pNext, copy_state);
+    } else if (geometryType == VK_GEOMETRY_TYPE_AABBS_KHR) {
+        geometry.aabbs.pNext = SafePnextCopy(copy_src->geometry.aabbs.pNext, copy_state);
+    }
     auto src_iter = GetAccelStructGeomHostAllocMap().find(copy_src);
     if (src_iter != GetAccelStructGeomHostAllocMap().end()) {
         auto& src_alloc = src_iter->second;

From c31e717dcd817279e9e90516612f9dbfc84b0e51 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 18 Nov 2024 16:04:10 +0000
Subject: [PATCH 064/106] build(deps): Bump fsfe/reuse-action from 4 to 5

Bumps [fsfe/reuse-action](https://github.com/fsfe/reuse-action) from 4 to 5.
- [Release notes](https://github.com/fsfe/reuse-action/releases)
- [Commits](https://github.com/fsfe/reuse-action/compare/v4...v5)

---
updated-dependencies:
- dependency-name: fsfe/reuse-action
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 .github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index afb3350..4d71374 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -92,7 +92,7 @@ jobs:
     steps:
     - uses: actions/checkout@v4
     - name: REUSE Compliance Check
-      uses: fsfe/reuse-action@v4
+      uses: fsfe/reuse-action@v5
 
   # Test to ensure we don't accidentally break the Chromium build.
   chromium:

From b538fb5b08513aa78346cd414ad5e576a2a3e920 Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Thu, 21 Nov 2024 06:56:02 -0800
Subject: [PATCH 065/106] build: Update to header 1.3.302

---
 include/vulkan/utility/vk_dispatch_table.h  |    2 +
 include/vulkan/utility/vk_safe_struct.hpp   |  537 +++++++
 include/vulkan/utility/vk_struct_helper.hpp |   25 +
 include/vulkan/vk_enum_string_helper.h      |  286 ++++
 scripts/known_good.json                     |    2 +-
 src/vulkan/vk_safe_struct_ext.cpp           |   53 +
 src/vulkan/vk_safe_struct_khr.cpp           | 1562 +++++++++++++++++++
 src/vulkan/vk_safe_struct_utils.cpp         |  150 ++
 src/vulkan/vk_safe_struct_vendor.cpp        |  144 ++
 9 files changed, 2760 insertions(+), 1 deletion(-)

diff --git a/include/vulkan/utility/vk_dispatch_table.h b/include/vulkan/utility/vk_dispatch_table.h
index 3d81ed5..dcd4f4b 100644
--- a/include/vulkan/utility/vk_dispatch_table.h
+++ b/include/vulkan/utility/vk_dispatch_table.h
@@ -490,6 +490,7 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkDestroyCuFunctionNVX DestroyCuFunctionNVX;
     PFN_vkCmdCuLaunchKernelNVX CmdCuLaunchKernelNVX;
     PFN_vkGetImageViewHandleNVX GetImageViewHandleNVX;
+    PFN_vkGetImageViewHandle64NVX GetImageViewHandle64NVX;
     PFN_vkGetImageViewAddressNVX GetImageViewAddressNVX;
     PFN_vkCmdDrawIndirectCountAMD CmdDrawIndirectCountAMD;
     PFN_vkCmdDrawIndexedIndirectCountAMD CmdDrawIndexedIndirectCountAMD;
@@ -1102,6 +1103,7 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
     table->DestroyCuFunctionNVX = (PFN_vkDestroyCuFunctionNVX)gdpa(device, "vkDestroyCuFunctionNVX");
     table->CmdCuLaunchKernelNVX = (PFN_vkCmdCuLaunchKernelNVX)gdpa(device, "vkCmdCuLaunchKernelNVX");
     table->GetImageViewHandleNVX = (PFN_vkGetImageViewHandleNVX)gdpa(device, "vkGetImageViewHandleNVX");
+    table->GetImageViewHandle64NVX = (PFN_vkGetImageViewHandle64NVX)gdpa(device, "vkGetImageViewHandle64NVX");
     table->GetImageViewAddressNVX = (PFN_vkGetImageViewAddressNVX)gdpa(device, "vkGetImageViewAddressNVX");
     table->CmdDrawIndirectCountAMD = (PFN_vkCmdDrawIndirectCountAMD)gdpa(device, "vkCmdDrawIndirectCountAMD");
     table->CmdDrawIndexedIndirectCountAMD = (PFN_vkCmdDrawIndexedIndirectCountAMD)gdpa(device, "vkCmdDrawIndexedIndirectCountAMD");
diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index 768615b..39f4ff4 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -8229,6 +8229,258 @@ struct safe_VkVideoDecodeAV1DpbSlotInfoKHR {
     VkVideoDecodeAV1DpbSlotInfoKHR* ptr() { return reinterpret_cast<VkVideoDecodeAV1DpbSlotInfoKHR*>(this); }
     VkVideoDecodeAV1DpbSlotInfoKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeAV1DpbSlotInfoKHR const*>(this); }
 };
+struct safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 videoEncodeAV1;
+
+    safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR(const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR(const safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR& operator=(const safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR();
+    ~safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR();
+    void initialize(const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVideoEncodeAV1FeaturesKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceVideoEncodeAV1FeaturesKHR*>(this); }
+    VkPhysicalDeviceVideoEncodeAV1FeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceVideoEncodeAV1FeaturesKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeAV1CapabilitiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkVideoEncodeAV1CapabilityFlagsKHR flags;
+    StdVideoAV1Level maxLevel;
+    VkExtent2D codedPictureAlignment;
+    VkExtent2D maxTiles;
+    VkExtent2D minTileSize;
+    VkExtent2D maxTileSize;
+    VkVideoEncodeAV1SuperblockSizeFlagsKHR superblockSizes;
+    uint32_t maxSingleReferenceCount;
+    uint32_t singleReferenceNameMask;
+    uint32_t maxUnidirectionalCompoundReferenceCount;
+    uint32_t maxUnidirectionalCompoundGroup1ReferenceCount;
+    uint32_t unidirectionalCompoundReferenceNameMask;
+    uint32_t maxBidirectionalCompoundReferenceCount;
+    uint32_t maxBidirectionalCompoundGroup1ReferenceCount;
+    uint32_t maxBidirectionalCompoundGroup2ReferenceCount;
+    uint32_t bidirectionalCompoundReferenceNameMask;
+    uint32_t maxTemporalLayerCount;
+    uint32_t maxSpatialLayerCount;
+    uint32_t maxOperatingPoints;
+    uint32_t minQIndex;
+    uint32_t maxQIndex;
+    VkBool32 prefersGopRemainingFrames;
+    VkBool32 requiresGopRemainingFrames;
+    VkVideoEncodeAV1StdFlagsKHR stdSyntaxFlags;
+
+    safe_VkVideoEncodeAV1CapabilitiesKHR(const VkVideoEncodeAV1CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkVideoEncodeAV1CapabilitiesKHR(const safe_VkVideoEncodeAV1CapabilitiesKHR& copy_src);
+    safe_VkVideoEncodeAV1CapabilitiesKHR& operator=(const safe_VkVideoEncodeAV1CapabilitiesKHR& copy_src);
+    safe_VkVideoEncodeAV1CapabilitiesKHR();
+    ~safe_VkVideoEncodeAV1CapabilitiesKHR();
+    void initialize(const VkVideoEncodeAV1CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeAV1CapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeAV1CapabilitiesKHR* ptr() { return reinterpret_cast<VkVideoEncodeAV1CapabilitiesKHR*>(this); }
+    VkVideoEncodeAV1CapabilitiesKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeAV1CapabilitiesKHR const*>(this); }
+};
+struct safe_VkVideoEncodeAV1QualityLevelPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkVideoEncodeAV1RateControlFlagsKHR preferredRateControlFlags;
+    uint32_t preferredGopFrameCount;
+    uint32_t preferredKeyFramePeriod;
+    uint32_t preferredConsecutiveBipredictiveFrameCount;
+    uint32_t preferredTemporalLayerCount;
+    VkVideoEncodeAV1QIndexKHR preferredConstantQIndex;
+    uint32_t preferredMaxSingleReferenceCount;
+    uint32_t preferredSingleReferenceNameMask;
+    uint32_t preferredMaxUnidirectionalCompoundReferenceCount;
+    uint32_t preferredMaxUnidirectionalCompoundGroup1ReferenceCount;
+    uint32_t preferredUnidirectionalCompoundReferenceNameMask;
+    uint32_t preferredMaxBidirectionalCompoundReferenceCount;
+    uint32_t preferredMaxBidirectionalCompoundGroup1ReferenceCount;
+    uint32_t preferredMaxBidirectionalCompoundGroup2ReferenceCount;
+    uint32_t preferredBidirectionalCompoundReferenceNameMask;
+
+    safe_VkVideoEncodeAV1QualityLevelPropertiesKHR(const VkVideoEncodeAV1QualityLevelPropertiesKHR* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEncodeAV1QualityLevelPropertiesKHR(const safe_VkVideoEncodeAV1QualityLevelPropertiesKHR& copy_src);
+    safe_VkVideoEncodeAV1QualityLevelPropertiesKHR& operator=(const safe_VkVideoEncodeAV1QualityLevelPropertiesKHR& copy_src);
+    safe_VkVideoEncodeAV1QualityLevelPropertiesKHR();
+    ~safe_VkVideoEncodeAV1QualityLevelPropertiesKHR();
+    void initialize(const VkVideoEncodeAV1QualityLevelPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeAV1QualityLevelPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeAV1QualityLevelPropertiesKHR* ptr() { return reinterpret_cast<VkVideoEncodeAV1QualityLevelPropertiesKHR*>(this); }
+    VkVideoEncodeAV1QualityLevelPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeAV1QualityLevelPropertiesKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeAV1SessionCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 useMaxLevel;
+    StdVideoAV1Level maxLevel;
+
+    safe_VkVideoEncodeAV1SessionCreateInfoKHR(const VkVideoEncodeAV1SessionCreateInfoKHR* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEncodeAV1SessionCreateInfoKHR(const safe_VkVideoEncodeAV1SessionCreateInfoKHR& copy_src);
+    safe_VkVideoEncodeAV1SessionCreateInfoKHR& operator=(const safe_VkVideoEncodeAV1SessionCreateInfoKHR& copy_src);
+    safe_VkVideoEncodeAV1SessionCreateInfoKHR();
+    ~safe_VkVideoEncodeAV1SessionCreateInfoKHR();
+    void initialize(const VkVideoEncodeAV1SessionCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeAV1SessionCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeAV1SessionCreateInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeAV1SessionCreateInfoKHR*>(this); }
+    VkVideoEncodeAV1SessionCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeAV1SessionCreateInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    const StdVideoAV1SequenceHeader* pStdSequenceHeader{};
+    const StdVideoEncodeAV1DecoderModelInfo* pStdDecoderModelInfo{};
+    uint32_t stdOperatingPointCount;
+    const StdVideoEncodeAV1OperatingPointInfo* pStdOperatingPoints{};
+
+    safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR(const VkVideoEncodeAV1SessionParametersCreateInfoKHR* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR(const safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR& copy_src);
+    safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR& operator=(
+        const safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR& copy_src);
+    safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR();
+    ~safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR();
+    void initialize(const VkVideoEncodeAV1SessionParametersCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeAV1SessionParametersCreateInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoEncodeAV1SessionParametersCreateInfoKHR*>(this);
+    }
+    VkVideoEncodeAV1SessionParametersCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeAV1SessionParametersCreateInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeAV1PictureInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkVideoEncodeAV1PredictionModeKHR predictionMode;
+    VkVideoEncodeAV1RateControlGroupKHR rateControlGroup;
+    uint32_t constantQIndex;
+    const StdVideoEncodeAV1PictureInfo* pStdPictureInfo{};
+    int32_t referenceNameSlotIndices[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR];
+    VkBool32 primaryReferenceCdfOnly;
+    VkBool32 generateObuExtensionHeader;
+
+    safe_VkVideoEncodeAV1PictureInfoKHR(const VkVideoEncodeAV1PictureInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkVideoEncodeAV1PictureInfoKHR(const safe_VkVideoEncodeAV1PictureInfoKHR& copy_src);
+    safe_VkVideoEncodeAV1PictureInfoKHR& operator=(const safe_VkVideoEncodeAV1PictureInfoKHR& copy_src);
+    safe_VkVideoEncodeAV1PictureInfoKHR();
+    ~safe_VkVideoEncodeAV1PictureInfoKHR();
+    void initialize(const VkVideoEncodeAV1PictureInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeAV1PictureInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeAV1PictureInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeAV1PictureInfoKHR*>(this); }
+    VkVideoEncodeAV1PictureInfoKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeAV1PictureInfoKHR const*>(this); }
+};
+struct safe_VkVideoEncodeAV1DpbSlotInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    const StdVideoEncodeAV1ReferenceInfo* pStdReferenceInfo{};
+
+    safe_VkVideoEncodeAV1DpbSlotInfoKHR(const VkVideoEncodeAV1DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkVideoEncodeAV1DpbSlotInfoKHR(const safe_VkVideoEncodeAV1DpbSlotInfoKHR& copy_src);
+    safe_VkVideoEncodeAV1DpbSlotInfoKHR& operator=(const safe_VkVideoEncodeAV1DpbSlotInfoKHR& copy_src);
+    safe_VkVideoEncodeAV1DpbSlotInfoKHR();
+    ~safe_VkVideoEncodeAV1DpbSlotInfoKHR();
+    void initialize(const VkVideoEncodeAV1DpbSlotInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeAV1DpbSlotInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeAV1DpbSlotInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeAV1DpbSlotInfoKHR*>(this); }
+    VkVideoEncodeAV1DpbSlotInfoKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeAV1DpbSlotInfoKHR const*>(this); }
+};
+struct safe_VkVideoEncodeAV1ProfileInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    StdVideoAV1Profile stdProfile;
+
+    safe_VkVideoEncodeAV1ProfileInfoKHR(const VkVideoEncodeAV1ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkVideoEncodeAV1ProfileInfoKHR(const safe_VkVideoEncodeAV1ProfileInfoKHR& copy_src);
+    safe_VkVideoEncodeAV1ProfileInfoKHR& operator=(const safe_VkVideoEncodeAV1ProfileInfoKHR& copy_src);
+    safe_VkVideoEncodeAV1ProfileInfoKHR();
+    ~safe_VkVideoEncodeAV1ProfileInfoKHR();
+    void initialize(const VkVideoEncodeAV1ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeAV1ProfileInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeAV1ProfileInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeAV1ProfileInfoKHR*>(this); }
+    VkVideoEncodeAV1ProfileInfoKHR const* ptr() const { return reinterpret_cast<VkVideoEncodeAV1ProfileInfoKHR const*>(this); }
+};
+struct safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 useGopRemainingFrames;
+    uint32_t gopRemainingIntra;
+    uint32_t gopRemainingPredictive;
+    uint32_t gopRemainingBipredictive;
+
+    safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR(const VkVideoEncodeAV1GopRemainingFrameInfoKHR* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR(const safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR& copy_src);
+    safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR& operator=(const safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR& copy_src);
+    safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR();
+    ~safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR();
+    void initialize(const VkVideoEncodeAV1GopRemainingFrameInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeAV1GopRemainingFrameInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeAV1GopRemainingFrameInfoKHR*>(this); }
+    VkVideoEncodeAV1GopRemainingFrameInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeAV1GopRemainingFrameInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeAV1RateControlInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkVideoEncodeAV1RateControlFlagsKHR flags;
+    uint32_t gopFrameCount;
+    uint32_t keyFramePeriod;
+    uint32_t consecutiveBipredictiveFrameCount;
+    uint32_t temporalLayerCount;
+
+    safe_VkVideoEncodeAV1RateControlInfoKHR(const VkVideoEncodeAV1RateControlInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                            bool copy_pnext = true);
+    safe_VkVideoEncodeAV1RateControlInfoKHR(const safe_VkVideoEncodeAV1RateControlInfoKHR& copy_src);
+    safe_VkVideoEncodeAV1RateControlInfoKHR& operator=(const safe_VkVideoEncodeAV1RateControlInfoKHR& copy_src);
+    safe_VkVideoEncodeAV1RateControlInfoKHR();
+    ~safe_VkVideoEncodeAV1RateControlInfoKHR();
+    void initialize(const VkVideoEncodeAV1RateControlInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeAV1RateControlInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeAV1RateControlInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeAV1RateControlInfoKHR*>(this); }
+    VkVideoEncodeAV1RateControlInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeAV1RateControlInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeAV1RateControlLayerInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 useMinQIndex;
+    VkVideoEncodeAV1QIndexKHR minQIndex;
+    VkBool32 useMaxQIndex;
+    VkVideoEncodeAV1QIndexKHR maxQIndex;
+    VkBool32 useMaxFrameSize;
+    VkVideoEncodeAV1FrameSizeKHR maxFrameSize;
+
+    safe_VkVideoEncodeAV1RateControlLayerInfoKHR(const VkVideoEncodeAV1RateControlLayerInfoKHR* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEncodeAV1RateControlLayerInfoKHR(const safe_VkVideoEncodeAV1RateControlLayerInfoKHR& copy_src);
+    safe_VkVideoEncodeAV1RateControlLayerInfoKHR& operator=(const safe_VkVideoEncodeAV1RateControlLayerInfoKHR& copy_src);
+    safe_VkVideoEncodeAV1RateControlLayerInfoKHR();
+    ~safe_VkVideoEncodeAV1RateControlLayerInfoKHR();
+    void initialize(const VkVideoEncodeAV1RateControlLayerInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeAV1RateControlLayerInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeAV1RateControlLayerInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeAV1RateControlLayerInfoKHR*>(this); }
+    VkVideoEncodeAV1RateControlLayerInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeAV1RateControlLayerInfoKHR const*>(this);
+    }
+};
 struct safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR {
     VkStructureType sType;
     void* pNext{};
@@ -8661,6 +8913,217 @@ struct safe_VkBindDescriptorBufferEmbeddedSamplersInfoEXT {
         return reinterpret_cast<VkBindDescriptorBufferEmbeddedSamplersInfoEXT const*>(this);
     }
 };
+struct safe_VkVideoEncodeQuantizationMapCapabilitiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkExtent2D maxQuantizationMapExtent;
+
+    safe_VkVideoEncodeQuantizationMapCapabilitiesKHR(const VkVideoEncodeQuantizationMapCapabilitiesKHR* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEncodeQuantizationMapCapabilitiesKHR(const safe_VkVideoEncodeQuantizationMapCapabilitiesKHR& copy_src);
+    safe_VkVideoEncodeQuantizationMapCapabilitiesKHR& operator=(const safe_VkVideoEncodeQuantizationMapCapabilitiesKHR& copy_src);
+    safe_VkVideoEncodeQuantizationMapCapabilitiesKHR();
+    ~safe_VkVideoEncodeQuantizationMapCapabilitiesKHR();
+    void initialize(const VkVideoEncodeQuantizationMapCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeQuantizationMapCapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeQuantizationMapCapabilitiesKHR* ptr() {
+        return reinterpret_cast<VkVideoEncodeQuantizationMapCapabilitiesKHR*>(this);
+    }
+    VkVideoEncodeQuantizationMapCapabilitiesKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeQuantizationMapCapabilitiesKHR const*>(this);
+    }
+};
+struct safe_VkVideoFormatQuantizationMapPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkExtent2D quantizationMapTexelSize;
+
+    safe_VkVideoFormatQuantizationMapPropertiesKHR(const VkVideoFormatQuantizationMapPropertiesKHR* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoFormatQuantizationMapPropertiesKHR(const safe_VkVideoFormatQuantizationMapPropertiesKHR& copy_src);
+    safe_VkVideoFormatQuantizationMapPropertiesKHR& operator=(const safe_VkVideoFormatQuantizationMapPropertiesKHR& copy_src);
+    safe_VkVideoFormatQuantizationMapPropertiesKHR();
+    ~safe_VkVideoFormatQuantizationMapPropertiesKHR();
+    void initialize(const VkVideoFormatQuantizationMapPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoFormatQuantizationMapPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoFormatQuantizationMapPropertiesKHR* ptr() { return reinterpret_cast<VkVideoFormatQuantizationMapPropertiesKHR*>(this); }
+    VkVideoFormatQuantizationMapPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkVideoFormatQuantizationMapPropertiesKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeQuantizationMapInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImageView quantizationMap;
+    VkExtent2D quantizationMapExtent;
+
+    safe_VkVideoEncodeQuantizationMapInfoKHR(const VkVideoEncodeQuantizationMapInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkVideoEncodeQuantizationMapInfoKHR(const safe_VkVideoEncodeQuantizationMapInfoKHR& copy_src);
+    safe_VkVideoEncodeQuantizationMapInfoKHR& operator=(const safe_VkVideoEncodeQuantizationMapInfoKHR& copy_src);
+    safe_VkVideoEncodeQuantizationMapInfoKHR();
+    ~safe_VkVideoEncodeQuantizationMapInfoKHR();
+    void initialize(const VkVideoEncodeQuantizationMapInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeQuantizationMapInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeQuantizationMapInfoKHR* ptr() { return reinterpret_cast<VkVideoEncodeQuantizationMapInfoKHR*>(this); }
+    VkVideoEncodeQuantizationMapInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeQuantizationMapInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExtent2D quantizationMapTexelSize;
+
+    safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR(
+        const VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR(
+        const safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR& copy_src);
+    safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR& operator=(
+        const safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR& copy_src);
+    safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR();
+    ~safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR();
+    void initialize(const VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR* copy_src,
+                    PNextCopyState* copy_state = {});
+    VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR*>(this);
+    }
+    VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 videoEncodeQuantizationMap;
+
+    safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR(
+        const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR(
+        const safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR& operator=(
+        const safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR();
+    ~safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR();
+    void initialize(const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    int32_t minQpDelta;
+    int32_t maxQpDelta;
+
+    safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR(const VkVideoEncodeH264QuantizationMapCapabilitiesKHR* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR(const safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR& copy_src);
+    safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR& operator=(
+        const safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR& copy_src);
+    safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR();
+    ~safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR();
+    void initialize(const VkVideoEncodeH264QuantizationMapCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH264QuantizationMapCapabilitiesKHR* ptr() {
+        return reinterpret_cast<VkVideoEncodeH264QuantizationMapCapabilitiesKHR*>(this);
+    }
+    VkVideoEncodeH264QuantizationMapCapabilitiesKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH264QuantizationMapCapabilitiesKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    int32_t minQpDelta;
+    int32_t maxQpDelta;
+
+    safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR(const VkVideoEncodeH265QuantizationMapCapabilitiesKHR* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR(const safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR& copy_src);
+    safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR& operator=(
+        const safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR& copy_src);
+    safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR();
+    ~safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR();
+    void initialize(const VkVideoEncodeH265QuantizationMapCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeH265QuantizationMapCapabilitiesKHR* ptr() {
+        return reinterpret_cast<VkVideoEncodeH265QuantizationMapCapabilitiesKHR*>(this);
+    }
+    VkVideoEncodeH265QuantizationMapCapabilitiesKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeH265QuantizationMapCapabilitiesKHR const*>(this);
+    }
+};
+struct safe_VkVideoFormatH265QuantizationMapPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkVideoEncodeH265CtbSizeFlagsKHR compatibleCtbSizes;
+
+    safe_VkVideoFormatH265QuantizationMapPropertiesKHR(const VkVideoFormatH265QuantizationMapPropertiesKHR* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoFormatH265QuantizationMapPropertiesKHR(const safe_VkVideoFormatH265QuantizationMapPropertiesKHR& copy_src);
+    safe_VkVideoFormatH265QuantizationMapPropertiesKHR& operator=(
+        const safe_VkVideoFormatH265QuantizationMapPropertiesKHR& copy_src);
+    safe_VkVideoFormatH265QuantizationMapPropertiesKHR();
+    ~safe_VkVideoFormatH265QuantizationMapPropertiesKHR();
+    void initialize(const VkVideoFormatH265QuantizationMapPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoFormatH265QuantizationMapPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoFormatH265QuantizationMapPropertiesKHR* ptr() {
+        return reinterpret_cast<VkVideoFormatH265QuantizationMapPropertiesKHR*>(this);
+    }
+    VkVideoFormatH265QuantizationMapPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkVideoFormatH265QuantizationMapPropertiesKHR const*>(this);
+    }
+};
+struct safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    int32_t minQIndexDelta;
+    int32_t maxQIndexDelta;
+
+    safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR(const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR(const safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR& copy_src);
+    safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR& operator=(
+        const safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR& copy_src);
+    safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR();
+    ~safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR();
+    void initialize(const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoEncodeAV1QuantizationMapCapabilitiesKHR* ptr() {
+        return reinterpret_cast<VkVideoEncodeAV1QuantizationMapCapabilitiesKHR*>(this);
+    }
+    VkVideoEncodeAV1QuantizationMapCapabilitiesKHR const* ptr() const {
+        return reinterpret_cast<VkVideoEncodeAV1QuantizationMapCapabilitiesKHR const*>(this);
+    }
+};
+struct safe_VkVideoFormatAV1QuantizationMapPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkVideoEncodeAV1SuperblockSizeFlagsKHR compatibleSuperblockSizes;
+
+    safe_VkVideoFormatAV1QuantizationMapPropertiesKHR(const VkVideoFormatAV1QuantizationMapPropertiesKHR* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoFormatAV1QuantizationMapPropertiesKHR(const safe_VkVideoFormatAV1QuantizationMapPropertiesKHR& copy_src);
+    safe_VkVideoFormatAV1QuantizationMapPropertiesKHR& operator=(const safe_VkVideoFormatAV1QuantizationMapPropertiesKHR& copy_src);
+    safe_VkVideoFormatAV1QuantizationMapPropertiesKHR();
+    ~safe_VkVideoFormatAV1QuantizationMapPropertiesKHR();
+    void initialize(const VkVideoFormatAV1QuantizationMapPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoFormatAV1QuantizationMapPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoFormatAV1QuantizationMapPropertiesKHR* ptr() {
+        return reinterpret_cast<VkVideoFormatAV1QuantizationMapPropertiesKHR*>(this);
+    }
+    VkVideoFormatAV1QuantizationMapPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkVideoFormatAV1QuantizationMapPropertiesKHR const*>(this);
+    }
+};
 struct safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR {
     VkStructureType sType;
     void* pNext{};
@@ -9031,6 +9494,24 @@ struct safe_VkCuModuleCreateInfoNVX {
     VkCuModuleCreateInfoNVX* ptr() { return reinterpret_cast<VkCuModuleCreateInfoNVX*>(this); }
     VkCuModuleCreateInfoNVX const* ptr() const { return reinterpret_cast<VkCuModuleCreateInfoNVX const*>(this); }
 };
+struct safe_VkCuModuleTexturingModeCreateInfoNVX {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 use64bitTexturing;
+
+    safe_VkCuModuleTexturingModeCreateInfoNVX(const VkCuModuleTexturingModeCreateInfoNVX* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkCuModuleTexturingModeCreateInfoNVX(const safe_VkCuModuleTexturingModeCreateInfoNVX& copy_src);
+    safe_VkCuModuleTexturingModeCreateInfoNVX& operator=(const safe_VkCuModuleTexturingModeCreateInfoNVX& copy_src);
+    safe_VkCuModuleTexturingModeCreateInfoNVX();
+    ~safe_VkCuModuleTexturingModeCreateInfoNVX();
+    void initialize(const VkCuModuleTexturingModeCreateInfoNVX* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCuModuleTexturingModeCreateInfoNVX* copy_src, PNextCopyState* copy_state = {});
+    VkCuModuleTexturingModeCreateInfoNVX* ptr() { return reinterpret_cast<VkCuModuleTexturingModeCreateInfoNVX*>(this); }
+    VkCuModuleTexturingModeCreateInfoNVX const* ptr() const {
+        return reinterpret_cast<VkCuModuleTexturingModeCreateInfoNVX const*>(this);
+    }
+};
 struct safe_VkCuFunctionCreateInfoNVX {
     VkStructureType sType;
     const void* pNext{};
@@ -18326,6 +18807,40 @@ struct safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV {
         return reinterpret_cast<VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV const*>(this);
     }
 };
+struct safe_VkDisplaySurfaceStereoCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDisplaySurfaceStereoTypeNV stereoType;
+
+    safe_VkDisplaySurfaceStereoCreateInfoNV(const VkDisplaySurfaceStereoCreateInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                            bool copy_pnext = true);
+    safe_VkDisplaySurfaceStereoCreateInfoNV(const safe_VkDisplaySurfaceStereoCreateInfoNV& copy_src);
+    safe_VkDisplaySurfaceStereoCreateInfoNV& operator=(const safe_VkDisplaySurfaceStereoCreateInfoNV& copy_src);
+    safe_VkDisplaySurfaceStereoCreateInfoNV();
+    ~safe_VkDisplaySurfaceStereoCreateInfoNV();
+    void initialize(const VkDisplaySurfaceStereoCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDisplaySurfaceStereoCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkDisplaySurfaceStereoCreateInfoNV* ptr() { return reinterpret_cast<VkDisplaySurfaceStereoCreateInfoNV*>(this); }
+    VkDisplaySurfaceStereoCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkDisplaySurfaceStereoCreateInfoNV const*>(this);
+    }
+};
+struct safe_VkDisplayModeStereoPropertiesNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 hdmi3DSupported;
+
+    safe_VkDisplayModeStereoPropertiesNV(const VkDisplayModeStereoPropertiesNV* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkDisplayModeStereoPropertiesNV(const safe_VkDisplayModeStereoPropertiesNV& copy_src);
+    safe_VkDisplayModeStereoPropertiesNV& operator=(const safe_VkDisplayModeStereoPropertiesNV& copy_src);
+    safe_VkDisplayModeStereoPropertiesNV();
+    ~safe_VkDisplayModeStereoPropertiesNV();
+    void initialize(const VkDisplayModeStereoPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDisplayModeStereoPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkDisplayModeStereoPropertiesNV* ptr() { return reinterpret_cast<VkDisplayModeStereoPropertiesNV*>(this); }
+    VkDisplayModeStereoPropertiesNV const* ptr() const { return reinterpret_cast<VkDisplayModeStereoPropertiesNV const*>(this); }
+};
 struct safe_VkPhysicalDeviceRawAccessChainsFeaturesNV {
     VkStructureType sType;
     void* pNext{};
@@ -18947,6 +19462,28 @@ struct safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV {
         return reinterpret_cast<VkPhysicalDeviceCooperativeMatrix2PropertiesNV const*>(this);
     }
 };
+struct safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 vertexAttributeRobustness;
+
+    safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT* in_struct,
+                                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(
+        const safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT();
+    ~safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT();
+    void initialize(const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT const*>(this);
+    }
+};
 struct safe_VkAccelerationStructureGeometryTrianglesDataKHR {
     VkStructureType sType;
     const void* pNext{};
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index 1c711b5..f5a10d1 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -439,6 +439,17 @@ template <> inline VkStructureType GetSType<VkVideoDecodeAV1CapabilitiesKHR>() {
 template <> inline VkStructureType GetSType<VkVideoDecodeAV1SessionParametersCreateInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkVideoDecodeAV1PictureInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkVideoDecodeAV1DpbSlotInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceVideoEncodeAV1FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeAV1CapabilitiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeAV1QualityLevelPropertiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeAV1SessionCreateInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeAV1SessionParametersCreateInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeAV1PictureInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeAV1DpbSlotInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeAV1ProfileInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeAV1GopRemainingFrameInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeAV1RateControlInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeAV1RateControlLayerInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceVideoMaintenance1FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkVideoInlineQueryInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR; }
@@ -460,6 +471,16 @@ template <> inline VkStructureType GetSType<VkPushDescriptorSetInfoKHR>() { retu
 template <> inline VkStructureType GetSType<VkPushDescriptorSetWithTemplateInfoKHR>() { return VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkSetDescriptorBufferOffsetsInfoEXT>() { return VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkBindDescriptorBufferEmbeddedSamplersInfoEXT>() { return VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT; }
+template <> inline VkStructureType GetSType<VkVideoEncodeQuantizationMapCapabilitiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR; }
+template <> inline VkStructureType GetSType<VkVideoFormatQuantizationMapPropertiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeQuantizationMapInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeH264QuantizationMapCapabilitiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeH265QuantizationMapCapabilitiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR; }
+template <> inline VkStructureType GetSType<VkVideoFormatH265QuantizationMapPropertiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR; }
+template <> inline VkStructureType GetSType<VkVideoEncodeAV1QuantizationMapCapabilitiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR; }
+template <> inline VkStructureType GetSType<VkVideoFormatAV1QuantizationMapPropertiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance7FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance7PropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR; }
@@ -478,6 +499,7 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceTransformFeedbackFea
 template <> inline VkStructureType GetSType<VkPhysicalDeviceTransformFeedbackPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT; }
 template <> inline VkStructureType GetSType<VkPipelineRasterizationStateStreamCreateInfoEXT>() { return VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkCuModuleCreateInfoNVX>() { return VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX; }
+template <> inline VkStructureType GetSType<VkCuModuleTexturingModeCreateInfoNVX>() { return VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX; }
 template <> inline VkStructureType GetSType<VkCuFunctionCreateInfoNVX>() { return VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX; }
 template <> inline VkStructureType GetSType<VkCuLaunchInfoNVX>() { return VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX; }
 template <> inline VkStructureType GetSType<VkImageViewHandleInfoNVX>() { return VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX; }
@@ -961,6 +983,8 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceExternalMemoryScreen
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
 template <> inline VkStructureType GetSType<VkPhysicalDeviceLayeredDriverPropertiesMSFT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV; }
+template <> inline VkStructureType GetSType<VkDisplaySurfaceStereoCreateInfoNV>() { return VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV; }
+template <> inline VkStructureType GetSType<VkDisplayModeStereoPropertiesNV>() { return VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceRawAccessChainsFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCommandBufferInheritanceFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; }
@@ -990,6 +1014,7 @@ template <> inline VkStructureType GetSType<VkHdrVividDynamicMetadataHUAWEI>() {
 template <> inline VkStructureType GetSType<VkCooperativeMatrixFlexibleDimensionsPropertiesNV>() { return VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeMatrix2FeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeMatrix2PropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryTrianglesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryAabbsDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryInstancesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index 058eada..ffa113f 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -652,6 +652,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX";
         case VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX:
             return "VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX";
+        case VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX:
+            return "VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX";
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX:
             return "VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX";
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX:
@@ -1864,6 +1866,28 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR";
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR:
             return "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR:
+            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR:
+            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR";
         case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR:
@@ -1942,6 +1966,30 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV";
+        case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV:
+            return "VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV";
+        case VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV:
+            return "VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR:
+            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR";
+        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR:
+            return "VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR:
+            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR:
+            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR";
+        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR:
+            return "VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR:
+            return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR";
+        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR:
+            return "VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR:
@@ -2012,6 +2060,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT";
         default:
             return "Unhandled VkStructureType";
     }
@@ -2084,6 +2134,8 @@ static inline const char* string_VkImageLayout(VkImageLayout input_value) {
             return "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR";
         case VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT:
             return "VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT";
+        case VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR:
+            return "VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR";
         default:
             return "Unhandled VkImageLayout";
     }
@@ -3906,6 +3958,32 @@ static inline const char* string_VkScopeKHR(VkScopeKHR input_value) {
             return "Unhandled VkScopeKHR";
     }
 }
+static inline const char* string_VkVideoEncodeAV1PredictionModeKHR(VkVideoEncodeAV1PredictionModeKHR input_value) {
+    switch (input_value) {
+        case VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_INTRA_ONLY_KHR:
+            return "VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_INTRA_ONLY_KHR";
+        case VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_SINGLE_REFERENCE_KHR:
+            return "VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_SINGLE_REFERENCE_KHR";
+        case VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_UNIDIRECTIONAL_COMPOUND_KHR:
+            return "VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_UNIDIRECTIONAL_COMPOUND_KHR";
+        case VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_BIDIRECTIONAL_COMPOUND_KHR:
+            return "VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_BIDIRECTIONAL_COMPOUND_KHR";
+        default:
+            return "Unhandled VkVideoEncodeAV1PredictionModeKHR";
+    }
+}
+static inline const char* string_VkVideoEncodeAV1RateControlGroupKHR(VkVideoEncodeAV1RateControlGroupKHR input_value) {
+    switch (input_value) {
+        case VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_INTRA_KHR:
+            return "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_INTRA_KHR";
+        case VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_PREDICTIVE_KHR:
+            return "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_PREDICTIVE_KHR";
+        case VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_BIPREDICTIVE_KHR:
+            return "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_BIPREDICTIVE_KHR";
+        default:
+            return "Unhandled VkVideoEncodeAV1RateControlGroupKHR";
+    }
+}
 static inline const char* string_VkLineRasterizationModeKHR(VkLineRasterizationModeKHR input_value) {
     switch (input_value) {
         case VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR:
@@ -4918,6 +4996,20 @@ static inline const char* string_VkLayeredDriverUnderlyingApiMSFT(VkLayeredDrive
             return "Unhandled VkLayeredDriverUnderlyingApiMSFT";
     }
 }
+static inline const char* string_VkDisplaySurfaceStereoTypeNV(VkDisplaySurfaceStereoTypeNV input_value) {
+    switch (input_value) {
+        case VK_DISPLAY_SURFACE_STEREO_TYPE_NONE_NV:
+            return "VK_DISPLAY_SURFACE_STEREO_TYPE_NONE_NV";
+        case VK_DISPLAY_SURFACE_STEREO_TYPE_ONBOARD_DIN_NV:
+            return "VK_DISPLAY_SURFACE_STEREO_TYPE_ONBOARD_DIN_NV";
+        case VK_DISPLAY_SURFACE_STEREO_TYPE_HDMI_3D_NV:
+            return "VK_DISPLAY_SURFACE_STEREO_TYPE_HDMI_3D_NV";
+        case VK_DISPLAY_SURFACE_STEREO_TYPE_INBAND_DISPLAYPORT_NV:
+            return "VK_DISPLAY_SURFACE_STEREO_TYPE_INBAND_DISPLAYPORT_NV";
+        default:
+            return "Unhandled VkDisplaySurfaceStereoTypeNV";
+    }
+}
 static inline const char* string_VkIndirectExecutionSetInfoTypeEXT(VkIndirectExecutionSetInfoTypeEXT input_value) {
     switch (input_value) {
         case VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT:
@@ -5346,6 +5438,10 @@ static inline const char* string_VkImageUsageFlagBits(VkImageUsageFlagBits input
             return "VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM";
         case VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM:
             return "VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM";
+        case VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR:
+            return "VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR";
+        case VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR:
+            return "VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR";
         default:
             return "Unhandled VkImageUsageFlagBits";
     }
@@ -7439,6 +7535,8 @@ static inline const char* string_VkFormatFeatureFlagBits2(uint64_t input_value)
     if (input_value == VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV) return "VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV";
     if (input_value == VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV) return "VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV";
     if (input_value == VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV) return "VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV";
+    if (input_value == VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR) return "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR";
+    if (input_value == VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR) return "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR";
     return "Unhandled VkFormatFeatureFlagBits2";
 }
 
@@ -7637,6 +7735,8 @@ static inline const char* string_VkVideoCodecOperationFlagBitsKHR(VkVideoCodecOp
             return "VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR";
         case VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR:
             return "VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR";
+        case VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR:
+            return "VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR";
         default:
             return "Unhandled VkVideoCodecOperationFlagBitsKHR";
     }
@@ -7757,6 +7857,10 @@ static inline const char* string_VkVideoSessionCreateFlagBitsKHR(VkVideoSessionC
             return "VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR";
         case VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR:
             return "VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR";
+        case VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR:
+            return "VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR";
+        case VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_EMPHASIS_MAP_BIT_KHR:
+            return "VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_EMPHASIS_MAP_BIT_KHR";
         default:
             return "Unhandled VkVideoSessionCreateFlagBitsKHR";
     }
@@ -7778,6 +7882,31 @@ static inline std::string string_VkVideoSessionCreateFlagsKHR(VkVideoSessionCrea
     return ret;
 }
 #endif // __cplusplus
+static inline const char* string_VkVideoSessionParametersCreateFlagBitsKHR(VkVideoSessionParametersCreateFlagBitsKHR input_value) {
+    switch (input_value) {
+        case VK_VIDEO_SESSION_PARAMETERS_CREATE_QUANTIZATION_MAP_COMPATIBLE_BIT_KHR:
+            return "VK_VIDEO_SESSION_PARAMETERS_CREATE_QUANTIZATION_MAP_COMPATIBLE_BIT_KHR";
+        default:
+            return "Unhandled VkVideoSessionParametersCreateFlagBitsKHR";
+    }
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkVideoSessionParametersCreateFlagsKHR(VkVideoSessionParametersCreateFlagsKHR input_value) {
+    std::string ret;
+    int index = 0;
+    while(input_value) {
+        if (input_value & 1) {
+            if( !ret.empty()) ret.append("|");
+            ret.append(string_VkVideoSessionParametersCreateFlagBitsKHR(static_cast<VkVideoSessionParametersCreateFlagBitsKHR>(1U << index)));
+        }
+        ++index;
+        input_value >>= 1;
+    }
+    if (ret.empty()) ret.append("VkVideoSessionParametersCreateFlagsKHR(0)");
+    return ret;
+}
+#endif // __cplusplus
 static inline const char* string_VkVideoCodingControlFlagBitsKHR(VkVideoCodingControlFlagBitsKHR input_value) {
     switch (input_value) {
         case VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR:
@@ -7885,6 +8014,8 @@ static inline const char* string_VkVideoEncodeH264CapabilityFlagBitsKHR(VkVideoE
             return "VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR";
         case VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR:
             return "VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR";
+        case VK_VIDEO_ENCODE_H264_CAPABILITY_MB_QP_DIFF_WRAPAROUND_BIT_KHR:
+            return "VK_VIDEO_ENCODE_H264_CAPABILITY_MB_QP_DIFF_WRAPAROUND_BIT_KHR";
         default:
             return "Unhandled VkVideoEncodeH264CapabilityFlagBitsKHR";
     }
@@ -8024,6 +8155,8 @@ static inline const char* string_VkVideoEncodeH265CapabilityFlagBitsKHR(VkVideoE
             return "VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR";
         case VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR:
             return "VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR";
+        case VK_VIDEO_ENCODE_H265_CAPABILITY_CU_QP_DIFF_WRAPAROUND_BIT_KHR:
+            return "VK_VIDEO_ENCODE_H265_CAPABILITY_CU_QP_DIFF_WRAPAROUND_BIT_KHR";
         default:
             return "Unhandled VkVideoEncodeH265CapabilityFlagBitsKHR";
     }
@@ -8284,12 +8417,43 @@ static inline std::string string_VkMemoryUnmapFlagsKHR(VkMemoryUnmapFlagsKHR inp
     return ret;
 }
 #endif // __cplusplus
+static inline const char* string_VkVideoEncodeFlagBitsKHR(VkVideoEncodeFlagBitsKHR input_value) {
+    switch (input_value) {
+        case VK_VIDEO_ENCODE_WITH_QUANTIZATION_DELTA_MAP_BIT_KHR:
+            return "VK_VIDEO_ENCODE_WITH_QUANTIZATION_DELTA_MAP_BIT_KHR";
+        case VK_VIDEO_ENCODE_WITH_EMPHASIS_MAP_BIT_KHR:
+            return "VK_VIDEO_ENCODE_WITH_EMPHASIS_MAP_BIT_KHR";
+        default:
+            return "Unhandled VkVideoEncodeFlagBitsKHR";
+    }
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkVideoEncodeFlagsKHR(VkVideoEncodeFlagsKHR input_value) {
+    std::string ret;
+    int index = 0;
+    while(input_value) {
+        if (input_value & 1) {
+            if( !ret.empty()) ret.append("|");
+            ret.append(string_VkVideoEncodeFlagBitsKHR(static_cast<VkVideoEncodeFlagBitsKHR>(1U << index)));
+        }
+        ++index;
+        input_value >>= 1;
+    }
+    if (ret.empty()) ret.append("VkVideoEncodeFlagsKHR(0)");
+    return ret;
+}
+#endif // __cplusplus
 static inline const char* string_VkVideoEncodeCapabilityFlagBitsKHR(VkVideoEncodeCapabilityFlagBitsKHR input_value) {
     switch (input_value) {
         case VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR:
             return "VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR";
         case VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR:
             return "VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR";
+        case VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR:
+            return "VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR";
+        case VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR:
+            return "VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR";
         default:
             return "Unhandled VkVideoEncodeCapabilityFlagBitsKHR";
     }
@@ -8541,6 +8705,128 @@ static inline std::string string_VkBufferUsageFlags2KHR(VkBufferUsageFlags2KHR i
     return ret;
 }
 #endif // __cplusplus
+static inline const char* string_VkVideoEncodeAV1CapabilityFlagBitsKHR(VkVideoEncodeAV1CapabilityFlagBitsKHR input_value) {
+    switch (input_value) {
+        case VK_VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR:
+            return "VK_VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR";
+        case VK_VIDEO_ENCODE_AV1_CAPABILITY_GENERATE_OBU_EXTENSION_HEADER_BIT_KHR:
+            return "VK_VIDEO_ENCODE_AV1_CAPABILITY_GENERATE_OBU_EXTENSION_HEADER_BIT_KHR";
+        case VK_VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR:
+            return "VK_VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR";
+        case VK_VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR:
+            return "VK_VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR";
+        case VK_VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR:
+            return "VK_VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR";
+        default:
+            return "Unhandled VkVideoEncodeAV1CapabilityFlagBitsKHR";
+    }
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkVideoEncodeAV1CapabilityFlagsKHR(VkVideoEncodeAV1CapabilityFlagsKHR input_value) {
+    std::string ret;
+    int index = 0;
+    while(input_value) {
+        if (input_value & 1) {
+            if( !ret.empty()) ret.append("|");
+            ret.append(string_VkVideoEncodeAV1CapabilityFlagBitsKHR(static_cast<VkVideoEncodeAV1CapabilityFlagBitsKHR>(1U << index)));
+        }
+        ++index;
+        input_value >>= 1;
+    }
+    if (ret.empty()) ret.append("VkVideoEncodeAV1CapabilityFlagsKHR(0)");
+    return ret;
+}
+#endif // __cplusplus
+static inline const char* string_VkVideoEncodeAV1StdFlagBitsKHR(VkVideoEncodeAV1StdFlagBitsKHR input_value) {
+    switch (input_value) {
+        case VK_VIDEO_ENCODE_AV1_STD_UNIFORM_TILE_SPACING_FLAG_SET_BIT_KHR:
+            return "VK_VIDEO_ENCODE_AV1_STD_UNIFORM_TILE_SPACING_FLAG_SET_BIT_KHR";
+        case VK_VIDEO_ENCODE_AV1_STD_SKIP_MODE_PRESENT_UNSET_BIT_KHR:
+            return "VK_VIDEO_ENCODE_AV1_STD_SKIP_MODE_PRESENT_UNSET_BIT_KHR";
+        case VK_VIDEO_ENCODE_AV1_STD_PRIMARY_REF_FRAME_BIT_KHR:
+            return "VK_VIDEO_ENCODE_AV1_STD_PRIMARY_REF_FRAME_BIT_KHR";
+        case VK_VIDEO_ENCODE_AV1_STD_DELTA_Q_BIT_KHR:
+            return "VK_VIDEO_ENCODE_AV1_STD_DELTA_Q_BIT_KHR";
+        default:
+            return "Unhandled VkVideoEncodeAV1StdFlagBitsKHR";
+    }
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkVideoEncodeAV1StdFlagsKHR(VkVideoEncodeAV1StdFlagsKHR input_value) {
+    std::string ret;
+    int index = 0;
+    while(input_value) {
+        if (input_value & 1) {
+            if( !ret.empty()) ret.append("|");
+            ret.append(string_VkVideoEncodeAV1StdFlagBitsKHR(static_cast<VkVideoEncodeAV1StdFlagBitsKHR>(1U << index)));
+        }
+        ++index;
+        input_value >>= 1;
+    }
+    if (ret.empty()) ret.append("VkVideoEncodeAV1StdFlagsKHR(0)");
+    return ret;
+}
+#endif // __cplusplus
+static inline const char* string_VkVideoEncodeAV1SuperblockSizeFlagBitsKHR(VkVideoEncodeAV1SuperblockSizeFlagBitsKHR input_value) {
+    switch (input_value) {
+        case VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR:
+            return "VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR";
+        case VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR:
+            return "VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR";
+        default:
+            return "Unhandled VkVideoEncodeAV1SuperblockSizeFlagBitsKHR";
+    }
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkVideoEncodeAV1SuperblockSizeFlagsKHR(VkVideoEncodeAV1SuperblockSizeFlagsKHR input_value) {
+    std::string ret;
+    int index = 0;
+    while(input_value) {
+        if (input_value & 1) {
+            if( !ret.empty()) ret.append("|");
+            ret.append(string_VkVideoEncodeAV1SuperblockSizeFlagBitsKHR(static_cast<VkVideoEncodeAV1SuperblockSizeFlagBitsKHR>(1U << index)));
+        }
+        ++index;
+        input_value >>= 1;
+    }
+    if (ret.empty()) ret.append("VkVideoEncodeAV1SuperblockSizeFlagsKHR(0)");
+    return ret;
+}
+#endif // __cplusplus
+static inline const char* string_VkVideoEncodeAV1RateControlFlagBitsKHR(VkVideoEncodeAV1RateControlFlagBitsKHR input_value) {
+    switch (input_value) {
+        case VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REGULAR_GOP_BIT_KHR:
+            return "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REGULAR_GOP_BIT_KHR";
+        case VK_VIDEO_ENCODE_AV1_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR:
+            return "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR";
+        case VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR:
+            return "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR";
+        case VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR:
+            return "VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR";
+        default:
+            return "Unhandled VkVideoEncodeAV1RateControlFlagBitsKHR";
+    }
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkVideoEncodeAV1RateControlFlagsKHR(VkVideoEncodeAV1RateControlFlagsKHR input_value) {
+    std::string ret;
+    int index = 0;
+    while(input_value) {
+        if (input_value & 1) {
+            if( !ret.empty()) ret.append("|");
+            ret.append(string_VkVideoEncodeAV1RateControlFlagBitsKHR(static_cast<VkVideoEncodeAV1RateControlFlagBitsKHR>(1U << index)));
+        }
+        ++index;
+        input_value >>= 1;
+    }
+    if (ret.empty()) ret.append("VkVideoEncodeAV1RateControlFlagsKHR(0)");
+    return ret;
+}
+#endif // __cplusplus
 static inline const char* string_VkDebugReportFlagBitsEXT(VkDebugReportFlagBitsEXT input_value) {
     switch (input_value) {
         case VK_DEBUG_REPORT_INFORMATION_BIT_EXT:
diff --git a/scripts/known_good.json b/scripts/known_good.json
index cbf87bf..07e048e 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.3.301"
+            "commit": "v1.3.302"
         },
         {
             "name": "googletest",
diff --git a/src/vulkan/vk_safe_struct_ext.cpp b/src/vulkan/vk_safe_struct_ext.cpp
index 52d2613..6ee2038 100644
--- a/src/vulkan/vk_safe_struct_ext.cpp
+++ b/src/vulkan/vk_safe_struct_ext.cpp
@@ -16647,6 +16647,59 @@ void safe_VkPipelineViewportDepthClampControlCreateInfoEXT::initialize(
     }
 }
 
+safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT::safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(
+    const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), vertexAttributeRobustness(in_struct->vertexAttributeRobustness) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT::safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT),
+      pNext(nullptr),
+      vertexAttributeRobustness() {}
+
+safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT::safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(
+    const safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    vertexAttributeRobustness = copy_src.vertexAttributeRobustness;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT& safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    vertexAttributeRobustness = copy_src.vertexAttributeRobustness;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT::~safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT::initialize(
+    const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    vertexAttributeRobustness = in_struct->vertexAttributeRobustness;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    vertexAttributeRobustness = copy_src->vertexAttributeRobustness;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkPhysicalDeviceMeshShaderFeaturesEXT::safe_VkPhysicalDeviceMeshShaderFeaturesEXT(
     const VkPhysicalDeviceMeshShaderFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType),
diff --git a/src/vulkan/vk_safe_struct_khr.cpp b/src/vulkan/vk_safe_struct_khr.cpp
index 994a7af..735e5d8 100644
--- a/src/vulkan/vk_safe_struct_khr.cpp
+++ b/src/vulkan/vk_safe_struct_khr.cpp
@@ -13709,6 +13709,1049 @@ void safe_VkVideoDecodeAV1DpbSlotInfoKHR::initialize(const safe_VkVideoDecodeAV1
     }
 }
 
+safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR::safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR(
+    const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), videoEncodeAV1(in_struct->videoEncodeAV1) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR::safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR), pNext(nullptr), videoEncodeAV1() {}
+
+safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR::safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR(
+    const safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    videoEncodeAV1 = copy_src.videoEncodeAV1;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR& safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    videoEncodeAV1 = copy_src.videoEncodeAV1;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR::~safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR::initialize(const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    videoEncodeAV1 = in_struct->videoEncodeAV1;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR::initialize(const safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    videoEncodeAV1 = copy_src->videoEncodeAV1;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeAV1CapabilitiesKHR::safe_VkVideoEncodeAV1CapabilitiesKHR(const VkVideoEncodeAV1CapabilitiesKHR* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      maxLevel(in_struct->maxLevel),
+      codedPictureAlignment(in_struct->codedPictureAlignment),
+      maxTiles(in_struct->maxTiles),
+      minTileSize(in_struct->minTileSize),
+      maxTileSize(in_struct->maxTileSize),
+      superblockSizes(in_struct->superblockSizes),
+      maxSingleReferenceCount(in_struct->maxSingleReferenceCount),
+      singleReferenceNameMask(in_struct->singleReferenceNameMask),
+      maxUnidirectionalCompoundReferenceCount(in_struct->maxUnidirectionalCompoundReferenceCount),
+      maxUnidirectionalCompoundGroup1ReferenceCount(in_struct->maxUnidirectionalCompoundGroup1ReferenceCount),
+      unidirectionalCompoundReferenceNameMask(in_struct->unidirectionalCompoundReferenceNameMask),
+      maxBidirectionalCompoundReferenceCount(in_struct->maxBidirectionalCompoundReferenceCount),
+      maxBidirectionalCompoundGroup1ReferenceCount(in_struct->maxBidirectionalCompoundGroup1ReferenceCount),
+      maxBidirectionalCompoundGroup2ReferenceCount(in_struct->maxBidirectionalCompoundGroup2ReferenceCount),
+      bidirectionalCompoundReferenceNameMask(in_struct->bidirectionalCompoundReferenceNameMask),
+      maxTemporalLayerCount(in_struct->maxTemporalLayerCount),
+      maxSpatialLayerCount(in_struct->maxSpatialLayerCount),
+      maxOperatingPoints(in_struct->maxOperatingPoints),
+      minQIndex(in_struct->minQIndex),
+      maxQIndex(in_struct->maxQIndex),
+      prefersGopRemainingFrames(in_struct->prefersGopRemainingFrames),
+      requiresGopRemainingFrames(in_struct->requiresGopRemainingFrames),
+      stdSyntaxFlags(in_struct->stdSyntaxFlags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeAV1CapabilitiesKHR::safe_VkVideoEncodeAV1CapabilitiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR),
+      pNext(nullptr),
+      flags(),
+      maxLevel(),
+      codedPictureAlignment(),
+      maxTiles(),
+      minTileSize(),
+      maxTileSize(),
+      superblockSizes(),
+      maxSingleReferenceCount(),
+      singleReferenceNameMask(),
+      maxUnidirectionalCompoundReferenceCount(),
+      maxUnidirectionalCompoundGroup1ReferenceCount(),
+      unidirectionalCompoundReferenceNameMask(),
+      maxBidirectionalCompoundReferenceCount(),
+      maxBidirectionalCompoundGroup1ReferenceCount(),
+      maxBidirectionalCompoundGroup2ReferenceCount(),
+      bidirectionalCompoundReferenceNameMask(),
+      maxTemporalLayerCount(),
+      maxSpatialLayerCount(),
+      maxOperatingPoints(),
+      minQIndex(),
+      maxQIndex(),
+      prefersGopRemainingFrames(),
+      requiresGopRemainingFrames(),
+      stdSyntaxFlags() {}
+
+safe_VkVideoEncodeAV1CapabilitiesKHR::safe_VkVideoEncodeAV1CapabilitiesKHR(const safe_VkVideoEncodeAV1CapabilitiesKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    maxLevel = copy_src.maxLevel;
+    codedPictureAlignment = copy_src.codedPictureAlignment;
+    maxTiles = copy_src.maxTiles;
+    minTileSize = copy_src.minTileSize;
+    maxTileSize = copy_src.maxTileSize;
+    superblockSizes = copy_src.superblockSizes;
+    maxSingleReferenceCount = copy_src.maxSingleReferenceCount;
+    singleReferenceNameMask = copy_src.singleReferenceNameMask;
+    maxUnidirectionalCompoundReferenceCount = copy_src.maxUnidirectionalCompoundReferenceCount;
+    maxUnidirectionalCompoundGroup1ReferenceCount = copy_src.maxUnidirectionalCompoundGroup1ReferenceCount;
+    unidirectionalCompoundReferenceNameMask = copy_src.unidirectionalCompoundReferenceNameMask;
+    maxBidirectionalCompoundReferenceCount = copy_src.maxBidirectionalCompoundReferenceCount;
+    maxBidirectionalCompoundGroup1ReferenceCount = copy_src.maxBidirectionalCompoundGroup1ReferenceCount;
+    maxBidirectionalCompoundGroup2ReferenceCount = copy_src.maxBidirectionalCompoundGroup2ReferenceCount;
+    bidirectionalCompoundReferenceNameMask = copy_src.bidirectionalCompoundReferenceNameMask;
+    maxTemporalLayerCount = copy_src.maxTemporalLayerCount;
+    maxSpatialLayerCount = copy_src.maxSpatialLayerCount;
+    maxOperatingPoints = copy_src.maxOperatingPoints;
+    minQIndex = copy_src.minQIndex;
+    maxQIndex = copy_src.maxQIndex;
+    prefersGopRemainingFrames = copy_src.prefersGopRemainingFrames;
+    requiresGopRemainingFrames = copy_src.requiresGopRemainingFrames;
+    stdSyntaxFlags = copy_src.stdSyntaxFlags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeAV1CapabilitiesKHR& safe_VkVideoEncodeAV1CapabilitiesKHR::operator=(
+    const safe_VkVideoEncodeAV1CapabilitiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    maxLevel = copy_src.maxLevel;
+    codedPictureAlignment = copy_src.codedPictureAlignment;
+    maxTiles = copy_src.maxTiles;
+    minTileSize = copy_src.minTileSize;
+    maxTileSize = copy_src.maxTileSize;
+    superblockSizes = copy_src.superblockSizes;
+    maxSingleReferenceCount = copy_src.maxSingleReferenceCount;
+    singleReferenceNameMask = copy_src.singleReferenceNameMask;
+    maxUnidirectionalCompoundReferenceCount = copy_src.maxUnidirectionalCompoundReferenceCount;
+    maxUnidirectionalCompoundGroup1ReferenceCount = copy_src.maxUnidirectionalCompoundGroup1ReferenceCount;
+    unidirectionalCompoundReferenceNameMask = copy_src.unidirectionalCompoundReferenceNameMask;
+    maxBidirectionalCompoundReferenceCount = copy_src.maxBidirectionalCompoundReferenceCount;
+    maxBidirectionalCompoundGroup1ReferenceCount = copy_src.maxBidirectionalCompoundGroup1ReferenceCount;
+    maxBidirectionalCompoundGroup2ReferenceCount = copy_src.maxBidirectionalCompoundGroup2ReferenceCount;
+    bidirectionalCompoundReferenceNameMask = copy_src.bidirectionalCompoundReferenceNameMask;
+    maxTemporalLayerCount = copy_src.maxTemporalLayerCount;
+    maxSpatialLayerCount = copy_src.maxSpatialLayerCount;
+    maxOperatingPoints = copy_src.maxOperatingPoints;
+    minQIndex = copy_src.minQIndex;
+    maxQIndex = copy_src.maxQIndex;
+    prefersGopRemainingFrames = copy_src.prefersGopRemainingFrames;
+    requiresGopRemainingFrames = copy_src.requiresGopRemainingFrames;
+    stdSyntaxFlags = copy_src.stdSyntaxFlags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeAV1CapabilitiesKHR::~safe_VkVideoEncodeAV1CapabilitiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeAV1CapabilitiesKHR::initialize(const VkVideoEncodeAV1CapabilitiesKHR* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    maxLevel = in_struct->maxLevel;
+    codedPictureAlignment = in_struct->codedPictureAlignment;
+    maxTiles = in_struct->maxTiles;
+    minTileSize = in_struct->minTileSize;
+    maxTileSize = in_struct->maxTileSize;
+    superblockSizes = in_struct->superblockSizes;
+    maxSingleReferenceCount = in_struct->maxSingleReferenceCount;
+    singleReferenceNameMask = in_struct->singleReferenceNameMask;
+    maxUnidirectionalCompoundReferenceCount = in_struct->maxUnidirectionalCompoundReferenceCount;
+    maxUnidirectionalCompoundGroup1ReferenceCount = in_struct->maxUnidirectionalCompoundGroup1ReferenceCount;
+    unidirectionalCompoundReferenceNameMask = in_struct->unidirectionalCompoundReferenceNameMask;
+    maxBidirectionalCompoundReferenceCount = in_struct->maxBidirectionalCompoundReferenceCount;
+    maxBidirectionalCompoundGroup1ReferenceCount = in_struct->maxBidirectionalCompoundGroup1ReferenceCount;
+    maxBidirectionalCompoundGroup2ReferenceCount = in_struct->maxBidirectionalCompoundGroup2ReferenceCount;
+    bidirectionalCompoundReferenceNameMask = in_struct->bidirectionalCompoundReferenceNameMask;
+    maxTemporalLayerCount = in_struct->maxTemporalLayerCount;
+    maxSpatialLayerCount = in_struct->maxSpatialLayerCount;
+    maxOperatingPoints = in_struct->maxOperatingPoints;
+    minQIndex = in_struct->minQIndex;
+    maxQIndex = in_struct->maxQIndex;
+    prefersGopRemainingFrames = in_struct->prefersGopRemainingFrames;
+    requiresGopRemainingFrames = in_struct->requiresGopRemainingFrames;
+    stdSyntaxFlags = in_struct->stdSyntaxFlags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeAV1CapabilitiesKHR::initialize(const safe_VkVideoEncodeAV1CapabilitiesKHR* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    maxLevel = copy_src->maxLevel;
+    codedPictureAlignment = copy_src->codedPictureAlignment;
+    maxTiles = copy_src->maxTiles;
+    minTileSize = copy_src->minTileSize;
+    maxTileSize = copy_src->maxTileSize;
+    superblockSizes = copy_src->superblockSizes;
+    maxSingleReferenceCount = copy_src->maxSingleReferenceCount;
+    singleReferenceNameMask = copy_src->singleReferenceNameMask;
+    maxUnidirectionalCompoundReferenceCount = copy_src->maxUnidirectionalCompoundReferenceCount;
+    maxUnidirectionalCompoundGroup1ReferenceCount = copy_src->maxUnidirectionalCompoundGroup1ReferenceCount;
+    unidirectionalCompoundReferenceNameMask = copy_src->unidirectionalCompoundReferenceNameMask;
+    maxBidirectionalCompoundReferenceCount = copy_src->maxBidirectionalCompoundReferenceCount;
+    maxBidirectionalCompoundGroup1ReferenceCount = copy_src->maxBidirectionalCompoundGroup1ReferenceCount;
+    maxBidirectionalCompoundGroup2ReferenceCount = copy_src->maxBidirectionalCompoundGroup2ReferenceCount;
+    bidirectionalCompoundReferenceNameMask = copy_src->bidirectionalCompoundReferenceNameMask;
+    maxTemporalLayerCount = copy_src->maxTemporalLayerCount;
+    maxSpatialLayerCount = copy_src->maxSpatialLayerCount;
+    maxOperatingPoints = copy_src->maxOperatingPoints;
+    minQIndex = copy_src->minQIndex;
+    maxQIndex = copy_src->maxQIndex;
+    prefersGopRemainingFrames = copy_src->prefersGopRemainingFrames;
+    requiresGopRemainingFrames = copy_src->requiresGopRemainingFrames;
+    stdSyntaxFlags = copy_src->stdSyntaxFlags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeAV1QualityLevelPropertiesKHR::safe_VkVideoEncodeAV1QualityLevelPropertiesKHR(
+    const VkVideoEncodeAV1QualityLevelPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      preferredRateControlFlags(in_struct->preferredRateControlFlags),
+      preferredGopFrameCount(in_struct->preferredGopFrameCount),
+      preferredKeyFramePeriod(in_struct->preferredKeyFramePeriod),
+      preferredConsecutiveBipredictiveFrameCount(in_struct->preferredConsecutiveBipredictiveFrameCount),
+      preferredTemporalLayerCount(in_struct->preferredTemporalLayerCount),
+      preferredConstantQIndex(in_struct->preferredConstantQIndex),
+      preferredMaxSingleReferenceCount(in_struct->preferredMaxSingleReferenceCount),
+      preferredSingleReferenceNameMask(in_struct->preferredSingleReferenceNameMask),
+      preferredMaxUnidirectionalCompoundReferenceCount(in_struct->preferredMaxUnidirectionalCompoundReferenceCount),
+      preferredMaxUnidirectionalCompoundGroup1ReferenceCount(in_struct->preferredMaxUnidirectionalCompoundGroup1ReferenceCount),
+      preferredUnidirectionalCompoundReferenceNameMask(in_struct->preferredUnidirectionalCompoundReferenceNameMask),
+      preferredMaxBidirectionalCompoundReferenceCount(in_struct->preferredMaxBidirectionalCompoundReferenceCount),
+      preferredMaxBidirectionalCompoundGroup1ReferenceCount(in_struct->preferredMaxBidirectionalCompoundGroup1ReferenceCount),
+      preferredMaxBidirectionalCompoundGroup2ReferenceCount(in_struct->preferredMaxBidirectionalCompoundGroup2ReferenceCount),
+      preferredBidirectionalCompoundReferenceNameMask(in_struct->preferredBidirectionalCompoundReferenceNameMask) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeAV1QualityLevelPropertiesKHR::safe_VkVideoEncodeAV1QualityLevelPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR),
+      pNext(nullptr),
+      preferredRateControlFlags(),
+      preferredGopFrameCount(),
+      preferredKeyFramePeriod(),
+      preferredConsecutiveBipredictiveFrameCount(),
+      preferredTemporalLayerCount(),
+      preferredConstantQIndex(),
+      preferredMaxSingleReferenceCount(),
+      preferredSingleReferenceNameMask(),
+      preferredMaxUnidirectionalCompoundReferenceCount(),
+      preferredMaxUnidirectionalCompoundGroup1ReferenceCount(),
+      preferredUnidirectionalCompoundReferenceNameMask(),
+      preferredMaxBidirectionalCompoundReferenceCount(),
+      preferredMaxBidirectionalCompoundGroup1ReferenceCount(),
+      preferredMaxBidirectionalCompoundGroup2ReferenceCount(),
+      preferredBidirectionalCompoundReferenceNameMask() {}
+
+safe_VkVideoEncodeAV1QualityLevelPropertiesKHR::safe_VkVideoEncodeAV1QualityLevelPropertiesKHR(
+    const safe_VkVideoEncodeAV1QualityLevelPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    preferredRateControlFlags = copy_src.preferredRateControlFlags;
+    preferredGopFrameCount = copy_src.preferredGopFrameCount;
+    preferredKeyFramePeriod = copy_src.preferredKeyFramePeriod;
+    preferredConsecutiveBipredictiveFrameCount = copy_src.preferredConsecutiveBipredictiveFrameCount;
+    preferredTemporalLayerCount = copy_src.preferredTemporalLayerCount;
+    preferredConstantQIndex = copy_src.preferredConstantQIndex;
+    preferredMaxSingleReferenceCount = copy_src.preferredMaxSingleReferenceCount;
+    preferredSingleReferenceNameMask = copy_src.preferredSingleReferenceNameMask;
+    preferredMaxUnidirectionalCompoundReferenceCount = copy_src.preferredMaxUnidirectionalCompoundReferenceCount;
+    preferredMaxUnidirectionalCompoundGroup1ReferenceCount = copy_src.preferredMaxUnidirectionalCompoundGroup1ReferenceCount;
+    preferredUnidirectionalCompoundReferenceNameMask = copy_src.preferredUnidirectionalCompoundReferenceNameMask;
+    preferredMaxBidirectionalCompoundReferenceCount = copy_src.preferredMaxBidirectionalCompoundReferenceCount;
+    preferredMaxBidirectionalCompoundGroup1ReferenceCount = copy_src.preferredMaxBidirectionalCompoundGroup1ReferenceCount;
+    preferredMaxBidirectionalCompoundGroup2ReferenceCount = copy_src.preferredMaxBidirectionalCompoundGroup2ReferenceCount;
+    preferredBidirectionalCompoundReferenceNameMask = copy_src.preferredBidirectionalCompoundReferenceNameMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeAV1QualityLevelPropertiesKHR& safe_VkVideoEncodeAV1QualityLevelPropertiesKHR::operator=(
+    const safe_VkVideoEncodeAV1QualityLevelPropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    preferredRateControlFlags = copy_src.preferredRateControlFlags;
+    preferredGopFrameCount = copy_src.preferredGopFrameCount;
+    preferredKeyFramePeriod = copy_src.preferredKeyFramePeriod;
+    preferredConsecutiveBipredictiveFrameCount = copy_src.preferredConsecutiveBipredictiveFrameCount;
+    preferredTemporalLayerCount = copy_src.preferredTemporalLayerCount;
+    preferredConstantQIndex = copy_src.preferredConstantQIndex;
+    preferredMaxSingleReferenceCount = copy_src.preferredMaxSingleReferenceCount;
+    preferredSingleReferenceNameMask = copy_src.preferredSingleReferenceNameMask;
+    preferredMaxUnidirectionalCompoundReferenceCount = copy_src.preferredMaxUnidirectionalCompoundReferenceCount;
+    preferredMaxUnidirectionalCompoundGroup1ReferenceCount = copy_src.preferredMaxUnidirectionalCompoundGroup1ReferenceCount;
+    preferredUnidirectionalCompoundReferenceNameMask = copy_src.preferredUnidirectionalCompoundReferenceNameMask;
+    preferredMaxBidirectionalCompoundReferenceCount = copy_src.preferredMaxBidirectionalCompoundReferenceCount;
+    preferredMaxBidirectionalCompoundGroup1ReferenceCount = copy_src.preferredMaxBidirectionalCompoundGroup1ReferenceCount;
+    preferredMaxBidirectionalCompoundGroup2ReferenceCount = copy_src.preferredMaxBidirectionalCompoundGroup2ReferenceCount;
+    preferredBidirectionalCompoundReferenceNameMask = copy_src.preferredBidirectionalCompoundReferenceNameMask;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeAV1QualityLevelPropertiesKHR::~safe_VkVideoEncodeAV1QualityLevelPropertiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeAV1QualityLevelPropertiesKHR::initialize(const VkVideoEncodeAV1QualityLevelPropertiesKHR* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    preferredRateControlFlags = in_struct->preferredRateControlFlags;
+    preferredGopFrameCount = in_struct->preferredGopFrameCount;
+    preferredKeyFramePeriod = in_struct->preferredKeyFramePeriod;
+    preferredConsecutiveBipredictiveFrameCount = in_struct->preferredConsecutiveBipredictiveFrameCount;
+    preferredTemporalLayerCount = in_struct->preferredTemporalLayerCount;
+    preferredConstantQIndex = in_struct->preferredConstantQIndex;
+    preferredMaxSingleReferenceCount = in_struct->preferredMaxSingleReferenceCount;
+    preferredSingleReferenceNameMask = in_struct->preferredSingleReferenceNameMask;
+    preferredMaxUnidirectionalCompoundReferenceCount = in_struct->preferredMaxUnidirectionalCompoundReferenceCount;
+    preferredMaxUnidirectionalCompoundGroup1ReferenceCount = in_struct->preferredMaxUnidirectionalCompoundGroup1ReferenceCount;
+    preferredUnidirectionalCompoundReferenceNameMask = in_struct->preferredUnidirectionalCompoundReferenceNameMask;
+    preferredMaxBidirectionalCompoundReferenceCount = in_struct->preferredMaxBidirectionalCompoundReferenceCount;
+    preferredMaxBidirectionalCompoundGroup1ReferenceCount = in_struct->preferredMaxBidirectionalCompoundGroup1ReferenceCount;
+    preferredMaxBidirectionalCompoundGroup2ReferenceCount = in_struct->preferredMaxBidirectionalCompoundGroup2ReferenceCount;
+    preferredBidirectionalCompoundReferenceNameMask = in_struct->preferredBidirectionalCompoundReferenceNameMask;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeAV1QualityLevelPropertiesKHR::initialize(const safe_VkVideoEncodeAV1QualityLevelPropertiesKHR* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    preferredRateControlFlags = copy_src->preferredRateControlFlags;
+    preferredGopFrameCount = copy_src->preferredGopFrameCount;
+    preferredKeyFramePeriod = copy_src->preferredKeyFramePeriod;
+    preferredConsecutiveBipredictiveFrameCount = copy_src->preferredConsecutiveBipredictiveFrameCount;
+    preferredTemporalLayerCount = copy_src->preferredTemporalLayerCount;
+    preferredConstantQIndex = copy_src->preferredConstantQIndex;
+    preferredMaxSingleReferenceCount = copy_src->preferredMaxSingleReferenceCount;
+    preferredSingleReferenceNameMask = copy_src->preferredSingleReferenceNameMask;
+    preferredMaxUnidirectionalCompoundReferenceCount = copy_src->preferredMaxUnidirectionalCompoundReferenceCount;
+    preferredMaxUnidirectionalCompoundGroup1ReferenceCount = copy_src->preferredMaxUnidirectionalCompoundGroup1ReferenceCount;
+    preferredUnidirectionalCompoundReferenceNameMask = copy_src->preferredUnidirectionalCompoundReferenceNameMask;
+    preferredMaxBidirectionalCompoundReferenceCount = copy_src->preferredMaxBidirectionalCompoundReferenceCount;
+    preferredMaxBidirectionalCompoundGroup1ReferenceCount = copy_src->preferredMaxBidirectionalCompoundGroup1ReferenceCount;
+    preferredMaxBidirectionalCompoundGroup2ReferenceCount = copy_src->preferredMaxBidirectionalCompoundGroup2ReferenceCount;
+    preferredBidirectionalCompoundReferenceNameMask = copy_src->preferredBidirectionalCompoundReferenceNameMask;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeAV1SessionCreateInfoKHR::safe_VkVideoEncodeAV1SessionCreateInfoKHR(
+    const VkVideoEncodeAV1SessionCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), useMaxLevel(in_struct->useMaxLevel), maxLevel(in_struct->maxLevel) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeAV1SessionCreateInfoKHR::safe_VkVideoEncodeAV1SessionCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR), pNext(nullptr), useMaxLevel(), maxLevel() {}
+
+safe_VkVideoEncodeAV1SessionCreateInfoKHR::safe_VkVideoEncodeAV1SessionCreateInfoKHR(
+    const safe_VkVideoEncodeAV1SessionCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    useMaxLevel = copy_src.useMaxLevel;
+    maxLevel = copy_src.maxLevel;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeAV1SessionCreateInfoKHR& safe_VkVideoEncodeAV1SessionCreateInfoKHR::operator=(
+    const safe_VkVideoEncodeAV1SessionCreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    useMaxLevel = copy_src.useMaxLevel;
+    maxLevel = copy_src.maxLevel;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeAV1SessionCreateInfoKHR::~safe_VkVideoEncodeAV1SessionCreateInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeAV1SessionCreateInfoKHR::initialize(const VkVideoEncodeAV1SessionCreateInfoKHR* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    useMaxLevel = in_struct->useMaxLevel;
+    maxLevel = in_struct->maxLevel;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeAV1SessionCreateInfoKHR::initialize(const safe_VkVideoEncodeAV1SessionCreateInfoKHR* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    useMaxLevel = copy_src->useMaxLevel;
+    maxLevel = copy_src->maxLevel;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR::safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR(
+    const VkVideoEncodeAV1SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      pStdSequenceHeader(nullptr),
+      pStdDecoderModelInfo(nullptr),
+      stdOperatingPointCount(in_struct->stdOperatingPointCount),
+      pStdOperatingPoints(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pStdSequenceHeader) {
+        pStdSequenceHeader = new StdVideoAV1SequenceHeader(*in_struct->pStdSequenceHeader);
+    }
+
+    if (in_struct->pStdDecoderModelInfo) {
+        pStdDecoderModelInfo = new StdVideoEncodeAV1DecoderModelInfo(*in_struct->pStdDecoderModelInfo);
+    }
+
+    if (in_struct->pStdOperatingPoints) {
+        pStdOperatingPoints = new StdVideoEncodeAV1OperatingPointInfo[in_struct->stdOperatingPointCount];
+        memcpy((void*)pStdOperatingPoints, (void*)in_struct->pStdOperatingPoints,
+               sizeof(StdVideoEncodeAV1OperatingPointInfo) * in_struct->stdOperatingPointCount);
+    }
+}
+
+safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR::safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR),
+      pNext(nullptr),
+      pStdSequenceHeader(nullptr),
+      pStdDecoderModelInfo(nullptr),
+      stdOperatingPointCount(),
+      pStdOperatingPoints(nullptr) {}
+
+safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR::safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR(
+    const safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pStdSequenceHeader = nullptr;
+    pStdDecoderModelInfo = nullptr;
+    stdOperatingPointCount = copy_src.stdOperatingPointCount;
+    pStdOperatingPoints = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdSequenceHeader) {
+        pStdSequenceHeader = new StdVideoAV1SequenceHeader(*copy_src.pStdSequenceHeader);
+    }
+
+    if (copy_src.pStdDecoderModelInfo) {
+        pStdDecoderModelInfo = new StdVideoEncodeAV1DecoderModelInfo(*copy_src.pStdDecoderModelInfo);
+    }
+
+    if (copy_src.pStdOperatingPoints) {
+        pStdOperatingPoints = new StdVideoEncodeAV1OperatingPointInfo[copy_src.stdOperatingPointCount];
+        memcpy((void*)pStdOperatingPoints, (void*)copy_src.pStdOperatingPoints,
+               sizeof(StdVideoEncodeAV1OperatingPointInfo) * copy_src.stdOperatingPointCount);
+    }
+}
+
+safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR& safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR::operator=(
+    const safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pStdSequenceHeader) delete pStdSequenceHeader;
+    if (pStdDecoderModelInfo) delete pStdDecoderModelInfo;
+    if (pStdOperatingPoints) delete[] pStdOperatingPoints;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pStdSequenceHeader = nullptr;
+    pStdDecoderModelInfo = nullptr;
+    stdOperatingPointCount = copy_src.stdOperatingPointCount;
+    pStdOperatingPoints = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdSequenceHeader) {
+        pStdSequenceHeader = new StdVideoAV1SequenceHeader(*copy_src.pStdSequenceHeader);
+    }
+
+    if (copy_src.pStdDecoderModelInfo) {
+        pStdDecoderModelInfo = new StdVideoEncodeAV1DecoderModelInfo(*copy_src.pStdDecoderModelInfo);
+    }
+
+    if (copy_src.pStdOperatingPoints) {
+        pStdOperatingPoints = new StdVideoEncodeAV1OperatingPointInfo[copy_src.stdOperatingPointCount];
+        memcpy((void*)pStdOperatingPoints, (void*)copy_src.pStdOperatingPoints,
+               sizeof(StdVideoEncodeAV1OperatingPointInfo) * copy_src.stdOperatingPointCount);
+    }
+
+    return *this;
+}
+
+safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR::~safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR() {
+    if (pStdSequenceHeader) delete pStdSequenceHeader;
+    if (pStdDecoderModelInfo) delete pStdDecoderModelInfo;
+    if (pStdOperatingPoints) delete[] pStdOperatingPoints;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR::initialize(
+    const VkVideoEncodeAV1SessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pStdSequenceHeader) delete pStdSequenceHeader;
+    if (pStdDecoderModelInfo) delete pStdDecoderModelInfo;
+    if (pStdOperatingPoints) delete[] pStdOperatingPoints;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pStdSequenceHeader = nullptr;
+    pStdDecoderModelInfo = nullptr;
+    stdOperatingPointCount = in_struct->stdOperatingPointCount;
+    pStdOperatingPoints = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pStdSequenceHeader) {
+        pStdSequenceHeader = new StdVideoAV1SequenceHeader(*in_struct->pStdSequenceHeader);
+    }
+
+    if (in_struct->pStdDecoderModelInfo) {
+        pStdDecoderModelInfo = new StdVideoEncodeAV1DecoderModelInfo(*in_struct->pStdDecoderModelInfo);
+    }
+
+    if (in_struct->pStdOperatingPoints) {
+        pStdOperatingPoints = new StdVideoEncodeAV1OperatingPointInfo[in_struct->stdOperatingPointCount];
+        memcpy((void*)pStdOperatingPoints, (void*)in_struct->pStdOperatingPoints,
+               sizeof(StdVideoEncodeAV1OperatingPointInfo) * in_struct->stdOperatingPointCount);
+    }
+}
+
+void safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR::initialize(
+    const safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pStdSequenceHeader = nullptr;
+    pStdDecoderModelInfo = nullptr;
+    stdOperatingPointCount = copy_src->stdOperatingPointCount;
+    pStdOperatingPoints = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pStdSequenceHeader) {
+        pStdSequenceHeader = new StdVideoAV1SequenceHeader(*copy_src->pStdSequenceHeader);
+    }
+
+    if (copy_src->pStdDecoderModelInfo) {
+        pStdDecoderModelInfo = new StdVideoEncodeAV1DecoderModelInfo(*copy_src->pStdDecoderModelInfo);
+    }
+
+    if (copy_src->pStdOperatingPoints) {
+        pStdOperatingPoints = new StdVideoEncodeAV1OperatingPointInfo[copy_src->stdOperatingPointCount];
+        memcpy((void*)pStdOperatingPoints, (void*)copy_src->pStdOperatingPoints,
+               sizeof(StdVideoEncodeAV1OperatingPointInfo) * copy_src->stdOperatingPointCount);
+    }
+}
+
+safe_VkVideoEncodeAV1PictureInfoKHR::safe_VkVideoEncodeAV1PictureInfoKHR(const VkVideoEncodeAV1PictureInfoKHR* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType),
+      predictionMode(in_struct->predictionMode),
+      rateControlGroup(in_struct->rateControlGroup),
+      constantQIndex(in_struct->constantQIndex),
+      pStdPictureInfo(nullptr),
+      primaryReferenceCdfOnly(in_struct->primaryReferenceCdfOnly),
+      generateObuExtensionHeader(in_struct->generateObuExtensionHeader) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoEncodeAV1PictureInfo(*in_struct->pStdPictureInfo);
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) {
+        referenceNameSlotIndices[i] = in_struct->referenceNameSlotIndices[i];
+    }
+}
+
+safe_VkVideoEncodeAV1PictureInfoKHR::safe_VkVideoEncodeAV1PictureInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR),
+      pNext(nullptr),
+      predictionMode(),
+      rateControlGroup(),
+      constantQIndex(),
+      pStdPictureInfo(nullptr),
+      primaryReferenceCdfOnly(),
+      generateObuExtensionHeader() {}
+
+safe_VkVideoEncodeAV1PictureInfoKHR::safe_VkVideoEncodeAV1PictureInfoKHR(const safe_VkVideoEncodeAV1PictureInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    predictionMode = copy_src.predictionMode;
+    rateControlGroup = copy_src.rateControlGroup;
+    constantQIndex = copy_src.constantQIndex;
+    pStdPictureInfo = nullptr;
+    primaryReferenceCdfOnly = copy_src.primaryReferenceCdfOnly;
+    generateObuExtensionHeader = copy_src.generateObuExtensionHeader;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoEncodeAV1PictureInfo(*copy_src.pStdPictureInfo);
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) {
+        referenceNameSlotIndices[i] = copy_src.referenceNameSlotIndices[i];
+    }
+}
+
+safe_VkVideoEncodeAV1PictureInfoKHR& safe_VkVideoEncodeAV1PictureInfoKHR::operator=(
+    const safe_VkVideoEncodeAV1PictureInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pStdPictureInfo) delete pStdPictureInfo;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    predictionMode = copy_src.predictionMode;
+    rateControlGroup = copy_src.rateControlGroup;
+    constantQIndex = copy_src.constantQIndex;
+    pStdPictureInfo = nullptr;
+    primaryReferenceCdfOnly = copy_src.primaryReferenceCdfOnly;
+    generateObuExtensionHeader = copy_src.generateObuExtensionHeader;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoEncodeAV1PictureInfo(*copy_src.pStdPictureInfo);
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) {
+        referenceNameSlotIndices[i] = copy_src.referenceNameSlotIndices[i];
+    }
+
+    return *this;
+}
+
+safe_VkVideoEncodeAV1PictureInfoKHR::~safe_VkVideoEncodeAV1PictureInfoKHR() {
+    if (pStdPictureInfo) delete pStdPictureInfo;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoEncodeAV1PictureInfoKHR::initialize(const VkVideoEncodeAV1PictureInfoKHR* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pStdPictureInfo) delete pStdPictureInfo;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    predictionMode = in_struct->predictionMode;
+    rateControlGroup = in_struct->rateControlGroup;
+    constantQIndex = in_struct->constantQIndex;
+    pStdPictureInfo = nullptr;
+    primaryReferenceCdfOnly = in_struct->primaryReferenceCdfOnly;
+    generateObuExtensionHeader = in_struct->generateObuExtensionHeader;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoEncodeAV1PictureInfo(*in_struct->pStdPictureInfo);
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) {
+        referenceNameSlotIndices[i] = in_struct->referenceNameSlotIndices[i];
+    }
+}
+
+void safe_VkVideoEncodeAV1PictureInfoKHR::initialize(const safe_VkVideoEncodeAV1PictureInfoKHR* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    predictionMode = copy_src->predictionMode;
+    rateControlGroup = copy_src->rateControlGroup;
+    constantQIndex = copy_src->constantQIndex;
+    pStdPictureInfo = nullptr;
+    primaryReferenceCdfOnly = copy_src->primaryReferenceCdfOnly;
+    generateObuExtensionHeader = copy_src->generateObuExtensionHeader;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoEncodeAV1PictureInfo(*copy_src->pStdPictureInfo);
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i) {
+        referenceNameSlotIndices[i] = copy_src->referenceNameSlotIndices[i];
+    }
+}
+
+safe_VkVideoEncodeAV1DpbSlotInfoKHR::safe_VkVideoEncodeAV1DpbSlotInfoKHR(const VkVideoEncodeAV1DpbSlotInfoKHR* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType), pStdReferenceInfo(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoEncodeAV1ReferenceInfo(*in_struct->pStdReferenceInfo);
+    }
+}
+
+safe_VkVideoEncodeAV1DpbSlotInfoKHR::safe_VkVideoEncodeAV1DpbSlotInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR), pNext(nullptr), pStdReferenceInfo(nullptr) {}
+
+safe_VkVideoEncodeAV1DpbSlotInfoKHR::safe_VkVideoEncodeAV1DpbSlotInfoKHR(const safe_VkVideoEncodeAV1DpbSlotInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pStdReferenceInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoEncodeAV1ReferenceInfo(*copy_src.pStdReferenceInfo);
+    }
+}
+
+safe_VkVideoEncodeAV1DpbSlotInfoKHR& safe_VkVideoEncodeAV1DpbSlotInfoKHR::operator=(
+    const safe_VkVideoEncodeAV1DpbSlotInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pStdReferenceInfo) delete pStdReferenceInfo;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pStdReferenceInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoEncodeAV1ReferenceInfo(*copy_src.pStdReferenceInfo);
+    }
+
+    return *this;
+}
+
+safe_VkVideoEncodeAV1DpbSlotInfoKHR::~safe_VkVideoEncodeAV1DpbSlotInfoKHR() {
+    if (pStdReferenceInfo) delete pStdReferenceInfo;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoEncodeAV1DpbSlotInfoKHR::initialize(const VkVideoEncodeAV1DpbSlotInfoKHR* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pStdReferenceInfo) delete pStdReferenceInfo;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pStdReferenceInfo = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoEncodeAV1ReferenceInfo(*in_struct->pStdReferenceInfo);
+    }
+}
+
+void safe_VkVideoEncodeAV1DpbSlotInfoKHR::initialize(const safe_VkVideoEncodeAV1DpbSlotInfoKHR* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pStdReferenceInfo = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pStdReferenceInfo) {
+        pStdReferenceInfo = new StdVideoEncodeAV1ReferenceInfo(*copy_src->pStdReferenceInfo);
+    }
+}
+
+safe_VkVideoEncodeAV1ProfileInfoKHR::safe_VkVideoEncodeAV1ProfileInfoKHR(const VkVideoEncodeAV1ProfileInfoKHR* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType), stdProfile(in_struct->stdProfile) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeAV1ProfileInfoKHR::safe_VkVideoEncodeAV1ProfileInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR), pNext(nullptr), stdProfile() {}
+
+safe_VkVideoEncodeAV1ProfileInfoKHR::safe_VkVideoEncodeAV1ProfileInfoKHR(const safe_VkVideoEncodeAV1ProfileInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    stdProfile = copy_src.stdProfile;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeAV1ProfileInfoKHR& safe_VkVideoEncodeAV1ProfileInfoKHR::operator=(
+    const safe_VkVideoEncodeAV1ProfileInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    stdProfile = copy_src.stdProfile;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeAV1ProfileInfoKHR::~safe_VkVideoEncodeAV1ProfileInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeAV1ProfileInfoKHR::initialize(const VkVideoEncodeAV1ProfileInfoKHR* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    stdProfile = in_struct->stdProfile;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeAV1ProfileInfoKHR::initialize(const safe_VkVideoEncodeAV1ProfileInfoKHR* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stdProfile = copy_src->stdProfile;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR::safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR(
+    const VkVideoEncodeAV1GopRemainingFrameInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      useGopRemainingFrames(in_struct->useGopRemainingFrames),
+      gopRemainingIntra(in_struct->gopRemainingIntra),
+      gopRemainingPredictive(in_struct->gopRemainingPredictive),
+      gopRemainingBipredictive(in_struct->gopRemainingBipredictive) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR::safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR),
+      pNext(nullptr),
+      useGopRemainingFrames(),
+      gopRemainingIntra(),
+      gopRemainingPredictive(),
+      gopRemainingBipredictive() {}
+
+safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR::safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR(
+    const safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    useGopRemainingFrames = copy_src.useGopRemainingFrames;
+    gopRemainingIntra = copy_src.gopRemainingIntra;
+    gopRemainingPredictive = copy_src.gopRemainingPredictive;
+    gopRemainingBipredictive = copy_src.gopRemainingBipredictive;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR& safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR::operator=(
+    const safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    useGopRemainingFrames = copy_src.useGopRemainingFrames;
+    gopRemainingIntra = copy_src.gopRemainingIntra;
+    gopRemainingPredictive = copy_src.gopRemainingPredictive;
+    gopRemainingBipredictive = copy_src.gopRemainingBipredictive;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR::~safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR::initialize(const VkVideoEncodeAV1GopRemainingFrameInfoKHR* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    useGopRemainingFrames = in_struct->useGopRemainingFrames;
+    gopRemainingIntra = in_struct->gopRemainingIntra;
+    gopRemainingPredictive = in_struct->gopRemainingPredictive;
+    gopRemainingBipredictive = in_struct->gopRemainingBipredictive;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR::initialize(const safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    useGopRemainingFrames = copy_src->useGopRemainingFrames;
+    gopRemainingIntra = copy_src->gopRemainingIntra;
+    gopRemainingPredictive = copy_src->gopRemainingPredictive;
+    gopRemainingBipredictive = copy_src->gopRemainingBipredictive;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeAV1RateControlInfoKHR::safe_VkVideoEncodeAV1RateControlInfoKHR(
+    const VkVideoEncodeAV1RateControlInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      gopFrameCount(in_struct->gopFrameCount),
+      keyFramePeriod(in_struct->keyFramePeriod),
+      consecutiveBipredictiveFrameCount(in_struct->consecutiveBipredictiveFrameCount),
+      temporalLayerCount(in_struct->temporalLayerCount) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeAV1RateControlInfoKHR::safe_VkVideoEncodeAV1RateControlInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR),
+      pNext(nullptr),
+      flags(),
+      gopFrameCount(),
+      keyFramePeriod(),
+      consecutiveBipredictiveFrameCount(),
+      temporalLayerCount() {}
+
+safe_VkVideoEncodeAV1RateControlInfoKHR::safe_VkVideoEncodeAV1RateControlInfoKHR(
+    const safe_VkVideoEncodeAV1RateControlInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    gopFrameCount = copy_src.gopFrameCount;
+    keyFramePeriod = copy_src.keyFramePeriod;
+    consecutiveBipredictiveFrameCount = copy_src.consecutiveBipredictiveFrameCount;
+    temporalLayerCount = copy_src.temporalLayerCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeAV1RateControlInfoKHR& safe_VkVideoEncodeAV1RateControlInfoKHR::operator=(
+    const safe_VkVideoEncodeAV1RateControlInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    gopFrameCount = copy_src.gopFrameCount;
+    keyFramePeriod = copy_src.keyFramePeriod;
+    consecutiveBipredictiveFrameCount = copy_src.consecutiveBipredictiveFrameCount;
+    temporalLayerCount = copy_src.temporalLayerCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeAV1RateControlInfoKHR::~safe_VkVideoEncodeAV1RateControlInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeAV1RateControlInfoKHR::initialize(const VkVideoEncodeAV1RateControlInfoKHR* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    gopFrameCount = in_struct->gopFrameCount;
+    keyFramePeriod = in_struct->keyFramePeriod;
+    consecutiveBipredictiveFrameCount = in_struct->consecutiveBipredictiveFrameCount;
+    temporalLayerCount = in_struct->temporalLayerCount;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeAV1RateControlInfoKHR::initialize(const safe_VkVideoEncodeAV1RateControlInfoKHR* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    gopFrameCount = copy_src->gopFrameCount;
+    keyFramePeriod = copy_src->keyFramePeriod;
+    consecutiveBipredictiveFrameCount = copy_src->consecutiveBipredictiveFrameCount;
+    temporalLayerCount = copy_src->temporalLayerCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeAV1RateControlLayerInfoKHR::safe_VkVideoEncodeAV1RateControlLayerInfoKHR(
+    const VkVideoEncodeAV1RateControlLayerInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      useMinQIndex(in_struct->useMinQIndex),
+      minQIndex(in_struct->minQIndex),
+      useMaxQIndex(in_struct->useMaxQIndex),
+      maxQIndex(in_struct->maxQIndex),
+      useMaxFrameSize(in_struct->useMaxFrameSize),
+      maxFrameSize(in_struct->maxFrameSize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeAV1RateControlLayerInfoKHR::safe_VkVideoEncodeAV1RateControlLayerInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR),
+      pNext(nullptr),
+      useMinQIndex(),
+      minQIndex(),
+      useMaxQIndex(),
+      maxQIndex(),
+      useMaxFrameSize(),
+      maxFrameSize() {}
+
+safe_VkVideoEncodeAV1RateControlLayerInfoKHR::safe_VkVideoEncodeAV1RateControlLayerInfoKHR(
+    const safe_VkVideoEncodeAV1RateControlLayerInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    useMinQIndex = copy_src.useMinQIndex;
+    minQIndex = copy_src.minQIndex;
+    useMaxQIndex = copy_src.useMaxQIndex;
+    maxQIndex = copy_src.maxQIndex;
+    useMaxFrameSize = copy_src.useMaxFrameSize;
+    maxFrameSize = copy_src.maxFrameSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeAV1RateControlLayerInfoKHR& safe_VkVideoEncodeAV1RateControlLayerInfoKHR::operator=(
+    const safe_VkVideoEncodeAV1RateControlLayerInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    useMinQIndex = copy_src.useMinQIndex;
+    minQIndex = copy_src.minQIndex;
+    useMaxQIndex = copy_src.useMaxQIndex;
+    maxQIndex = copy_src.maxQIndex;
+    useMaxFrameSize = copy_src.useMaxFrameSize;
+    maxFrameSize = copy_src.maxFrameSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeAV1RateControlLayerInfoKHR::~safe_VkVideoEncodeAV1RateControlLayerInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeAV1RateControlLayerInfoKHR::initialize(const VkVideoEncodeAV1RateControlLayerInfoKHR* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    useMinQIndex = in_struct->useMinQIndex;
+    minQIndex = in_struct->minQIndex;
+    useMaxQIndex = in_struct->useMaxQIndex;
+    maxQIndex = in_struct->maxQIndex;
+    useMaxFrameSize = in_struct->useMaxFrameSize;
+    maxFrameSize = in_struct->maxFrameSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeAV1RateControlLayerInfoKHR::initialize(const safe_VkVideoEncodeAV1RateControlLayerInfoKHR* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    useMinQIndex = copy_src->useMinQIndex;
+    minQIndex = copy_src->minQIndex;
+    useMaxQIndex = copy_src->useMaxQIndex;
+    maxQIndex = copy_src->maxQIndex;
+    useMaxFrameSize = copy_src->useMaxFrameSize;
+    maxFrameSize = copy_src->maxFrameSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(
     const VkPhysicalDeviceVideoMaintenance1FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType), videoMaintenance1(in_struct->videoMaintenance1) {
@@ -15002,6 +16045,525 @@ void safe_VkPushDescriptorSetWithTemplateInfoKHR::initialize(const safe_VkPushDe
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkVideoEncodeQuantizationMapCapabilitiesKHR::safe_VkVideoEncodeQuantizationMapCapabilitiesKHR(
+    const VkVideoEncodeQuantizationMapCapabilitiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), maxQuantizationMapExtent(in_struct->maxQuantizationMapExtent) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeQuantizationMapCapabilitiesKHR::safe_VkVideoEncodeQuantizationMapCapabilitiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR), pNext(nullptr), maxQuantizationMapExtent() {}
+
+safe_VkVideoEncodeQuantizationMapCapabilitiesKHR::safe_VkVideoEncodeQuantizationMapCapabilitiesKHR(
+    const safe_VkVideoEncodeQuantizationMapCapabilitiesKHR& copy_src) {
+    sType = copy_src.sType;
+    maxQuantizationMapExtent = copy_src.maxQuantizationMapExtent;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeQuantizationMapCapabilitiesKHR& safe_VkVideoEncodeQuantizationMapCapabilitiesKHR::operator=(
+    const safe_VkVideoEncodeQuantizationMapCapabilitiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxQuantizationMapExtent = copy_src.maxQuantizationMapExtent;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeQuantizationMapCapabilitiesKHR::~safe_VkVideoEncodeQuantizationMapCapabilitiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeQuantizationMapCapabilitiesKHR::initialize(const VkVideoEncodeQuantizationMapCapabilitiesKHR* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxQuantizationMapExtent = in_struct->maxQuantizationMapExtent;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeQuantizationMapCapabilitiesKHR::initialize(const safe_VkVideoEncodeQuantizationMapCapabilitiesKHR* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxQuantizationMapExtent = copy_src->maxQuantizationMapExtent;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoFormatQuantizationMapPropertiesKHR::safe_VkVideoFormatQuantizationMapPropertiesKHR(
+    const VkVideoFormatQuantizationMapPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), quantizationMapTexelSize(in_struct->quantizationMapTexelSize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoFormatQuantizationMapPropertiesKHR::safe_VkVideoFormatQuantizationMapPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR), pNext(nullptr), quantizationMapTexelSize() {}
+
+safe_VkVideoFormatQuantizationMapPropertiesKHR::safe_VkVideoFormatQuantizationMapPropertiesKHR(
+    const safe_VkVideoFormatQuantizationMapPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    quantizationMapTexelSize = copy_src.quantizationMapTexelSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoFormatQuantizationMapPropertiesKHR& safe_VkVideoFormatQuantizationMapPropertiesKHR::operator=(
+    const safe_VkVideoFormatQuantizationMapPropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    quantizationMapTexelSize = copy_src.quantizationMapTexelSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoFormatQuantizationMapPropertiesKHR::~safe_VkVideoFormatQuantizationMapPropertiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoFormatQuantizationMapPropertiesKHR::initialize(const VkVideoFormatQuantizationMapPropertiesKHR* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    quantizationMapTexelSize = in_struct->quantizationMapTexelSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoFormatQuantizationMapPropertiesKHR::initialize(const safe_VkVideoFormatQuantizationMapPropertiesKHR* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    quantizationMapTexelSize = copy_src->quantizationMapTexelSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeQuantizationMapInfoKHR::safe_VkVideoEncodeQuantizationMapInfoKHR(
+    const VkVideoEncodeQuantizationMapInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      quantizationMap(in_struct->quantizationMap),
+      quantizationMapExtent(in_struct->quantizationMapExtent) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeQuantizationMapInfoKHR::safe_VkVideoEncodeQuantizationMapInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR), pNext(nullptr), quantizationMap(), quantizationMapExtent() {}
+
+safe_VkVideoEncodeQuantizationMapInfoKHR::safe_VkVideoEncodeQuantizationMapInfoKHR(
+    const safe_VkVideoEncodeQuantizationMapInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    quantizationMap = copy_src.quantizationMap;
+    quantizationMapExtent = copy_src.quantizationMapExtent;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeQuantizationMapInfoKHR& safe_VkVideoEncodeQuantizationMapInfoKHR::operator=(
+    const safe_VkVideoEncodeQuantizationMapInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    quantizationMap = copy_src.quantizationMap;
+    quantizationMapExtent = copy_src.quantizationMapExtent;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeQuantizationMapInfoKHR::~safe_VkVideoEncodeQuantizationMapInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoEncodeQuantizationMapInfoKHR::initialize(const VkVideoEncodeQuantizationMapInfoKHR* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    quantizationMap = in_struct->quantizationMap;
+    quantizationMapExtent = in_struct->quantizationMapExtent;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeQuantizationMapInfoKHR::initialize(const safe_VkVideoEncodeQuantizationMapInfoKHR* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    quantizationMap = copy_src->quantizationMap;
+    quantizationMapExtent = copy_src->quantizationMapExtent;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR::safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR(
+    const VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), quantizationMapTexelSize(in_struct->quantizationMapTexelSize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR::safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR),
+      pNext(nullptr),
+      quantizationMapTexelSize() {}
+
+safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR::safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR(
+    const safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    quantizationMapTexelSize = copy_src.quantizationMapTexelSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR&
+safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR::operator=(
+    const safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    quantizationMapTexelSize = copy_src.quantizationMapTexelSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR::
+    ~safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR::initialize(
+    const VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    quantizationMapTexelSize = in_struct->quantizationMapTexelSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR::initialize(
+    const safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    quantizationMapTexelSize = copy_src->quantizationMapTexelSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR::safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR(
+    const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), videoEncodeQuantizationMap(in_struct->videoEncodeQuantizationMap) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR::safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR),
+      pNext(nullptr),
+      videoEncodeQuantizationMap() {}
+
+safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR::safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR(
+    const safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    videoEncodeQuantizationMap = copy_src.videoEncodeQuantizationMap;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR& safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    videoEncodeQuantizationMap = copy_src.videoEncodeQuantizationMap;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR::~safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR::initialize(
+    const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    videoEncodeQuantizationMap = in_struct->videoEncodeQuantizationMap;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR::initialize(
+    const safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    videoEncodeQuantizationMap = copy_src->videoEncodeQuantizationMap;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR::safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR(
+    const VkVideoEncodeH264QuantizationMapCapabilitiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), minQpDelta(in_struct->minQpDelta), maxQpDelta(in_struct->maxQpDelta) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR::safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR), pNext(nullptr), minQpDelta(), maxQpDelta() {}
+
+safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR::safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR(
+    const safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR& copy_src) {
+    sType = copy_src.sType;
+    minQpDelta = copy_src.minQpDelta;
+    maxQpDelta = copy_src.maxQpDelta;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR& safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR::operator=(
+    const safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    minQpDelta = copy_src.minQpDelta;
+    maxQpDelta = copy_src.maxQpDelta;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR::~safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR::initialize(
+    const VkVideoEncodeH264QuantizationMapCapabilitiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    minQpDelta = in_struct->minQpDelta;
+    maxQpDelta = in_struct->maxQpDelta;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR::initialize(
+    const safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    minQpDelta = copy_src->minQpDelta;
+    maxQpDelta = copy_src->maxQpDelta;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR::safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR(
+    const VkVideoEncodeH265QuantizationMapCapabilitiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), minQpDelta(in_struct->minQpDelta), maxQpDelta(in_struct->maxQpDelta) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR::safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR), pNext(nullptr), minQpDelta(), maxQpDelta() {}
+
+safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR::safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR(
+    const safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR& copy_src) {
+    sType = copy_src.sType;
+    minQpDelta = copy_src.minQpDelta;
+    maxQpDelta = copy_src.maxQpDelta;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR& safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR::operator=(
+    const safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    minQpDelta = copy_src.minQpDelta;
+    maxQpDelta = copy_src.maxQpDelta;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR::~safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR::initialize(
+    const VkVideoEncodeH265QuantizationMapCapabilitiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    minQpDelta = in_struct->minQpDelta;
+    maxQpDelta = in_struct->maxQpDelta;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR::initialize(
+    const safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    minQpDelta = copy_src->minQpDelta;
+    maxQpDelta = copy_src->maxQpDelta;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoFormatH265QuantizationMapPropertiesKHR::safe_VkVideoFormatH265QuantizationMapPropertiesKHR(
+    const VkVideoFormatH265QuantizationMapPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), compatibleCtbSizes(in_struct->compatibleCtbSizes) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoFormatH265QuantizationMapPropertiesKHR::safe_VkVideoFormatH265QuantizationMapPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR), pNext(nullptr), compatibleCtbSizes() {}
+
+safe_VkVideoFormatH265QuantizationMapPropertiesKHR::safe_VkVideoFormatH265QuantizationMapPropertiesKHR(
+    const safe_VkVideoFormatH265QuantizationMapPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    compatibleCtbSizes = copy_src.compatibleCtbSizes;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoFormatH265QuantizationMapPropertiesKHR& safe_VkVideoFormatH265QuantizationMapPropertiesKHR::operator=(
+    const safe_VkVideoFormatH265QuantizationMapPropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    compatibleCtbSizes = copy_src.compatibleCtbSizes;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoFormatH265QuantizationMapPropertiesKHR::~safe_VkVideoFormatH265QuantizationMapPropertiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoFormatH265QuantizationMapPropertiesKHR::initialize(const VkVideoFormatH265QuantizationMapPropertiesKHR* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    compatibleCtbSizes = in_struct->compatibleCtbSizes;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoFormatH265QuantizationMapPropertiesKHR::initialize(
+    const safe_VkVideoFormatH265QuantizationMapPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    compatibleCtbSizes = copy_src->compatibleCtbSizes;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR::safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR(
+    const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), minQIndexDelta(in_struct->minQIndexDelta), maxQIndexDelta(in_struct->maxQIndexDelta) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR::safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR),
+      pNext(nullptr),
+      minQIndexDelta(),
+      maxQIndexDelta() {}
+
+safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR::safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR(
+    const safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR& copy_src) {
+    sType = copy_src.sType;
+    minQIndexDelta = copy_src.minQIndexDelta;
+    maxQIndexDelta = copy_src.maxQIndexDelta;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR& safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR::operator=(
+    const safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    minQIndexDelta = copy_src.minQIndexDelta;
+    maxQIndexDelta = copy_src.maxQIndexDelta;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR::~safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR::initialize(
+    const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    minQIndexDelta = in_struct->minQIndexDelta;
+    maxQIndexDelta = in_struct->maxQIndexDelta;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR::initialize(
+    const safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    minQIndexDelta = copy_src->minQIndexDelta;
+    maxQIndexDelta = copy_src->maxQIndexDelta;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoFormatAV1QuantizationMapPropertiesKHR::safe_VkVideoFormatAV1QuantizationMapPropertiesKHR(
+    const VkVideoFormatAV1QuantizationMapPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), compatibleSuperblockSizes(in_struct->compatibleSuperblockSizes) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoFormatAV1QuantizationMapPropertiesKHR::safe_VkVideoFormatAV1QuantizationMapPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR), pNext(nullptr), compatibleSuperblockSizes() {}
+
+safe_VkVideoFormatAV1QuantizationMapPropertiesKHR::safe_VkVideoFormatAV1QuantizationMapPropertiesKHR(
+    const safe_VkVideoFormatAV1QuantizationMapPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    compatibleSuperblockSizes = copy_src.compatibleSuperblockSizes;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoFormatAV1QuantizationMapPropertiesKHR& safe_VkVideoFormatAV1QuantizationMapPropertiesKHR::operator=(
+    const safe_VkVideoFormatAV1QuantizationMapPropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    compatibleSuperblockSizes = copy_src.compatibleSuperblockSizes;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoFormatAV1QuantizationMapPropertiesKHR::~safe_VkVideoFormatAV1QuantizationMapPropertiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoFormatAV1QuantizationMapPropertiesKHR::initialize(const VkVideoFormatAV1QuantizationMapPropertiesKHR* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    compatibleSuperblockSizes = in_struct->compatibleSuperblockSizes;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoFormatAV1QuantizationMapPropertiesKHR::initialize(
+    const safe_VkVideoFormatAV1QuantizationMapPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    compatibleSuperblockSizes = copy_src->compatibleSuperblockSizes;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR::safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR(
     const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
     bool copy_pnext)
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index 3f0b37c..1f1f6fe 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -737,6 +737,39 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR:
                 safe_pNext = new safe_VkVideoDecodeAV1DpbSlotInfoKHR(reinterpret_cast<const VkVideoDecodeAV1DpbSlotInfoKHR *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR:
+                safe_pNext = new safe_VkVideoEncodeAV1CapabilitiesKHR(reinterpret_cast<const VkVideoEncodeAV1CapabilitiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR:
+                safe_pNext = new safe_VkVideoEncodeAV1QualityLevelPropertiesKHR(reinterpret_cast<const VkVideoEncodeAV1QualityLevelPropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeAV1SessionCreateInfoKHR(reinterpret_cast<const VkVideoEncodeAV1SessionCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR(reinterpret_cast<const VkVideoEncodeAV1SessionParametersCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeAV1PictureInfoKHR(reinterpret_cast<const VkVideoEncodeAV1PictureInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeAV1DpbSlotInfoKHR(reinterpret_cast<const VkVideoEncodeAV1DpbSlotInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeAV1ProfileInfoKHR(reinterpret_cast<const VkVideoEncodeAV1ProfileInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR(reinterpret_cast<const VkVideoEncodeAV1GopRemainingFrameInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeAV1RateControlInfoKHR(reinterpret_cast<const VkVideoEncodeAV1RateControlInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeAV1RateControlLayerInfoKHR(reinterpret_cast<const VkVideoEncodeAV1RateControlLayerInfoKHR *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
                 safe_pNext = new safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *>(pNext), copy_state, false);
                 break;
@@ -779,6 +812,36 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR:
                 safe_pNext = new safe_VkBindMemoryStatusKHR(reinterpret_cast<const VkBindMemoryStatusKHR *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR:
+                safe_pNext = new safe_VkVideoEncodeQuantizationMapCapabilitiesKHR(reinterpret_cast<const VkVideoEncodeQuantizationMapCapabilitiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR:
+                safe_pNext = new safe_VkVideoFormatQuantizationMapPropertiesKHR(reinterpret_cast<const VkVideoFormatQuantizationMapPropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeQuantizationMapInfoKHR(reinterpret_cast<const VkVideoEncodeQuantizationMapInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR:
+                safe_pNext = new safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR(reinterpret_cast<const VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR:
+                safe_pNext = new safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR(reinterpret_cast<const VkVideoEncodeH264QuantizationMapCapabilitiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR:
+                safe_pNext = new safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR(reinterpret_cast<const VkVideoEncodeH265QuantizationMapCapabilitiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR:
+                safe_pNext = new safe_VkVideoFormatH265QuantizationMapPropertiesKHR(reinterpret_cast<const VkVideoFormatH265QuantizationMapPropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR:
+                safe_pNext = new safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR(reinterpret_cast<const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR:
+                safe_pNext = new safe_VkVideoFormatAV1QuantizationMapPropertiesKHR(reinterpret_cast<const VkVideoFormatAV1QuantizationMapPropertiesKHR *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR:
                 safe_pNext = new safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *>(pNext), copy_state, false);
                 break;
@@ -818,6 +881,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
                 safe_pNext = new safe_VkPipelineRasterizationStateStreamCreateInfoEXT(reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX:
+                safe_pNext = new safe_VkCuModuleTexturingModeCreateInfoNVX(reinterpret_cast<const VkCuModuleTexturingModeCreateInfoNVX *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
                 safe_pNext = new safe_VkTextureLODGatherFormatPropertiesAMD(reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD *>(pNext), copy_state, false);
                 break;
@@ -1828,6 +1894,12 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
                 safe_pNext = new safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV(reinterpret_cast<const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV:
+                safe_pNext = new safe_VkDisplaySurfaceStereoCreateInfoNV(reinterpret_cast<const VkDisplaySurfaceStereoCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV:
+                safe_pNext = new safe_VkDisplayModeStereoPropertiesNV(reinterpret_cast<const VkDisplayModeStereoPropertiesNV *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
                 safe_pNext = new safe_VkPhysicalDeviceRawAccessChainsFeaturesNV(reinterpret_cast<const VkPhysicalDeviceRawAccessChainsFeaturesNV *>(pNext), copy_state, false);
                 break;
@@ -1882,6 +1954,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV:
                 safe_pNext = new safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrix2PropertiesNV *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
                 safe_pNext = new safe_VkWriteDescriptorSetAccelerationStructureKHR(reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR *>(pNext), copy_state, false);
                 break;
@@ -2635,6 +2710,39 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR:
             delete reinterpret_cast<safe_VkVideoDecodeAV1DpbSlotInfoKHR *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR:
+            delete reinterpret_cast<safe_VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR:
+            delete reinterpret_cast<safe_VkVideoEncodeAV1CapabilitiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR:
+            delete reinterpret_cast<safe_VkVideoEncodeAV1QualityLevelPropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR:
+            delete reinterpret_cast<safe_VkVideoEncodeAV1SessionCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR:
+            delete reinterpret_cast<safe_VkVideoEncodeAV1SessionParametersCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR:
+            delete reinterpret_cast<safe_VkVideoEncodeAV1PictureInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR:
+            delete reinterpret_cast<safe_VkVideoEncodeAV1DpbSlotInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR:
+            delete reinterpret_cast<safe_VkVideoEncodeAV1ProfileInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR:
+            delete reinterpret_cast<safe_VkVideoEncodeAV1GopRemainingFrameInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR:
+            delete reinterpret_cast<safe_VkVideoEncodeAV1RateControlInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR:
+            delete reinterpret_cast<safe_VkVideoEncodeAV1RateControlLayerInfoKHR *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
             delete reinterpret_cast<safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR *>(header);
             break;
@@ -2677,6 +2785,36 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR:
             delete reinterpret_cast<safe_VkBindMemoryStatusKHR *>(header);
             break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR:
+            delete reinterpret_cast<safe_VkVideoEncodeQuantizationMapCapabilitiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR:
+            delete reinterpret_cast<safe_VkVideoFormatQuantizationMapPropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR:
+            delete reinterpret_cast<safe_VkVideoEncodeQuantizationMapInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR:
+            delete reinterpret_cast<safe_VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR:
+            delete reinterpret_cast<safe_VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR:
+            delete reinterpret_cast<safe_VkVideoEncodeH264QuantizationMapCapabilitiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR:
+            delete reinterpret_cast<safe_VkVideoEncodeH265QuantizationMapCapabilitiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR:
+            delete reinterpret_cast<safe_VkVideoFormatH265QuantizationMapPropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR:
+            delete reinterpret_cast<safe_VkVideoEncodeAV1QuantizationMapCapabilitiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR:
+            delete reinterpret_cast<safe_VkVideoFormatAV1QuantizationMapPropertiesKHR *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR:
             delete reinterpret_cast<safe_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *>(header);
             break;
@@ -2716,6 +2854,9 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
             delete reinterpret_cast<safe_VkPipelineRasterizationStateStreamCreateInfoEXT *>(header);
             break;
+        case VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX:
+            delete reinterpret_cast<safe_VkCuModuleTexturingModeCreateInfoNVX *>(header);
+            break;
         case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
             delete reinterpret_cast<safe_VkTextureLODGatherFormatPropertiesAMD *>(header);
             break;
@@ -3726,6 +3867,12 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
             delete reinterpret_cast<safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *>(header);
             break;
+        case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV:
+            delete reinterpret_cast<safe_VkDisplaySurfaceStereoCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV:
+            delete reinterpret_cast<safe_VkDisplayModeStereoPropertiesNV *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
             delete reinterpret_cast<safe_VkPhysicalDeviceRawAccessChainsFeaturesNV *>(header);
             break;
@@ -3780,6 +3927,9 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV:
             delete reinterpret_cast<safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
+            delete reinterpret_cast<safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *>(header);
+            break;
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
             delete reinterpret_cast<safe_VkWriteDescriptorSetAccelerationStructureKHR *>(header);
             break;
diff --git a/src/vulkan/vk_safe_struct_vendor.cpp b/src/vulkan/vk_safe_struct_vendor.cpp
index bb764f1..18a87db 100644
--- a/src/vulkan/vk_safe_struct_vendor.cpp
+++ b/src/vulkan/vk_safe_struct_vendor.cpp
@@ -309,6 +309,54 @@ void safe_VkCuModuleCreateInfoNVX::initialize(const safe_VkCuModuleCreateInfoNVX
     }
 }
 
+safe_VkCuModuleTexturingModeCreateInfoNVX::safe_VkCuModuleTexturingModeCreateInfoNVX(
+    const VkCuModuleTexturingModeCreateInfoNVX* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), use64bitTexturing(in_struct->use64bitTexturing) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkCuModuleTexturingModeCreateInfoNVX::safe_VkCuModuleTexturingModeCreateInfoNVX()
+    : sType(VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX), pNext(nullptr), use64bitTexturing() {}
+
+safe_VkCuModuleTexturingModeCreateInfoNVX::safe_VkCuModuleTexturingModeCreateInfoNVX(
+    const safe_VkCuModuleTexturingModeCreateInfoNVX& copy_src) {
+    sType = copy_src.sType;
+    use64bitTexturing = copy_src.use64bitTexturing;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkCuModuleTexturingModeCreateInfoNVX& safe_VkCuModuleTexturingModeCreateInfoNVX::operator=(
+    const safe_VkCuModuleTexturingModeCreateInfoNVX& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    use64bitTexturing = copy_src.use64bitTexturing;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkCuModuleTexturingModeCreateInfoNVX::~safe_VkCuModuleTexturingModeCreateInfoNVX() { FreePnextChain(pNext); }
+
+void safe_VkCuModuleTexturingModeCreateInfoNVX::initialize(const VkCuModuleTexturingModeCreateInfoNVX* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    use64bitTexturing = in_struct->use64bitTexturing;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkCuModuleTexturingModeCreateInfoNVX::initialize(const safe_VkCuModuleTexturingModeCreateInfoNVX* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    use64bitTexturing = copy_src->use64bitTexturing;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkCuFunctionCreateInfoNVX::safe_VkCuFunctionCreateInfoNVX(const VkCuFunctionCreateInfoNVX* in_struct,
                                                                [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType), module(in_struct->module) {
@@ -15111,6 +15159,102 @@ void safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV::initialize(
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkDisplaySurfaceStereoCreateInfoNV::safe_VkDisplaySurfaceStereoCreateInfoNV(
+    const VkDisplaySurfaceStereoCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), stereoType(in_struct->stereoType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDisplaySurfaceStereoCreateInfoNV::safe_VkDisplaySurfaceStereoCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV), pNext(nullptr), stereoType() {}
+
+safe_VkDisplaySurfaceStereoCreateInfoNV::safe_VkDisplaySurfaceStereoCreateInfoNV(
+    const safe_VkDisplaySurfaceStereoCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    stereoType = copy_src.stereoType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDisplaySurfaceStereoCreateInfoNV& safe_VkDisplaySurfaceStereoCreateInfoNV::operator=(
+    const safe_VkDisplaySurfaceStereoCreateInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    stereoType = copy_src.stereoType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDisplaySurfaceStereoCreateInfoNV::~safe_VkDisplaySurfaceStereoCreateInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkDisplaySurfaceStereoCreateInfoNV::initialize(const VkDisplaySurfaceStereoCreateInfoNV* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    stereoType = in_struct->stereoType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDisplaySurfaceStereoCreateInfoNV::initialize(const safe_VkDisplaySurfaceStereoCreateInfoNV* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stereoType = copy_src->stereoType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDisplayModeStereoPropertiesNV::safe_VkDisplayModeStereoPropertiesNV(const VkDisplayModeStereoPropertiesNV* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), hdmi3DSupported(in_struct->hdmi3DSupported) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDisplayModeStereoPropertiesNV::safe_VkDisplayModeStereoPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV), pNext(nullptr), hdmi3DSupported() {}
+
+safe_VkDisplayModeStereoPropertiesNV::safe_VkDisplayModeStereoPropertiesNV(const safe_VkDisplayModeStereoPropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    hdmi3DSupported = copy_src.hdmi3DSupported;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDisplayModeStereoPropertiesNV& safe_VkDisplayModeStereoPropertiesNV::operator=(
+    const safe_VkDisplayModeStereoPropertiesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    hdmi3DSupported = copy_src.hdmi3DSupported;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDisplayModeStereoPropertiesNV::~safe_VkDisplayModeStereoPropertiesNV() { FreePnextChain(pNext); }
+
+void safe_VkDisplayModeStereoPropertiesNV::initialize(const VkDisplayModeStereoPropertiesNV* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    hdmi3DSupported = in_struct->hdmi3DSupported;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDisplayModeStereoPropertiesNV::initialize(const safe_VkDisplayModeStereoPropertiesNV* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    hdmi3DSupported = copy_src->hdmi3DSupported;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkPhysicalDeviceRawAccessChainsFeaturesNV::safe_VkPhysicalDeviceRawAccessChainsFeaturesNV(
     const VkPhysicalDeviceRawAccessChainsFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType), shaderRawAccessChains(in_struct->shaderRawAccessChains) {

From 5a72ae0208f1bf116af74ef31cc6f6c7ff4acec6 Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Mon, 2 Dec 2024 08:31:27 -0800
Subject: [PATCH 066/106] build: Update to header 1.4.303

---
 include/vulkan/utility/vk_dispatch_table.h  |   38 +
 include/vulkan/utility/vk_format_utils.h    |   12 +-
 include/vulkan/utility/vk_safe_struct.hpp   | 1966 +++++-----
 include/vulkan/utility/vk_struct_helper.hpp |   98 +-
 include/vulkan/vk_enum_string_helper.h      |  680 ++--
 scripts/generators/safe_struct_generator.py |    6 +-
 scripts/known_good.json                     |    2 +-
 src/vulkan/vk_safe_struct_core.cpp          | 3814 +++++++++++++++++++
 src/vulkan/vk_safe_struct_ext.cpp           | 1106 ------
 src/vulkan/vk_safe_struct_khr.cpp           | 2306 -----------
 src/vulkan/vk_safe_struct_utils.cpp         |  396 +-
 11 files changed, 5466 insertions(+), 4958 deletions(-)

diff --git a/include/vulkan/utility/vk_dispatch_table.h b/include/vulkan/utility/vk_dispatch_table.h
index dcd4f4b..d8f80c4 100644
--- a/include/vulkan/utility/vk_dispatch_table.h
+++ b/include/vulkan/utility/vk_dispatch_table.h
@@ -352,6 +352,25 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkGetDeviceBufferMemoryRequirements GetDeviceBufferMemoryRequirements;
     PFN_vkGetDeviceImageMemoryRequirements GetDeviceImageMemoryRequirements;
     PFN_vkGetDeviceImageSparseMemoryRequirements GetDeviceImageSparseMemoryRequirements;
+    PFN_vkCmdSetLineStipple CmdSetLineStipple;
+    PFN_vkMapMemory2 MapMemory2;
+    PFN_vkUnmapMemory2 UnmapMemory2;
+    PFN_vkCmdBindIndexBuffer2 CmdBindIndexBuffer2;
+    PFN_vkGetRenderingAreaGranularity GetRenderingAreaGranularity;
+    PFN_vkGetDeviceImageSubresourceLayout GetDeviceImageSubresourceLayout;
+    PFN_vkGetImageSubresourceLayout2 GetImageSubresourceLayout2;
+    PFN_vkCmdPushDescriptorSet CmdPushDescriptorSet;
+    PFN_vkCmdPushDescriptorSetWithTemplate CmdPushDescriptorSetWithTemplate;
+    PFN_vkCmdSetRenderingAttachmentLocations CmdSetRenderingAttachmentLocations;
+    PFN_vkCmdSetRenderingInputAttachmentIndices CmdSetRenderingInputAttachmentIndices;
+    PFN_vkCmdBindDescriptorSets2 CmdBindDescriptorSets2;
+    PFN_vkCmdPushConstants2 CmdPushConstants2;
+    PFN_vkCmdPushDescriptorSet2 CmdPushDescriptorSet2;
+    PFN_vkCmdPushDescriptorSetWithTemplate2 CmdPushDescriptorSetWithTemplate2;
+    PFN_vkCopyMemoryToImage CopyMemoryToImage;
+    PFN_vkCopyImageToMemory CopyImageToMemory;
+    PFN_vkCopyImageToImage CopyImageToImage;
+    PFN_vkTransitionImageLayout TransitionImageLayout;
     PFN_vkCreateSwapchainKHR CreateSwapchainKHR;
     PFN_vkDestroySwapchainKHR DestroySwapchainKHR;
     PFN_vkGetSwapchainImagesKHR GetSwapchainImagesKHR;
@@ -965,6 +984,25 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
     table->GetDeviceBufferMemoryRequirements = (PFN_vkGetDeviceBufferMemoryRequirements)gdpa(device, "vkGetDeviceBufferMemoryRequirements");
     table->GetDeviceImageMemoryRequirements = (PFN_vkGetDeviceImageMemoryRequirements)gdpa(device, "vkGetDeviceImageMemoryRequirements");
     table->GetDeviceImageSparseMemoryRequirements = (PFN_vkGetDeviceImageSparseMemoryRequirements)gdpa(device, "vkGetDeviceImageSparseMemoryRequirements");
+    table->CmdSetLineStipple = (PFN_vkCmdSetLineStipple)gdpa(device, "vkCmdSetLineStipple");
+    table->MapMemory2 = (PFN_vkMapMemory2)gdpa(device, "vkMapMemory2");
+    table->UnmapMemory2 = (PFN_vkUnmapMemory2)gdpa(device, "vkUnmapMemory2");
+    table->CmdBindIndexBuffer2 = (PFN_vkCmdBindIndexBuffer2)gdpa(device, "vkCmdBindIndexBuffer2");
+    table->GetRenderingAreaGranularity = (PFN_vkGetRenderingAreaGranularity)gdpa(device, "vkGetRenderingAreaGranularity");
+    table->GetDeviceImageSubresourceLayout = (PFN_vkGetDeviceImageSubresourceLayout)gdpa(device, "vkGetDeviceImageSubresourceLayout");
+    table->GetImageSubresourceLayout2 = (PFN_vkGetImageSubresourceLayout2)gdpa(device, "vkGetImageSubresourceLayout2");
+    table->CmdPushDescriptorSet = (PFN_vkCmdPushDescriptorSet)gdpa(device, "vkCmdPushDescriptorSet");
+    table->CmdPushDescriptorSetWithTemplate = (PFN_vkCmdPushDescriptorSetWithTemplate)gdpa(device, "vkCmdPushDescriptorSetWithTemplate");
+    table->CmdSetRenderingAttachmentLocations = (PFN_vkCmdSetRenderingAttachmentLocations)gdpa(device, "vkCmdSetRenderingAttachmentLocations");
+    table->CmdSetRenderingInputAttachmentIndices = (PFN_vkCmdSetRenderingInputAttachmentIndices)gdpa(device, "vkCmdSetRenderingInputAttachmentIndices");
+    table->CmdBindDescriptorSets2 = (PFN_vkCmdBindDescriptorSets2)gdpa(device, "vkCmdBindDescriptorSets2");
+    table->CmdPushConstants2 = (PFN_vkCmdPushConstants2)gdpa(device, "vkCmdPushConstants2");
+    table->CmdPushDescriptorSet2 = (PFN_vkCmdPushDescriptorSet2)gdpa(device, "vkCmdPushDescriptorSet2");
+    table->CmdPushDescriptorSetWithTemplate2 = (PFN_vkCmdPushDescriptorSetWithTemplate2)gdpa(device, "vkCmdPushDescriptorSetWithTemplate2");
+    table->CopyMemoryToImage = (PFN_vkCopyMemoryToImage)gdpa(device, "vkCopyMemoryToImage");
+    table->CopyImageToMemory = (PFN_vkCopyImageToMemory)gdpa(device, "vkCopyImageToMemory");
+    table->CopyImageToImage = (PFN_vkCopyImageToImage)gdpa(device, "vkCopyImageToImage");
+    table->TransitionImageLayout = (PFN_vkTransitionImageLayout)gdpa(device, "vkTransitionImageLayout");
     table->CreateSwapchainKHR = (PFN_vkCreateSwapchainKHR)gdpa(device, "vkCreateSwapchainKHR");
     table->DestroySwapchainKHR = (PFN_vkDestroySwapchainKHR)gdpa(device, "vkDestroySwapchainKHR");
     table->GetSwapchainImagesKHR = (PFN_vkGetSwapchainImagesKHR)gdpa(device, "vkGetSwapchainImagesKHR");
diff --git a/include/vulkan/utility/vk_format_utils.h b/include/vulkan/utility/vk_format_utils.h
index 1b0ea3f..862f8e1 100644
--- a/include/vulkan/utility/vk_format_utils.h
+++ b/include/vulkan/utility/vk_format_utils.h
@@ -381,10 +381,10 @@ inline const struct VKU_FORMAT_INFO vkuGetFormatInfo(VkFormat format) {
         case VK_FORMAT_A1R5G5B5_UNORM_PACK16: {
             struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 1}, {VKU_FORMAT_COMPONENT_TYPE_R, 5}, {VKU_FORMAT_COMPONENT_TYPE_G, 5}, {VKU_FORMAT_COMPONENT_TYPE_B, 5}}};
             return out; }
-        case VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR: {
+        case VK_FORMAT_A1B5G5R5_UNORM_PACK16: {
             struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 1}, {VKU_FORMAT_COMPONENT_TYPE_B, 5}, {VKU_FORMAT_COMPONENT_TYPE_G, 5}, {VKU_FORMAT_COMPONENT_TYPE_R, 5}}};
             return out; }
-        case VK_FORMAT_A8_UNORM_KHR: {
+        case VK_FORMAT_A8_UNORM: {
             struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_8BIT_ALPHA, 1, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_A, 8}}};
             return out; }
         case VK_FORMAT_R8_UNORM: {
@@ -1426,8 +1426,8 @@ bool vkuFormatIsUNORM(VkFormat format) {
         case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
         case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
         case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
-        case VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR:
-        case VK_FORMAT_A8_UNORM_KHR:
+        case VK_FORMAT_A1B5G5R5_UNORM_PACK16:
+        case VK_FORMAT_A8_UNORM:
         case VK_FORMAT_R8_UNORM:
         case VK_FORMAT_R8G8_UNORM:
         case VK_FORMAT_R8G8B8_UNORM:
@@ -1811,7 +1811,7 @@ bool vkuFormatIsPacked(VkFormat format) {
         case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
         case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
         case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
-        case VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR:
+        case VK_FORMAT_A1B5G5R5_UNORM_PACK16:
         case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
         case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
         case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
@@ -2080,7 +2080,7 @@ inline double vkuFormatTexelSizeWithAspect(VkFormat format, VkImageAspectFlagBit
 
 inline bool vkuFormatIs8bit(VkFormat format) {
     switch (format) {
-        case VK_FORMAT_A8_UNORM_KHR:
+        case VK_FORMAT_A8_UNORM:
         case VK_FORMAT_R8_UNORM:
         case VK_FORMAT_R8_SNORM:
         case VK_FORMAT_R8_USCALED:
diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index 39f4ff4..69bc5c4 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -4546,6 +4546,1014 @@ struct safe_VkDeviceImageMemoryRequirements {
     VkDeviceImageMemoryRequirements* ptr() { return reinterpret_cast<VkDeviceImageMemoryRequirements*>(this); }
     VkDeviceImageMemoryRequirements const* ptr() const { return reinterpret_cast<VkDeviceImageMemoryRequirements const*>(this); }
 };
+struct safe_VkPhysicalDeviceVulkan14Features {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 globalPriorityQuery;
+    VkBool32 shaderSubgroupRotate;
+    VkBool32 shaderSubgroupRotateClustered;
+    VkBool32 shaderFloatControls2;
+    VkBool32 shaderExpectAssume;
+    VkBool32 rectangularLines;
+    VkBool32 bresenhamLines;
+    VkBool32 smoothLines;
+    VkBool32 stippledRectangularLines;
+    VkBool32 stippledBresenhamLines;
+    VkBool32 stippledSmoothLines;
+    VkBool32 vertexAttributeInstanceRateDivisor;
+    VkBool32 vertexAttributeInstanceRateZeroDivisor;
+    VkBool32 indexTypeUint8;
+    VkBool32 dynamicRenderingLocalRead;
+    VkBool32 maintenance5;
+    VkBool32 maintenance6;
+    VkBool32 pipelineProtectedAccess;
+    VkBool32 pipelineRobustness;
+    VkBool32 hostImageCopy;
+    VkBool32 pushDescriptor;
+
+    safe_VkPhysicalDeviceVulkan14Features(const VkPhysicalDeviceVulkan14Features* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkPhysicalDeviceVulkan14Features(const safe_VkPhysicalDeviceVulkan14Features& copy_src);
+    safe_VkPhysicalDeviceVulkan14Features& operator=(const safe_VkPhysicalDeviceVulkan14Features& copy_src);
+    safe_VkPhysicalDeviceVulkan14Features();
+    ~safe_VkPhysicalDeviceVulkan14Features();
+    void initialize(const VkPhysicalDeviceVulkan14Features* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceVulkan14Features* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVulkan14Features* ptr() { return reinterpret_cast<VkPhysicalDeviceVulkan14Features*>(this); }
+    VkPhysicalDeviceVulkan14Features const* ptr() const { return reinterpret_cast<VkPhysicalDeviceVulkan14Features const*>(this); }
+};
+struct safe_VkPhysicalDeviceVulkan14Properties {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t lineSubPixelPrecisionBits;
+    uint32_t maxVertexAttribDivisor;
+    VkBool32 supportsNonZeroFirstInstance;
+    uint32_t maxPushDescriptors;
+    VkBool32 dynamicRenderingLocalReadDepthStencilAttachments;
+    VkBool32 dynamicRenderingLocalReadMultisampledAttachments;
+    VkBool32 earlyFragmentMultisampleCoverageAfterSampleCounting;
+    VkBool32 earlyFragmentSampleMaskTestBeforeSampleCounting;
+    VkBool32 depthStencilSwizzleOneSupport;
+    VkBool32 polygonModePointSize;
+    VkBool32 nonStrictSinglePixelWideLinesUseParallelogram;
+    VkBool32 nonStrictWideLinesUseParallelogram;
+    VkBool32 blockTexelViewCompatibleMultipleLayers;
+    uint32_t maxCombinedImageSamplerDescriptorCount;
+    VkBool32 fragmentShadingRateClampCombinerInputs;
+    VkPipelineRobustnessBufferBehavior defaultRobustnessStorageBuffers;
+    VkPipelineRobustnessBufferBehavior defaultRobustnessUniformBuffers;
+    VkPipelineRobustnessBufferBehavior defaultRobustnessVertexInputs;
+    VkPipelineRobustnessImageBehavior defaultRobustnessImages;
+    uint32_t copySrcLayoutCount;
+    VkImageLayout* pCopySrcLayouts{};
+    uint32_t copyDstLayoutCount;
+    VkImageLayout* pCopyDstLayouts{};
+    uint8_t optimalTilingLayoutUUID[VK_UUID_SIZE];
+    VkBool32 identicalMemoryTypeRequirements;
+
+    safe_VkPhysicalDeviceVulkan14Properties(const VkPhysicalDeviceVulkan14Properties* in_struct, PNextCopyState* copy_state = {},
+                                            bool copy_pnext = true);
+    safe_VkPhysicalDeviceVulkan14Properties(const safe_VkPhysicalDeviceVulkan14Properties& copy_src);
+    safe_VkPhysicalDeviceVulkan14Properties& operator=(const safe_VkPhysicalDeviceVulkan14Properties& copy_src);
+    safe_VkPhysicalDeviceVulkan14Properties();
+    ~safe_VkPhysicalDeviceVulkan14Properties();
+    void initialize(const VkPhysicalDeviceVulkan14Properties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceVulkan14Properties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVulkan14Properties* ptr() { return reinterpret_cast<VkPhysicalDeviceVulkan14Properties*>(this); }
+    VkPhysicalDeviceVulkan14Properties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceVulkan14Properties const*>(this);
+    }
+};
+struct safe_VkDeviceQueueGlobalPriorityCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkQueueGlobalPriority globalPriority;
+
+    safe_VkDeviceQueueGlobalPriorityCreateInfo(const VkDeviceQueueGlobalPriorityCreateInfo* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDeviceQueueGlobalPriorityCreateInfo(const safe_VkDeviceQueueGlobalPriorityCreateInfo& copy_src);
+    safe_VkDeviceQueueGlobalPriorityCreateInfo& operator=(const safe_VkDeviceQueueGlobalPriorityCreateInfo& copy_src);
+    safe_VkDeviceQueueGlobalPriorityCreateInfo();
+    ~safe_VkDeviceQueueGlobalPriorityCreateInfo();
+    void initialize(const VkDeviceQueueGlobalPriorityCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDeviceQueueGlobalPriorityCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceQueueGlobalPriorityCreateInfo* ptr() { return reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfo*>(this); }
+    VkDeviceQueueGlobalPriorityCreateInfo const* ptr() const {
+        return reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfo const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceGlobalPriorityQueryFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 globalPriorityQuery;
+
+    safe_VkPhysicalDeviceGlobalPriorityQueryFeatures(const VkPhysicalDeviceGlobalPriorityQueryFeatures* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceGlobalPriorityQueryFeatures(const safe_VkPhysicalDeviceGlobalPriorityQueryFeatures& copy_src);
+    safe_VkPhysicalDeviceGlobalPriorityQueryFeatures& operator=(const safe_VkPhysicalDeviceGlobalPriorityQueryFeatures& copy_src);
+    safe_VkPhysicalDeviceGlobalPriorityQueryFeatures();
+    ~safe_VkPhysicalDeviceGlobalPriorityQueryFeatures();
+    void initialize(const VkPhysicalDeviceGlobalPriorityQueryFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceGlobalPriorityQueryFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceGlobalPriorityQueryFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeatures*>(this);
+    }
+    VkPhysicalDeviceGlobalPriorityQueryFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeatures const*>(this);
+    }
+};
+struct safe_VkQueueFamilyGlobalPriorityProperties {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t priorityCount;
+    VkQueueGlobalPriority priorities[VK_MAX_GLOBAL_PRIORITY_SIZE];
+
+    safe_VkQueueFamilyGlobalPriorityProperties(const VkQueueFamilyGlobalPriorityProperties* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkQueueFamilyGlobalPriorityProperties(const safe_VkQueueFamilyGlobalPriorityProperties& copy_src);
+    safe_VkQueueFamilyGlobalPriorityProperties& operator=(const safe_VkQueueFamilyGlobalPriorityProperties& copy_src);
+    safe_VkQueueFamilyGlobalPriorityProperties();
+    ~safe_VkQueueFamilyGlobalPriorityProperties();
+    void initialize(const VkQueueFamilyGlobalPriorityProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkQueueFamilyGlobalPriorityProperties* copy_src, PNextCopyState* copy_state = {});
+    VkQueueFamilyGlobalPriorityProperties* ptr() { return reinterpret_cast<VkQueueFamilyGlobalPriorityProperties*>(this); }
+    VkQueueFamilyGlobalPriorityProperties const* ptr() const {
+        return reinterpret_cast<VkQueueFamilyGlobalPriorityProperties const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceShaderSubgroupRotateFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderSubgroupRotate;
+    VkBool32 shaderSubgroupRotateClustered;
+
+    safe_VkPhysicalDeviceShaderSubgroupRotateFeatures(const VkPhysicalDeviceShaderSubgroupRotateFeatures* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderSubgroupRotateFeatures(const safe_VkPhysicalDeviceShaderSubgroupRotateFeatures& copy_src);
+    safe_VkPhysicalDeviceShaderSubgroupRotateFeatures& operator=(const safe_VkPhysicalDeviceShaderSubgroupRotateFeatures& copy_src);
+    safe_VkPhysicalDeviceShaderSubgroupRotateFeatures();
+    ~safe_VkPhysicalDeviceShaderSubgroupRotateFeatures();
+    void initialize(const VkPhysicalDeviceShaderSubgroupRotateFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderSubgroupRotateFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderSubgroupRotateFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderSubgroupRotateFeatures*>(this);
+    }
+    VkPhysicalDeviceShaderSubgroupRotateFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderSubgroupRotateFeatures const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceShaderFloatControls2Features {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderFloatControls2;
+
+    safe_VkPhysicalDeviceShaderFloatControls2Features(const VkPhysicalDeviceShaderFloatControls2Features* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderFloatControls2Features(const safe_VkPhysicalDeviceShaderFloatControls2Features& copy_src);
+    safe_VkPhysicalDeviceShaderFloatControls2Features& operator=(const safe_VkPhysicalDeviceShaderFloatControls2Features& copy_src);
+    safe_VkPhysicalDeviceShaderFloatControls2Features();
+    ~safe_VkPhysicalDeviceShaderFloatControls2Features();
+    void initialize(const VkPhysicalDeviceShaderFloatControls2Features* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderFloatControls2Features* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderFloatControls2Features* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderFloatControls2Features*>(this);
+    }
+    VkPhysicalDeviceShaderFloatControls2Features const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderFloatControls2Features const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceShaderExpectAssumeFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderExpectAssume;
+
+    safe_VkPhysicalDeviceShaderExpectAssumeFeatures(const VkPhysicalDeviceShaderExpectAssumeFeatures* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderExpectAssumeFeatures(const safe_VkPhysicalDeviceShaderExpectAssumeFeatures& copy_src);
+    safe_VkPhysicalDeviceShaderExpectAssumeFeatures& operator=(const safe_VkPhysicalDeviceShaderExpectAssumeFeatures& copy_src);
+    safe_VkPhysicalDeviceShaderExpectAssumeFeatures();
+    ~safe_VkPhysicalDeviceShaderExpectAssumeFeatures();
+    void initialize(const VkPhysicalDeviceShaderExpectAssumeFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderExpectAssumeFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderExpectAssumeFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceShaderExpectAssumeFeatures*>(this);
+    }
+    VkPhysicalDeviceShaderExpectAssumeFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderExpectAssumeFeatures const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceLineRasterizationFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 rectangularLines;
+    VkBool32 bresenhamLines;
+    VkBool32 smoothLines;
+    VkBool32 stippledRectangularLines;
+    VkBool32 stippledBresenhamLines;
+    VkBool32 stippledSmoothLines;
+
+    safe_VkPhysicalDeviceLineRasterizationFeatures(const VkPhysicalDeviceLineRasterizationFeatures* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceLineRasterizationFeatures(const safe_VkPhysicalDeviceLineRasterizationFeatures& copy_src);
+    safe_VkPhysicalDeviceLineRasterizationFeatures& operator=(const safe_VkPhysicalDeviceLineRasterizationFeatures& copy_src);
+    safe_VkPhysicalDeviceLineRasterizationFeatures();
+    ~safe_VkPhysicalDeviceLineRasterizationFeatures();
+    void initialize(const VkPhysicalDeviceLineRasterizationFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceLineRasterizationFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceLineRasterizationFeatures* ptr() { return reinterpret_cast<VkPhysicalDeviceLineRasterizationFeatures*>(this); }
+    VkPhysicalDeviceLineRasterizationFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceLineRasterizationFeatures const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceLineRasterizationProperties {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t lineSubPixelPrecisionBits;
+
+    safe_VkPhysicalDeviceLineRasterizationProperties(const VkPhysicalDeviceLineRasterizationProperties* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceLineRasterizationProperties(const safe_VkPhysicalDeviceLineRasterizationProperties& copy_src);
+    safe_VkPhysicalDeviceLineRasterizationProperties& operator=(const safe_VkPhysicalDeviceLineRasterizationProperties& copy_src);
+    safe_VkPhysicalDeviceLineRasterizationProperties();
+    ~safe_VkPhysicalDeviceLineRasterizationProperties();
+    void initialize(const VkPhysicalDeviceLineRasterizationProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceLineRasterizationProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceLineRasterizationProperties* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceLineRasterizationProperties*>(this);
+    }
+    VkPhysicalDeviceLineRasterizationProperties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceLineRasterizationProperties const*>(this);
+    }
+};
+struct safe_VkPipelineRasterizationLineStateCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkLineRasterizationMode lineRasterizationMode;
+    VkBool32 stippledLineEnable;
+    uint32_t lineStippleFactor;
+    uint16_t lineStipplePattern;
+
+    safe_VkPipelineRasterizationLineStateCreateInfo(const VkPipelineRasterizationLineStateCreateInfo* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineRasterizationLineStateCreateInfo(const safe_VkPipelineRasterizationLineStateCreateInfo& copy_src);
+    safe_VkPipelineRasterizationLineStateCreateInfo& operator=(const safe_VkPipelineRasterizationLineStateCreateInfo& copy_src);
+    safe_VkPipelineRasterizationLineStateCreateInfo();
+    ~safe_VkPipelineRasterizationLineStateCreateInfo();
+    void initialize(const VkPipelineRasterizationLineStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineRasterizationLineStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineRasterizationLineStateCreateInfo* ptr() {
+        return reinterpret_cast<VkPipelineRasterizationLineStateCreateInfo*>(this);
+    }
+    VkPipelineRasterizationLineStateCreateInfo const* ptr() const {
+        return reinterpret_cast<VkPipelineRasterizationLineStateCreateInfo const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceVertexAttributeDivisorProperties {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxVertexAttribDivisor;
+    VkBool32 supportsNonZeroFirstInstance;
+
+    safe_VkPhysicalDeviceVertexAttributeDivisorProperties(const VkPhysicalDeviceVertexAttributeDivisorProperties* in_struct,
+                                                          PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceVertexAttributeDivisorProperties(const safe_VkPhysicalDeviceVertexAttributeDivisorProperties& copy_src);
+    safe_VkPhysicalDeviceVertexAttributeDivisorProperties& operator=(
+        const safe_VkPhysicalDeviceVertexAttributeDivisorProperties& copy_src);
+    safe_VkPhysicalDeviceVertexAttributeDivisorProperties();
+    ~safe_VkPhysicalDeviceVertexAttributeDivisorProperties();
+    void initialize(const VkPhysicalDeviceVertexAttributeDivisorProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceVertexAttributeDivisorProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVertexAttributeDivisorProperties* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorProperties*>(this);
+    }
+    VkPhysicalDeviceVertexAttributeDivisorProperties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorProperties const*>(this);
+    }
+};
+struct safe_VkPipelineVertexInputDivisorStateCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t vertexBindingDivisorCount;
+    const VkVertexInputBindingDivisorDescription* pVertexBindingDivisors{};
+
+    safe_VkPipelineVertexInputDivisorStateCreateInfo(const VkPipelineVertexInputDivisorStateCreateInfo* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPipelineVertexInputDivisorStateCreateInfo(const safe_VkPipelineVertexInputDivisorStateCreateInfo& copy_src);
+    safe_VkPipelineVertexInputDivisorStateCreateInfo& operator=(const safe_VkPipelineVertexInputDivisorStateCreateInfo& copy_src);
+    safe_VkPipelineVertexInputDivisorStateCreateInfo();
+    ~safe_VkPipelineVertexInputDivisorStateCreateInfo();
+    void initialize(const VkPipelineVertexInputDivisorStateCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineVertexInputDivisorStateCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineVertexInputDivisorStateCreateInfo* ptr() {
+        return reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfo*>(this);
+    }
+    VkPipelineVertexInputDivisorStateCreateInfo const* ptr() const {
+        return reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfo const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceVertexAttributeDivisorFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 vertexAttributeInstanceRateDivisor;
+    VkBool32 vertexAttributeInstanceRateZeroDivisor;
+
+    safe_VkPhysicalDeviceVertexAttributeDivisorFeatures(const VkPhysicalDeviceVertexAttributeDivisorFeatures* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceVertexAttributeDivisorFeatures(const safe_VkPhysicalDeviceVertexAttributeDivisorFeatures& copy_src);
+    safe_VkPhysicalDeviceVertexAttributeDivisorFeatures& operator=(
+        const safe_VkPhysicalDeviceVertexAttributeDivisorFeatures& copy_src);
+    safe_VkPhysicalDeviceVertexAttributeDivisorFeatures();
+    ~safe_VkPhysicalDeviceVertexAttributeDivisorFeatures();
+    void initialize(const VkPhysicalDeviceVertexAttributeDivisorFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceVertexAttributeDivisorFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVertexAttributeDivisorFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeatures*>(this);
+    }
+    VkPhysicalDeviceVertexAttributeDivisorFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeatures const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceIndexTypeUint8Features {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 indexTypeUint8;
+
+    safe_VkPhysicalDeviceIndexTypeUint8Features(const VkPhysicalDeviceIndexTypeUint8Features* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceIndexTypeUint8Features(const safe_VkPhysicalDeviceIndexTypeUint8Features& copy_src);
+    safe_VkPhysicalDeviceIndexTypeUint8Features& operator=(const safe_VkPhysicalDeviceIndexTypeUint8Features& copy_src);
+    safe_VkPhysicalDeviceIndexTypeUint8Features();
+    ~safe_VkPhysicalDeviceIndexTypeUint8Features();
+    void initialize(const VkPhysicalDeviceIndexTypeUint8Features* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceIndexTypeUint8Features* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceIndexTypeUint8Features* ptr() { return reinterpret_cast<VkPhysicalDeviceIndexTypeUint8Features*>(this); }
+    VkPhysicalDeviceIndexTypeUint8Features const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceIndexTypeUint8Features const*>(this);
+    }
+};
+struct safe_VkMemoryMapInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkMemoryMapFlags flags;
+    VkDeviceMemory memory;
+    VkDeviceSize offset;
+    VkDeviceSize size;
+
+    safe_VkMemoryMapInfo(const VkMemoryMapInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkMemoryMapInfo(const safe_VkMemoryMapInfo& copy_src);
+    safe_VkMemoryMapInfo& operator=(const safe_VkMemoryMapInfo& copy_src);
+    safe_VkMemoryMapInfo();
+    ~safe_VkMemoryMapInfo();
+    void initialize(const VkMemoryMapInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMemoryMapInfo* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryMapInfo* ptr() { return reinterpret_cast<VkMemoryMapInfo*>(this); }
+    VkMemoryMapInfo const* ptr() const { return reinterpret_cast<VkMemoryMapInfo const*>(this); }
+};
+struct safe_VkMemoryUnmapInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkMemoryUnmapFlags flags;
+    VkDeviceMemory memory;
+
+    safe_VkMemoryUnmapInfo(const VkMemoryUnmapInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkMemoryUnmapInfo(const safe_VkMemoryUnmapInfo& copy_src);
+    safe_VkMemoryUnmapInfo& operator=(const safe_VkMemoryUnmapInfo& copy_src);
+    safe_VkMemoryUnmapInfo();
+    ~safe_VkMemoryUnmapInfo();
+    void initialize(const VkMemoryUnmapInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMemoryUnmapInfo* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryUnmapInfo* ptr() { return reinterpret_cast<VkMemoryUnmapInfo*>(this); }
+    VkMemoryUnmapInfo const* ptr() const { return reinterpret_cast<VkMemoryUnmapInfo const*>(this); }
+};
+struct safe_VkPhysicalDeviceMaintenance5Features {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 maintenance5;
+
+    safe_VkPhysicalDeviceMaintenance5Features(const VkPhysicalDeviceMaintenance5Features* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceMaintenance5Features(const safe_VkPhysicalDeviceMaintenance5Features& copy_src);
+    safe_VkPhysicalDeviceMaintenance5Features& operator=(const safe_VkPhysicalDeviceMaintenance5Features& copy_src);
+    safe_VkPhysicalDeviceMaintenance5Features();
+    ~safe_VkPhysicalDeviceMaintenance5Features();
+    void initialize(const VkPhysicalDeviceMaintenance5Features* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMaintenance5Features* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMaintenance5Features* ptr() { return reinterpret_cast<VkPhysicalDeviceMaintenance5Features*>(this); }
+    VkPhysicalDeviceMaintenance5Features const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMaintenance5Features const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceMaintenance5Properties {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 earlyFragmentMultisampleCoverageAfterSampleCounting;
+    VkBool32 earlyFragmentSampleMaskTestBeforeSampleCounting;
+    VkBool32 depthStencilSwizzleOneSupport;
+    VkBool32 polygonModePointSize;
+    VkBool32 nonStrictSinglePixelWideLinesUseParallelogram;
+    VkBool32 nonStrictWideLinesUseParallelogram;
+
+    safe_VkPhysicalDeviceMaintenance5Properties(const VkPhysicalDeviceMaintenance5Properties* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceMaintenance5Properties(const safe_VkPhysicalDeviceMaintenance5Properties& copy_src);
+    safe_VkPhysicalDeviceMaintenance5Properties& operator=(const safe_VkPhysicalDeviceMaintenance5Properties& copy_src);
+    safe_VkPhysicalDeviceMaintenance5Properties();
+    ~safe_VkPhysicalDeviceMaintenance5Properties();
+    void initialize(const VkPhysicalDeviceMaintenance5Properties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMaintenance5Properties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMaintenance5Properties* ptr() { return reinterpret_cast<VkPhysicalDeviceMaintenance5Properties*>(this); }
+    VkPhysicalDeviceMaintenance5Properties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMaintenance5Properties const*>(this);
+    }
+};
+struct safe_VkRenderingAreaInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t viewMask;
+    uint32_t colorAttachmentCount;
+    const VkFormat* pColorAttachmentFormats{};
+    VkFormat depthAttachmentFormat;
+    VkFormat stencilAttachmentFormat;
+
+    safe_VkRenderingAreaInfo(const VkRenderingAreaInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkRenderingAreaInfo(const safe_VkRenderingAreaInfo& copy_src);
+    safe_VkRenderingAreaInfo& operator=(const safe_VkRenderingAreaInfo& copy_src);
+    safe_VkRenderingAreaInfo();
+    ~safe_VkRenderingAreaInfo();
+    void initialize(const VkRenderingAreaInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderingAreaInfo* copy_src, PNextCopyState* copy_state = {});
+    VkRenderingAreaInfo* ptr() { return reinterpret_cast<VkRenderingAreaInfo*>(this); }
+    VkRenderingAreaInfo const* ptr() const { return reinterpret_cast<VkRenderingAreaInfo const*>(this); }
+};
+struct safe_VkImageSubresource2 {
+    VkStructureType sType;
+    void* pNext{};
+    VkImageSubresource imageSubresource;
+
+    safe_VkImageSubresource2(const VkImageSubresource2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkImageSubresource2(const safe_VkImageSubresource2& copy_src);
+    safe_VkImageSubresource2& operator=(const safe_VkImageSubresource2& copy_src);
+    safe_VkImageSubresource2();
+    ~safe_VkImageSubresource2();
+    void initialize(const VkImageSubresource2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageSubresource2* copy_src, PNextCopyState* copy_state = {});
+    VkImageSubresource2* ptr() { return reinterpret_cast<VkImageSubresource2*>(this); }
+    VkImageSubresource2 const* ptr() const { return reinterpret_cast<VkImageSubresource2 const*>(this); }
+};
+struct safe_VkDeviceImageSubresourceInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    safe_VkImageCreateInfo* pCreateInfo{};
+    safe_VkImageSubresource2* pSubresource{};
+
+    safe_VkDeviceImageSubresourceInfo(const VkDeviceImageSubresourceInfo* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    safe_VkDeviceImageSubresourceInfo(const safe_VkDeviceImageSubresourceInfo& copy_src);
+    safe_VkDeviceImageSubresourceInfo& operator=(const safe_VkDeviceImageSubresourceInfo& copy_src);
+    safe_VkDeviceImageSubresourceInfo();
+    ~safe_VkDeviceImageSubresourceInfo();
+    void initialize(const VkDeviceImageSubresourceInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDeviceImageSubresourceInfo* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceImageSubresourceInfo* ptr() { return reinterpret_cast<VkDeviceImageSubresourceInfo*>(this); }
+    VkDeviceImageSubresourceInfo const* ptr() const { return reinterpret_cast<VkDeviceImageSubresourceInfo const*>(this); }
+};
+struct safe_VkSubresourceLayout2 {
+    VkStructureType sType;
+    void* pNext{};
+    VkSubresourceLayout subresourceLayout;
+
+    safe_VkSubresourceLayout2(const VkSubresourceLayout2* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSubresourceLayout2(const safe_VkSubresourceLayout2& copy_src);
+    safe_VkSubresourceLayout2& operator=(const safe_VkSubresourceLayout2& copy_src);
+    safe_VkSubresourceLayout2();
+    ~safe_VkSubresourceLayout2();
+    void initialize(const VkSubresourceLayout2* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSubresourceLayout2* copy_src, PNextCopyState* copy_state = {});
+    VkSubresourceLayout2* ptr() { return reinterpret_cast<VkSubresourceLayout2*>(this); }
+    VkSubresourceLayout2 const* ptr() const { return reinterpret_cast<VkSubresourceLayout2 const*>(this); }
+};
+struct safe_VkPipelineCreateFlags2CreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineCreateFlags2 flags;
+
+    safe_VkPipelineCreateFlags2CreateInfo(const VkPipelineCreateFlags2CreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkPipelineCreateFlags2CreateInfo(const safe_VkPipelineCreateFlags2CreateInfo& copy_src);
+    safe_VkPipelineCreateFlags2CreateInfo& operator=(const safe_VkPipelineCreateFlags2CreateInfo& copy_src);
+    safe_VkPipelineCreateFlags2CreateInfo();
+    ~safe_VkPipelineCreateFlags2CreateInfo();
+    void initialize(const VkPipelineCreateFlags2CreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineCreateFlags2CreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineCreateFlags2CreateInfo* ptr() { return reinterpret_cast<VkPipelineCreateFlags2CreateInfo*>(this); }
+    VkPipelineCreateFlags2CreateInfo const* ptr() const { return reinterpret_cast<VkPipelineCreateFlags2CreateInfo const*>(this); }
+};
+struct safe_VkBufferUsageFlags2CreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBufferUsageFlags2 usage;
+
+    safe_VkBufferUsageFlags2CreateInfo(const VkBufferUsageFlags2CreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    safe_VkBufferUsageFlags2CreateInfo(const safe_VkBufferUsageFlags2CreateInfo& copy_src);
+    safe_VkBufferUsageFlags2CreateInfo& operator=(const safe_VkBufferUsageFlags2CreateInfo& copy_src);
+    safe_VkBufferUsageFlags2CreateInfo();
+    ~safe_VkBufferUsageFlags2CreateInfo();
+    void initialize(const VkBufferUsageFlags2CreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBufferUsageFlags2CreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkBufferUsageFlags2CreateInfo* ptr() { return reinterpret_cast<VkBufferUsageFlags2CreateInfo*>(this); }
+    VkBufferUsageFlags2CreateInfo const* ptr() const { return reinterpret_cast<VkBufferUsageFlags2CreateInfo const*>(this); }
+};
+struct safe_VkPhysicalDevicePushDescriptorProperties {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxPushDescriptors;
+
+    safe_VkPhysicalDevicePushDescriptorProperties(const VkPhysicalDevicePushDescriptorProperties* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDevicePushDescriptorProperties(const safe_VkPhysicalDevicePushDescriptorProperties& copy_src);
+    safe_VkPhysicalDevicePushDescriptorProperties& operator=(const safe_VkPhysicalDevicePushDescriptorProperties& copy_src);
+    safe_VkPhysicalDevicePushDescriptorProperties();
+    ~safe_VkPhysicalDevicePushDescriptorProperties();
+    void initialize(const VkPhysicalDevicePushDescriptorProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePushDescriptorProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePushDescriptorProperties* ptr() { return reinterpret_cast<VkPhysicalDevicePushDescriptorProperties*>(this); }
+    VkPhysicalDevicePushDescriptorProperties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePushDescriptorProperties const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 dynamicRenderingLocalRead;
+
+    safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(const VkPhysicalDeviceDynamicRenderingLocalReadFeatures* in_struct,
+                                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures& copy_src);
+    safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures& operator=(
+        const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures& copy_src);
+    safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures();
+    ~safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures();
+    void initialize(const VkPhysicalDeviceDynamicRenderingLocalReadFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDynamicRenderingLocalReadFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDynamicRenderingLocalReadFeatures*>(this);
+    }
+    VkPhysicalDeviceDynamicRenderingLocalReadFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDynamicRenderingLocalReadFeatures const*>(this);
+    }
+};
+struct safe_VkRenderingAttachmentLocationInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t colorAttachmentCount;
+    const uint32_t* pColorAttachmentLocations{};
+
+    safe_VkRenderingAttachmentLocationInfo(const VkRenderingAttachmentLocationInfo* in_struct, PNextCopyState* copy_state = {},
+                                           bool copy_pnext = true);
+    safe_VkRenderingAttachmentLocationInfo(const safe_VkRenderingAttachmentLocationInfo& copy_src);
+    safe_VkRenderingAttachmentLocationInfo& operator=(const safe_VkRenderingAttachmentLocationInfo& copy_src);
+    safe_VkRenderingAttachmentLocationInfo();
+    ~safe_VkRenderingAttachmentLocationInfo();
+    void initialize(const VkRenderingAttachmentLocationInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderingAttachmentLocationInfo* copy_src, PNextCopyState* copy_state = {});
+    VkRenderingAttachmentLocationInfo* ptr() { return reinterpret_cast<VkRenderingAttachmentLocationInfo*>(this); }
+    VkRenderingAttachmentLocationInfo const* ptr() const {
+        return reinterpret_cast<VkRenderingAttachmentLocationInfo const*>(this);
+    }
+};
+struct safe_VkRenderingInputAttachmentIndexInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t colorAttachmentCount;
+    const uint32_t* pColorAttachmentInputIndices{};
+    const uint32_t* pDepthInputAttachmentIndex{};
+    const uint32_t* pStencilInputAttachmentIndex{};
+
+    safe_VkRenderingInputAttachmentIndexInfo(const VkRenderingInputAttachmentIndexInfo* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkRenderingInputAttachmentIndexInfo(const safe_VkRenderingInputAttachmentIndexInfo& copy_src);
+    safe_VkRenderingInputAttachmentIndexInfo& operator=(const safe_VkRenderingInputAttachmentIndexInfo& copy_src);
+    safe_VkRenderingInputAttachmentIndexInfo();
+    ~safe_VkRenderingInputAttachmentIndexInfo();
+    void initialize(const VkRenderingInputAttachmentIndexInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderingInputAttachmentIndexInfo* copy_src, PNextCopyState* copy_state = {});
+    VkRenderingInputAttachmentIndexInfo* ptr() { return reinterpret_cast<VkRenderingInputAttachmentIndexInfo*>(this); }
+    VkRenderingInputAttachmentIndexInfo const* ptr() const {
+        return reinterpret_cast<VkRenderingInputAttachmentIndexInfo const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceMaintenance6Features {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 maintenance6;
+
+    safe_VkPhysicalDeviceMaintenance6Features(const VkPhysicalDeviceMaintenance6Features* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceMaintenance6Features(const safe_VkPhysicalDeviceMaintenance6Features& copy_src);
+    safe_VkPhysicalDeviceMaintenance6Features& operator=(const safe_VkPhysicalDeviceMaintenance6Features& copy_src);
+    safe_VkPhysicalDeviceMaintenance6Features();
+    ~safe_VkPhysicalDeviceMaintenance6Features();
+    void initialize(const VkPhysicalDeviceMaintenance6Features* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMaintenance6Features* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMaintenance6Features* ptr() { return reinterpret_cast<VkPhysicalDeviceMaintenance6Features*>(this); }
+    VkPhysicalDeviceMaintenance6Features const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMaintenance6Features const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceMaintenance6Properties {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 blockTexelViewCompatibleMultipleLayers;
+    uint32_t maxCombinedImageSamplerDescriptorCount;
+    VkBool32 fragmentShadingRateClampCombinerInputs;
+
+    safe_VkPhysicalDeviceMaintenance6Properties(const VkPhysicalDeviceMaintenance6Properties* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceMaintenance6Properties(const safe_VkPhysicalDeviceMaintenance6Properties& copy_src);
+    safe_VkPhysicalDeviceMaintenance6Properties& operator=(const safe_VkPhysicalDeviceMaintenance6Properties& copy_src);
+    safe_VkPhysicalDeviceMaintenance6Properties();
+    ~safe_VkPhysicalDeviceMaintenance6Properties();
+    void initialize(const VkPhysicalDeviceMaintenance6Properties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMaintenance6Properties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMaintenance6Properties* ptr() { return reinterpret_cast<VkPhysicalDeviceMaintenance6Properties*>(this); }
+    VkPhysicalDeviceMaintenance6Properties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMaintenance6Properties const*>(this);
+    }
+};
+struct safe_VkBindMemoryStatus {
+    VkStructureType sType;
+    const void* pNext{};
+    VkResult* pResult{};
+
+    safe_VkBindMemoryStatus(const VkBindMemoryStatus* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkBindMemoryStatus(const safe_VkBindMemoryStatus& copy_src);
+    safe_VkBindMemoryStatus& operator=(const safe_VkBindMemoryStatus& copy_src);
+    safe_VkBindMemoryStatus();
+    ~safe_VkBindMemoryStatus();
+    void initialize(const VkBindMemoryStatus* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBindMemoryStatus* copy_src, PNextCopyState* copy_state = {});
+    VkBindMemoryStatus* ptr() { return reinterpret_cast<VkBindMemoryStatus*>(this); }
+    VkBindMemoryStatus const* ptr() const { return reinterpret_cast<VkBindMemoryStatus const*>(this); }
+};
+struct safe_VkBindDescriptorSetsInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkShaderStageFlags stageFlags;
+    VkPipelineLayout layout;
+    uint32_t firstSet;
+    uint32_t descriptorSetCount;
+    VkDescriptorSet* pDescriptorSets{};
+    uint32_t dynamicOffsetCount;
+    const uint32_t* pDynamicOffsets{};
+
+    safe_VkBindDescriptorSetsInfo(const VkBindDescriptorSetsInfo* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    safe_VkBindDescriptorSetsInfo(const safe_VkBindDescriptorSetsInfo& copy_src);
+    safe_VkBindDescriptorSetsInfo& operator=(const safe_VkBindDescriptorSetsInfo& copy_src);
+    safe_VkBindDescriptorSetsInfo();
+    ~safe_VkBindDescriptorSetsInfo();
+    void initialize(const VkBindDescriptorSetsInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBindDescriptorSetsInfo* copy_src, PNextCopyState* copy_state = {});
+    VkBindDescriptorSetsInfo* ptr() { return reinterpret_cast<VkBindDescriptorSetsInfo*>(this); }
+    VkBindDescriptorSetsInfo const* ptr() const { return reinterpret_cast<VkBindDescriptorSetsInfo const*>(this); }
+};
+struct safe_VkPushConstantsInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineLayout layout;
+    VkShaderStageFlags stageFlags;
+    uint32_t offset;
+    uint32_t size;
+    const void* pValues{};
+
+    safe_VkPushConstantsInfo(const VkPushConstantsInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPushConstantsInfo(const safe_VkPushConstantsInfo& copy_src);
+    safe_VkPushConstantsInfo& operator=(const safe_VkPushConstantsInfo& copy_src);
+    safe_VkPushConstantsInfo();
+    ~safe_VkPushConstantsInfo();
+    void initialize(const VkPushConstantsInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPushConstantsInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPushConstantsInfo* ptr() { return reinterpret_cast<VkPushConstantsInfo*>(this); }
+    VkPushConstantsInfo const* ptr() const { return reinterpret_cast<VkPushConstantsInfo const*>(this); }
+};
+struct safe_VkPushDescriptorSetInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkShaderStageFlags stageFlags;
+    VkPipelineLayout layout;
+    uint32_t set;
+    uint32_t descriptorWriteCount;
+    safe_VkWriteDescriptorSet* pDescriptorWrites{};
+
+    safe_VkPushDescriptorSetInfo(const VkPushDescriptorSetInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPushDescriptorSetInfo(const safe_VkPushDescriptorSetInfo& copy_src);
+    safe_VkPushDescriptorSetInfo& operator=(const safe_VkPushDescriptorSetInfo& copy_src);
+    safe_VkPushDescriptorSetInfo();
+    ~safe_VkPushDescriptorSetInfo();
+    void initialize(const VkPushDescriptorSetInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPushDescriptorSetInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPushDescriptorSetInfo* ptr() { return reinterpret_cast<VkPushDescriptorSetInfo*>(this); }
+    VkPushDescriptorSetInfo const* ptr() const { return reinterpret_cast<VkPushDescriptorSetInfo const*>(this); }
+};
+struct safe_VkPushDescriptorSetWithTemplateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDescriptorUpdateTemplate descriptorUpdateTemplate;
+    VkPipelineLayout layout;
+    uint32_t set;
+    const void* pData{};
+
+    safe_VkPushDescriptorSetWithTemplateInfo(const VkPushDescriptorSetWithTemplateInfo* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkPushDescriptorSetWithTemplateInfo(const safe_VkPushDescriptorSetWithTemplateInfo& copy_src);
+    safe_VkPushDescriptorSetWithTemplateInfo& operator=(const safe_VkPushDescriptorSetWithTemplateInfo& copy_src);
+    safe_VkPushDescriptorSetWithTemplateInfo();
+    ~safe_VkPushDescriptorSetWithTemplateInfo();
+    void initialize(const VkPushDescriptorSetWithTemplateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPushDescriptorSetWithTemplateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPushDescriptorSetWithTemplateInfo* ptr() { return reinterpret_cast<VkPushDescriptorSetWithTemplateInfo*>(this); }
+    VkPushDescriptorSetWithTemplateInfo const* ptr() const {
+        return reinterpret_cast<VkPushDescriptorSetWithTemplateInfo const*>(this);
+    }
+};
+struct safe_VkPhysicalDevicePipelineProtectedAccessFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 pipelineProtectedAccess;
+
+    safe_VkPhysicalDevicePipelineProtectedAccessFeatures(const VkPhysicalDevicePipelineProtectedAccessFeatures* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDevicePipelineProtectedAccessFeatures(const safe_VkPhysicalDevicePipelineProtectedAccessFeatures& copy_src);
+    safe_VkPhysicalDevicePipelineProtectedAccessFeatures& operator=(
+        const safe_VkPhysicalDevicePipelineProtectedAccessFeatures& copy_src);
+    safe_VkPhysicalDevicePipelineProtectedAccessFeatures();
+    ~safe_VkPhysicalDevicePipelineProtectedAccessFeatures();
+    void initialize(const VkPhysicalDevicePipelineProtectedAccessFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePipelineProtectedAccessFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePipelineProtectedAccessFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePipelineProtectedAccessFeatures*>(this);
+    }
+    VkPhysicalDevicePipelineProtectedAccessFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePipelineProtectedAccessFeatures const*>(this);
+    }
+};
+struct safe_VkPhysicalDevicePipelineRobustnessFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 pipelineRobustness;
+
+    safe_VkPhysicalDevicePipelineRobustnessFeatures(const VkPhysicalDevicePipelineRobustnessFeatures* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDevicePipelineRobustnessFeatures(const safe_VkPhysicalDevicePipelineRobustnessFeatures& copy_src);
+    safe_VkPhysicalDevicePipelineRobustnessFeatures& operator=(const safe_VkPhysicalDevicePipelineRobustnessFeatures& copy_src);
+    safe_VkPhysicalDevicePipelineRobustnessFeatures();
+    ~safe_VkPhysicalDevicePipelineRobustnessFeatures();
+    void initialize(const VkPhysicalDevicePipelineRobustnessFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePipelineRobustnessFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePipelineRobustnessFeatures* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePipelineRobustnessFeatures*>(this);
+    }
+    VkPhysicalDevicePipelineRobustnessFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePipelineRobustnessFeatures const*>(this);
+    }
+};
+struct safe_VkPhysicalDevicePipelineRobustnessProperties {
+    VkStructureType sType;
+    void* pNext{};
+    VkPipelineRobustnessBufferBehavior defaultRobustnessStorageBuffers;
+    VkPipelineRobustnessBufferBehavior defaultRobustnessUniformBuffers;
+    VkPipelineRobustnessBufferBehavior defaultRobustnessVertexInputs;
+    VkPipelineRobustnessImageBehavior defaultRobustnessImages;
+
+    safe_VkPhysicalDevicePipelineRobustnessProperties(const VkPhysicalDevicePipelineRobustnessProperties* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDevicePipelineRobustnessProperties(const safe_VkPhysicalDevicePipelineRobustnessProperties& copy_src);
+    safe_VkPhysicalDevicePipelineRobustnessProperties& operator=(const safe_VkPhysicalDevicePipelineRobustnessProperties& copy_src);
+    safe_VkPhysicalDevicePipelineRobustnessProperties();
+    ~safe_VkPhysicalDevicePipelineRobustnessProperties();
+    void initialize(const VkPhysicalDevicePipelineRobustnessProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePipelineRobustnessProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePipelineRobustnessProperties* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePipelineRobustnessProperties*>(this);
+    }
+    VkPhysicalDevicePipelineRobustnessProperties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePipelineRobustnessProperties const*>(this);
+    }
+};
+struct safe_VkPipelineRobustnessCreateInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineRobustnessBufferBehavior storageBuffers;
+    VkPipelineRobustnessBufferBehavior uniformBuffers;
+    VkPipelineRobustnessBufferBehavior vertexInputs;
+    VkPipelineRobustnessImageBehavior images;
+
+    safe_VkPipelineRobustnessCreateInfo(const VkPipelineRobustnessCreateInfo* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkPipelineRobustnessCreateInfo(const safe_VkPipelineRobustnessCreateInfo& copy_src);
+    safe_VkPipelineRobustnessCreateInfo& operator=(const safe_VkPipelineRobustnessCreateInfo& copy_src);
+    safe_VkPipelineRobustnessCreateInfo();
+    ~safe_VkPipelineRobustnessCreateInfo();
+    void initialize(const VkPipelineRobustnessCreateInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPipelineRobustnessCreateInfo* copy_src, PNextCopyState* copy_state = {});
+    VkPipelineRobustnessCreateInfo* ptr() { return reinterpret_cast<VkPipelineRobustnessCreateInfo*>(this); }
+    VkPipelineRobustnessCreateInfo const* ptr() const { return reinterpret_cast<VkPipelineRobustnessCreateInfo const*>(this); }
+};
+struct safe_VkPhysicalDeviceHostImageCopyFeatures {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 hostImageCopy;
+
+    safe_VkPhysicalDeviceHostImageCopyFeatures(const VkPhysicalDeviceHostImageCopyFeatures* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceHostImageCopyFeatures(const safe_VkPhysicalDeviceHostImageCopyFeatures& copy_src);
+    safe_VkPhysicalDeviceHostImageCopyFeatures& operator=(const safe_VkPhysicalDeviceHostImageCopyFeatures& copy_src);
+    safe_VkPhysicalDeviceHostImageCopyFeatures();
+    ~safe_VkPhysicalDeviceHostImageCopyFeatures();
+    void initialize(const VkPhysicalDeviceHostImageCopyFeatures* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceHostImageCopyFeatures* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceHostImageCopyFeatures* ptr() { return reinterpret_cast<VkPhysicalDeviceHostImageCopyFeatures*>(this); }
+    VkPhysicalDeviceHostImageCopyFeatures const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceHostImageCopyFeatures const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceHostImageCopyProperties {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t copySrcLayoutCount;
+    VkImageLayout* pCopySrcLayouts{};
+    uint32_t copyDstLayoutCount;
+    VkImageLayout* pCopyDstLayouts{};
+    uint8_t optimalTilingLayoutUUID[VK_UUID_SIZE];
+    VkBool32 identicalMemoryTypeRequirements;
+
+    safe_VkPhysicalDeviceHostImageCopyProperties(const VkPhysicalDeviceHostImageCopyProperties* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceHostImageCopyProperties(const safe_VkPhysicalDeviceHostImageCopyProperties& copy_src);
+    safe_VkPhysicalDeviceHostImageCopyProperties& operator=(const safe_VkPhysicalDeviceHostImageCopyProperties& copy_src);
+    safe_VkPhysicalDeviceHostImageCopyProperties();
+    ~safe_VkPhysicalDeviceHostImageCopyProperties();
+    void initialize(const VkPhysicalDeviceHostImageCopyProperties* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceHostImageCopyProperties* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceHostImageCopyProperties* ptr() { return reinterpret_cast<VkPhysicalDeviceHostImageCopyProperties*>(this); }
+    VkPhysicalDeviceHostImageCopyProperties const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceHostImageCopyProperties const*>(this);
+    }
+};
+struct safe_VkMemoryToImageCopy {
+    VkStructureType sType;
+    const void* pNext{};
+    const void* pHostPointer{};
+    uint32_t memoryRowLength;
+    uint32_t memoryImageHeight;
+    VkImageSubresourceLayers imageSubresource;
+    VkOffset3D imageOffset;
+    VkExtent3D imageExtent;
+
+    safe_VkMemoryToImageCopy(const VkMemoryToImageCopy* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkMemoryToImageCopy(const safe_VkMemoryToImageCopy& copy_src);
+    safe_VkMemoryToImageCopy& operator=(const safe_VkMemoryToImageCopy& copy_src);
+    safe_VkMemoryToImageCopy();
+    ~safe_VkMemoryToImageCopy();
+    void initialize(const VkMemoryToImageCopy* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMemoryToImageCopy* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryToImageCopy* ptr() { return reinterpret_cast<VkMemoryToImageCopy*>(this); }
+    VkMemoryToImageCopy const* ptr() const { return reinterpret_cast<VkMemoryToImageCopy const*>(this); }
+};
+struct safe_VkImageToMemoryCopy {
+    VkStructureType sType;
+    const void* pNext{};
+    void* pHostPointer{};
+    uint32_t memoryRowLength;
+    uint32_t memoryImageHeight;
+    VkImageSubresourceLayers imageSubresource;
+    VkOffset3D imageOffset;
+    VkExtent3D imageExtent;
+
+    safe_VkImageToMemoryCopy(const VkImageToMemoryCopy* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkImageToMemoryCopy(const safe_VkImageToMemoryCopy& copy_src);
+    safe_VkImageToMemoryCopy& operator=(const safe_VkImageToMemoryCopy& copy_src);
+    safe_VkImageToMemoryCopy();
+    ~safe_VkImageToMemoryCopy();
+    void initialize(const VkImageToMemoryCopy* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImageToMemoryCopy* copy_src, PNextCopyState* copy_state = {});
+    VkImageToMemoryCopy* ptr() { return reinterpret_cast<VkImageToMemoryCopy*>(this); }
+    VkImageToMemoryCopy const* ptr() const { return reinterpret_cast<VkImageToMemoryCopy const*>(this); }
+};
+struct safe_VkCopyMemoryToImageInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkHostImageCopyFlags flags;
+    VkImage dstImage;
+    VkImageLayout dstImageLayout;
+    uint32_t regionCount;
+    safe_VkMemoryToImageCopy* pRegions{};
+
+    safe_VkCopyMemoryToImageInfo(const VkCopyMemoryToImageInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkCopyMemoryToImageInfo(const safe_VkCopyMemoryToImageInfo& copy_src);
+    safe_VkCopyMemoryToImageInfo& operator=(const safe_VkCopyMemoryToImageInfo& copy_src);
+    safe_VkCopyMemoryToImageInfo();
+    ~safe_VkCopyMemoryToImageInfo();
+    void initialize(const VkCopyMemoryToImageInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCopyMemoryToImageInfo* copy_src, PNextCopyState* copy_state = {});
+    VkCopyMemoryToImageInfo* ptr() { return reinterpret_cast<VkCopyMemoryToImageInfo*>(this); }
+    VkCopyMemoryToImageInfo const* ptr() const { return reinterpret_cast<VkCopyMemoryToImageInfo const*>(this); }
+};
+struct safe_VkCopyImageToMemoryInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkHostImageCopyFlags flags;
+    VkImage srcImage;
+    VkImageLayout srcImageLayout;
+    uint32_t regionCount;
+    safe_VkImageToMemoryCopy* pRegions{};
+
+    safe_VkCopyImageToMemoryInfo(const VkCopyImageToMemoryInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkCopyImageToMemoryInfo(const safe_VkCopyImageToMemoryInfo& copy_src);
+    safe_VkCopyImageToMemoryInfo& operator=(const safe_VkCopyImageToMemoryInfo& copy_src);
+    safe_VkCopyImageToMemoryInfo();
+    ~safe_VkCopyImageToMemoryInfo();
+    void initialize(const VkCopyImageToMemoryInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCopyImageToMemoryInfo* copy_src, PNextCopyState* copy_state = {});
+    VkCopyImageToMemoryInfo* ptr() { return reinterpret_cast<VkCopyImageToMemoryInfo*>(this); }
+    VkCopyImageToMemoryInfo const* ptr() const { return reinterpret_cast<VkCopyImageToMemoryInfo const*>(this); }
+};
+struct safe_VkCopyImageToImageInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkHostImageCopyFlags flags;
+    VkImage srcImage;
+    VkImageLayout srcImageLayout;
+    VkImage dstImage;
+    VkImageLayout dstImageLayout;
+    uint32_t regionCount;
+    safe_VkImageCopy2* pRegions{};
+
+    safe_VkCopyImageToImageInfo(const VkCopyImageToImageInfo* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkCopyImageToImageInfo(const safe_VkCopyImageToImageInfo& copy_src);
+    safe_VkCopyImageToImageInfo& operator=(const safe_VkCopyImageToImageInfo& copy_src);
+    safe_VkCopyImageToImageInfo();
+    ~safe_VkCopyImageToImageInfo();
+    void initialize(const VkCopyImageToImageInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCopyImageToImageInfo* copy_src, PNextCopyState* copy_state = {});
+    VkCopyImageToImageInfo* ptr() { return reinterpret_cast<VkCopyImageToImageInfo*>(this); }
+    VkCopyImageToImageInfo const* ptr() const { return reinterpret_cast<VkCopyImageToImageInfo const*>(this); }
+};
+struct safe_VkHostImageLayoutTransitionInfo {
+    VkStructureType sType;
+    const void* pNext{};
+    VkImage image;
+    VkImageLayout oldLayout;
+    VkImageLayout newLayout;
+    VkImageSubresourceRange subresourceRange;
+
+    safe_VkHostImageLayoutTransitionInfo(const VkHostImageLayoutTransitionInfo* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkHostImageLayoutTransitionInfo(const safe_VkHostImageLayoutTransitionInfo& copy_src);
+    safe_VkHostImageLayoutTransitionInfo& operator=(const safe_VkHostImageLayoutTransitionInfo& copy_src);
+    safe_VkHostImageLayoutTransitionInfo();
+    ~safe_VkHostImageLayoutTransitionInfo();
+    void initialize(const VkHostImageLayoutTransitionInfo* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkHostImageLayoutTransitionInfo* copy_src, PNextCopyState* copy_state = {});
+    VkHostImageLayoutTransitionInfo* ptr() { return reinterpret_cast<VkHostImageLayoutTransitionInfo*>(this); }
+    VkHostImageLayoutTransitionInfo const* ptr() const { return reinterpret_cast<VkHostImageLayoutTransitionInfo const*>(this); }
+};
+struct safe_VkSubresourceHostMemcpySize {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceSize size;
+
+    safe_VkSubresourceHostMemcpySize(const VkSubresourceHostMemcpySize* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    safe_VkSubresourceHostMemcpySize(const safe_VkSubresourceHostMemcpySize& copy_src);
+    safe_VkSubresourceHostMemcpySize& operator=(const safe_VkSubresourceHostMemcpySize& copy_src);
+    safe_VkSubresourceHostMemcpySize();
+    ~safe_VkSubresourceHostMemcpySize();
+    void initialize(const VkSubresourceHostMemcpySize* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSubresourceHostMemcpySize* copy_src, PNextCopyState* copy_state = {});
+    VkSubresourceHostMemcpySize* ptr() { return reinterpret_cast<VkSubresourceHostMemcpySize*>(this); }
+    VkSubresourceHostMemcpySize const* ptr() const { return reinterpret_cast<VkSubresourceHostMemcpySize const*>(this); }
+};
+struct safe_VkHostImageCopyDevicePerformanceQuery {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 optimalDeviceAccess;
+    VkBool32 identicalMemoryLayout;
+
+    safe_VkHostImageCopyDevicePerformanceQuery(const VkHostImageCopyDevicePerformanceQuery* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkHostImageCopyDevicePerformanceQuery(const safe_VkHostImageCopyDevicePerformanceQuery& copy_src);
+    safe_VkHostImageCopyDevicePerformanceQuery& operator=(const safe_VkHostImageCopyDevicePerformanceQuery& copy_src);
+    safe_VkHostImageCopyDevicePerformanceQuery();
+    ~safe_VkHostImageCopyDevicePerformanceQuery();
+    void initialize(const VkHostImageCopyDevicePerformanceQuery* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkHostImageCopyDevicePerformanceQuery* copy_src, PNextCopyState* copy_state = {});
+    VkHostImageCopyDevicePerformanceQuery* ptr() { return reinterpret_cast<VkHostImageCopyDevicePerformanceQuery*>(this); }
+    VkHostImageCopyDevicePerformanceQuery const* ptr() const {
+        return reinterpret_cast<VkHostImageCopyDevicePerformanceQuery const*>(this);
+    }
+};
 struct safe_VkSwapchainCreateInfoKHR {
     VkStructureType sType;
     const void* pNext{};
@@ -6139,26 +7147,6 @@ struct safe_VkSemaphoreGetFdInfoKHR {
     VkSemaphoreGetFdInfoKHR* ptr() { return reinterpret_cast<VkSemaphoreGetFdInfoKHR*>(this); }
     VkSemaphoreGetFdInfoKHR const* ptr() const { return reinterpret_cast<VkSemaphoreGetFdInfoKHR const*>(this); }
 };
-struct safe_VkPhysicalDevicePushDescriptorPropertiesKHR {
-    VkStructureType sType;
-    void* pNext{};
-    uint32_t maxPushDescriptors;
-
-    safe_VkPhysicalDevicePushDescriptorPropertiesKHR(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct,
-                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPhysicalDevicePushDescriptorPropertiesKHR(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& copy_src);
-    safe_VkPhysicalDevicePushDescriptorPropertiesKHR& operator=(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& copy_src);
-    safe_VkPhysicalDevicePushDescriptorPropertiesKHR();
-    ~safe_VkPhysicalDevicePushDescriptorPropertiesKHR();
-    void initialize(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
-    VkPhysicalDevicePushDescriptorPropertiesKHR* ptr() {
-        return reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(this);
-    }
-    VkPhysicalDevicePushDescriptorPropertiesKHR const* ptr() const {
-        return reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR const*>(this);
-    }
-};
 struct safe_VkPresentRegionKHR {
     uint32_t rectangleCount;
     const VkRectLayerKHR* pRectangles{};
@@ -6749,64 +7737,6 @@ struct safe_VkVideoDecodeH265DpbSlotInfoKHR {
     VkVideoDecodeH265DpbSlotInfoKHR* ptr() { return reinterpret_cast<VkVideoDecodeH265DpbSlotInfoKHR*>(this); }
     VkVideoDecodeH265DpbSlotInfoKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeH265DpbSlotInfoKHR const*>(this); }
 };
-struct safe_VkDeviceQueueGlobalPriorityCreateInfoKHR {
-    VkStructureType sType;
-    const void* pNext{};
-    VkQueueGlobalPriorityKHR globalPriority;
-
-    safe_VkDeviceQueueGlobalPriorityCreateInfoKHR(const VkDeviceQueueGlobalPriorityCreateInfoKHR* in_struct,
-                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkDeviceQueueGlobalPriorityCreateInfoKHR(const safe_VkDeviceQueueGlobalPriorityCreateInfoKHR& copy_src);
-    safe_VkDeviceQueueGlobalPriorityCreateInfoKHR& operator=(const safe_VkDeviceQueueGlobalPriorityCreateInfoKHR& copy_src);
-    safe_VkDeviceQueueGlobalPriorityCreateInfoKHR();
-    ~safe_VkDeviceQueueGlobalPriorityCreateInfoKHR();
-    void initialize(const VkDeviceQueueGlobalPriorityCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkDeviceQueueGlobalPriorityCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
-    VkDeviceQueueGlobalPriorityCreateInfoKHR* ptr() { return reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoKHR*>(this); }
-    VkDeviceQueueGlobalPriorityCreateInfoKHR const* ptr() const {
-        return reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoKHR const*>(this);
-    }
-};
-struct safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR {
-    VkStructureType sType;
-    void* pNext{};
-    VkBool32 globalPriorityQuery;
-
-    safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* in_struct,
-                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(const safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& copy_src);
-    safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& operator=(
-        const safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& copy_src);
-    safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR();
-    ~safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR();
-    void initialize(const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
-    VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* ptr() {
-        return reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR*>(this);
-    }
-    VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR const* ptr() const {
-        return reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR const*>(this);
-    }
-};
-struct safe_VkQueueFamilyGlobalPriorityPropertiesKHR {
-    VkStructureType sType;
-    void* pNext{};
-    uint32_t priorityCount;
-    VkQueueGlobalPriorityKHR priorities[VK_MAX_GLOBAL_PRIORITY_SIZE_KHR];
-
-    safe_VkQueueFamilyGlobalPriorityPropertiesKHR(const VkQueueFamilyGlobalPriorityPropertiesKHR* in_struct,
-                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkQueueFamilyGlobalPriorityPropertiesKHR(const safe_VkQueueFamilyGlobalPriorityPropertiesKHR& copy_src);
-    safe_VkQueueFamilyGlobalPriorityPropertiesKHR& operator=(const safe_VkQueueFamilyGlobalPriorityPropertiesKHR& copy_src);
-    safe_VkQueueFamilyGlobalPriorityPropertiesKHR();
-    ~safe_VkQueueFamilyGlobalPriorityPropertiesKHR();
-    void initialize(const VkQueueFamilyGlobalPriorityPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkQueueFamilyGlobalPriorityPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
-    VkQueueFamilyGlobalPriorityPropertiesKHR* ptr() { return reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesKHR*>(this); }
-    VkQueueFamilyGlobalPriorityPropertiesKHR const* ptr() const {
-        return reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesKHR const*>(this);
-    }
-};
 struct safe_VkFragmentShadingRateAttachmentInfoKHR {
     VkStructureType sType;
     const void* pNext{};
@@ -6950,68 +7880,6 @@ struct safe_VkRenderingFragmentShadingRateAttachmentInfoKHR {
         return reinterpret_cast<VkRenderingFragmentShadingRateAttachmentInfoKHR const*>(this);
     }
 };
-struct safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR {
-    VkStructureType sType;
-    void* pNext{};
-    VkBool32 dynamicRenderingLocalRead;
-
-    safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR(const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* in_struct,
-                                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR(
-        const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& copy_src);
-    safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& operator=(
-        const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& copy_src);
-    safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR();
-    ~safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR();
-    void initialize(const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
-    VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* ptr() {
-        return reinterpret_cast<VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR*>(this);
-    }
-    VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR const* ptr() const {
-        return reinterpret_cast<VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR const*>(this);
-    }
-};
-struct safe_VkRenderingAttachmentLocationInfoKHR {
-    VkStructureType sType;
-    const void* pNext{};
-    uint32_t colorAttachmentCount;
-    const uint32_t* pColorAttachmentLocations{};
-
-    safe_VkRenderingAttachmentLocationInfoKHR(const VkRenderingAttachmentLocationInfoKHR* in_struct,
-                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkRenderingAttachmentLocationInfoKHR(const safe_VkRenderingAttachmentLocationInfoKHR& copy_src);
-    safe_VkRenderingAttachmentLocationInfoKHR& operator=(const safe_VkRenderingAttachmentLocationInfoKHR& copy_src);
-    safe_VkRenderingAttachmentLocationInfoKHR();
-    ~safe_VkRenderingAttachmentLocationInfoKHR();
-    void initialize(const VkRenderingAttachmentLocationInfoKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkRenderingAttachmentLocationInfoKHR* copy_src, PNextCopyState* copy_state = {});
-    VkRenderingAttachmentLocationInfoKHR* ptr() { return reinterpret_cast<VkRenderingAttachmentLocationInfoKHR*>(this); }
-    VkRenderingAttachmentLocationInfoKHR const* ptr() const {
-        return reinterpret_cast<VkRenderingAttachmentLocationInfoKHR const*>(this);
-    }
-};
-struct safe_VkRenderingInputAttachmentIndexInfoKHR {
-    VkStructureType sType;
-    const void* pNext{};
-    uint32_t colorAttachmentCount;
-    const uint32_t* pColorAttachmentInputIndices{};
-    const uint32_t* pDepthInputAttachmentIndex{};
-    const uint32_t* pStencilInputAttachmentIndex{};
-
-    safe_VkRenderingInputAttachmentIndexInfoKHR(const VkRenderingInputAttachmentIndexInfoKHR* in_struct,
-                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkRenderingInputAttachmentIndexInfoKHR(const safe_VkRenderingInputAttachmentIndexInfoKHR& copy_src);
-    safe_VkRenderingInputAttachmentIndexInfoKHR& operator=(const safe_VkRenderingInputAttachmentIndexInfoKHR& copy_src);
-    safe_VkRenderingInputAttachmentIndexInfoKHR();
-    ~safe_VkRenderingInputAttachmentIndexInfoKHR();
-    void initialize(const VkRenderingInputAttachmentIndexInfoKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkRenderingInputAttachmentIndexInfoKHR* copy_src, PNextCopyState* copy_state = {});
-    VkRenderingInputAttachmentIndexInfoKHR* ptr() { return reinterpret_cast<VkRenderingInputAttachmentIndexInfoKHR*>(this); }
-    VkRenderingInputAttachmentIndexInfoKHR const* ptr() const {
-        return reinterpret_cast<VkRenderingInputAttachmentIndexInfoKHR const*>(this);
-    }
-};
 struct safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR {
     VkStructureType sType;
     void* pNext{};
@@ -7188,40 +8056,6 @@ struct safe_VkPipelineExecutableInternalRepresentationKHR {
         return reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR const*>(this);
     }
 };
-struct safe_VkMemoryMapInfoKHR {
-    VkStructureType sType;
-    const void* pNext{};
-    VkMemoryMapFlags flags;
-    VkDeviceMemory memory;
-    VkDeviceSize offset;
-    VkDeviceSize size;
-
-    safe_VkMemoryMapInfoKHR(const VkMemoryMapInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkMemoryMapInfoKHR(const safe_VkMemoryMapInfoKHR& copy_src);
-    safe_VkMemoryMapInfoKHR& operator=(const safe_VkMemoryMapInfoKHR& copy_src);
-    safe_VkMemoryMapInfoKHR();
-    ~safe_VkMemoryMapInfoKHR();
-    void initialize(const VkMemoryMapInfoKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkMemoryMapInfoKHR* copy_src, PNextCopyState* copy_state = {});
-    VkMemoryMapInfoKHR* ptr() { return reinterpret_cast<VkMemoryMapInfoKHR*>(this); }
-    VkMemoryMapInfoKHR const* ptr() const { return reinterpret_cast<VkMemoryMapInfoKHR const*>(this); }
-};
-struct safe_VkMemoryUnmapInfoKHR {
-    VkStructureType sType;
-    const void* pNext{};
-    VkMemoryUnmapFlagsKHR flags;
-    VkDeviceMemory memory;
-
-    safe_VkMemoryUnmapInfoKHR(const VkMemoryUnmapInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkMemoryUnmapInfoKHR(const safe_VkMemoryUnmapInfoKHR& copy_src);
-    safe_VkMemoryUnmapInfoKHR& operator=(const safe_VkMemoryUnmapInfoKHR& copy_src);
-    safe_VkMemoryUnmapInfoKHR();
-    ~safe_VkMemoryUnmapInfoKHR();
-    void initialize(const VkMemoryUnmapInfoKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkMemoryUnmapInfoKHR* copy_src, PNextCopyState* copy_state = {});
-    VkMemoryUnmapInfoKHR* ptr() { return reinterpret_cast<VkMemoryUnmapInfoKHR*>(this); }
-    VkMemoryUnmapInfoKHR const* ptr() const { return reinterpret_cast<VkMemoryUnmapInfoKHR const*>(this); }
-};
 struct safe_VkPipelineLibraryCreateInfoKHR {
     VkStructureType sType;
     const void* pNext{};
@@ -7611,28 +8445,6 @@ struct safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR {
         return reinterpret_cast<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR const*>(this);
     }
 };
-struct safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR {
-    VkStructureType sType;
-    void* pNext{};
-    VkBool32 shaderSubgroupRotate;
-    VkBool32 shaderSubgroupRotateClustered;
-
-    safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR(const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* in_struct,
-                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR(const safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR& copy_src);
-    safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR& operator=(
-        const safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR& copy_src);
-    safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR();
-    ~safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR();
-    void initialize(const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
-    VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* ptr() {
-        return reinterpret_cast<VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR*>(this);
-    }
-    VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR const* ptr() const {
-        return reinterpret_cast<VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR const*>(this);
-    }
-};
 struct safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR {
     VkStructureType sType;
     void* pNext{};
@@ -7656,147 +8468,6 @@ struct safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR {
         return reinterpret_cast<VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const*>(this);
     }
 };
-struct safe_VkPhysicalDeviceMaintenance5FeaturesKHR {
-    VkStructureType sType;
-    void* pNext{};
-    VkBool32 maintenance5;
-
-    safe_VkPhysicalDeviceMaintenance5FeaturesKHR(const VkPhysicalDeviceMaintenance5FeaturesKHR* in_struct,
-                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPhysicalDeviceMaintenance5FeaturesKHR(const safe_VkPhysicalDeviceMaintenance5FeaturesKHR& copy_src);
-    safe_VkPhysicalDeviceMaintenance5FeaturesKHR& operator=(const safe_VkPhysicalDeviceMaintenance5FeaturesKHR& copy_src);
-    safe_VkPhysicalDeviceMaintenance5FeaturesKHR();
-    ~safe_VkPhysicalDeviceMaintenance5FeaturesKHR();
-    void initialize(const VkPhysicalDeviceMaintenance5FeaturesKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPhysicalDeviceMaintenance5FeaturesKHR* copy_src, PNextCopyState* copy_state = {});
-    VkPhysicalDeviceMaintenance5FeaturesKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceMaintenance5FeaturesKHR*>(this); }
-    VkPhysicalDeviceMaintenance5FeaturesKHR const* ptr() const {
-        return reinterpret_cast<VkPhysicalDeviceMaintenance5FeaturesKHR const*>(this);
-    }
-};
-struct safe_VkPhysicalDeviceMaintenance5PropertiesKHR {
-    VkStructureType sType;
-    void* pNext{};
-    VkBool32 earlyFragmentMultisampleCoverageAfterSampleCounting;
-    VkBool32 earlyFragmentSampleMaskTestBeforeSampleCounting;
-    VkBool32 depthStencilSwizzleOneSupport;
-    VkBool32 polygonModePointSize;
-    VkBool32 nonStrictSinglePixelWideLinesUseParallelogram;
-    VkBool32 nonStrictWideLinesUseParallelogram;
-
-    safe_VkPhysicalDeviceMaintenance5PropertiesKHR(const VkPhysicalDeviceMaintenance5PropertiesKHR* in_struct,
-                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPhysicalDeviceMaintenance5PropertiesKHR(const safe_VkPhysicalDeviceMaintenance5PropertiesKHR& copy_src);
-    safe_VkPhysicalDeviceMaintenance5PropertiesKHR& operator=(const safe_VkPhysicalDeviceMaintenance5PropertiesKHR& copy_src);
-    safe_VkPhysicalDeviceMaintenance5PropertiesKHR();
-    ~safe_VkPhysicalDeviceMaintenance5PropertiesKHR();
-    void initialize(const VkPhysicalDeviceMaintenance5PropertiesKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPhysicalDeviceMaintenance5PropertiesKHR* copy_src, PNextCopyState* copy_state = {});
-    VkPhysicalDeviceMaintenance5PropertiesKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceMaintenance5PropertiesKHR*>(this); }
-    VkPhysicalDeviceMaintenance5PropertiesKHR const* ptr() const {
-        return reinterpret_cast<VkPhysicalDeviceMaintenance5PropertiesKHR const*>(this);
-    }
-};
-struct safe_VkRenderingAreaInfoKHR {
-    VkStructureType sType;
-    const void* pNext{};
-    uint32_t viewMask;
-    uint32_t colorAttachmentCount;
-    const VkFormat* pColorAttachmentFormats{};
-    VkFormat depthAttachmentFormat;
-    VkFormat stencilAttachmentFormat;
-
-    safe_VkRenderingAreaInfoKHR(const VkRenderingAreaInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkRenderingAreaInfoKHR(const safe_VkRenderingAreaInfoKHR& copy_src);
-    safe_VkRenderingAreaInfoKHR& operator=(const safe_VkRenderingAreaInfoKHR& copy_src);
-    safe_VkRenderingAreaInfoKHR();
-    ~safe_VkRenderingAreaInfoKHR();
-    void initialize(const VkRenderingAreaInfoKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkRenderingAreaInfoKHR* copy_src, PNextCopyState* copy_state = {});
-    VkRenderingAreaInfoKHR* ptr() { return reinterpret_cast<VkRenderingAreaInfoKHR*>(this); }
-    VkRenderingAreaInfoKHR const* ptr() const { return reinterpret_cast<VkRenderingAreaInfoKHR const*>(this); }
-};
-struct safe_VkImageSubresource2KHR {
-    VkStructureType sType;
-    void* pNext{};
-    VkImageSubresource imageSubresource;
-
-    safe_VkImageSubresource2KHR(const VkImageSubresource2KHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkImageSubresource2KHR(const safe_VkImageSubresource2KHR& copy_src);
-    safe_VkImageSubresource2KHR& operator=(const safe_VkImageSubresource2KHR& copy_src);
-    safe_VkImageSubresource2KHR();
-    ~safe_VkImageSubresource2KHR();
-    void initialize(const VkImageSubresource2KHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkImageSubresource2KHR* copy_src, PNextCopyState* copy_state = {});
-    VkImageSubresource2KHR* ptr() { return reinterpret_cast<VkImageSubresource2KHR*>(this); }
-    VkImageSubresource2KHR const* ptr() const { return reinterpret_cast<VkImageSubresource2KHR const*>(this); }
-};
-struct safe_VkDeviceImageSubresourceInfoKHR {
-    VkStructureType sType;
-    const void* pNext{};
-    safe_VkImageCreateInfo* pCreateInfo{};
-    safe_VkImageSubresource2KHR* pSubresource{};
-
-    safe_VkDeviceImageSubresourceInfoKHR(const VkDeviceImageSubresourceInfoKHR* in_struct, PNextCopyState* copy_state = {},
-                                         bool copy_pnext = true);
-    safe_VkDeviceImageSubresourceInfoKHR(const safe_VkDeviceImageSubresourceInfoKHR& copy_src);
-    safe_VkDeviceImageSubresourceInfoKHR& operator=(const safe_VkDeviceImageSubresourceInfoKHR& copy_src);
-    safe_VkDeviceImageSubresourceInfoKHR();
-    ~safe_VkDeviceImageSubresourceInfoKHR();
-    void initialize(const VkDeviceImageSubresourceInfoKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkDeviceImageSubresourceInfoKHR* copy_src, PNextCopyState* copy_state = {});
-    VkDeviceImageSubresourceInfoKHR* ptr() { return reinterpret_cast<VkDeviceImageSubresourceInfoKHR*>(this); }
-    VkDeviceImageSubresourceInfoKHR const* ptr() const { return reinterpret_cast<VkDeviceImageSubresourceInfoKHR const*>(this); }
-};
-struct safe_VkSubresourceLayout2KHR {
-    VkStructureType sType;
-    void* pNext{};
-    VkSubresourceLayout subresourceLayout;
-
-    safe_VkSubresourceLayout2KHR(const VkSubresourceLayout2KHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkSubresourceLayout2KHR(const safe_VkSubresourceLayout2KHR& copy_src);
-    safe_VkSubresourceLayout2KHR& operator=(const safe_VkSubresourceLayout2KHR& copy_src);
-    safe_VkSubresourceLayout2KHR();
-    ~safe_VkSubresourceLayout2KHR();
-    void initialize(const VkSubresourceLayout2KHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkSubresourceLayout2KHR* copy_src, PNextCopyState* copy_state = {});
-    VkSubresourceLayout2KHR* ptr() { return reinterpret_cast<VkSubresourceLayout2KHR*>(this); }
-    VkSubresourceLayout2KHR const* ptr() const { return reinterpret_cast<VkSubresourceLayout2KHR const*>(this); }
-};
-struct safe_VkPipelineCreateFlags2CreateInfoKHR {
-    VkStructureType sType;
-    const void* pNext{};
-    VkPipelineCreateFlags2KHR flags;
-
-    safe_VkPipelineCreateFlags2CreateInfoKHR(const VkPipelineCreateFlags2CreateInfoKHR* in_struct, PNextCopyState* copy_state = {},
-                                             bool copy_pnext = true);
-    safe_VkPipelineCreateFlags2CreateInfoKHR(const safe_VkPipelineCreateFlags2CreateInfoKHR& copy_src);
-    safe_VkPipelineCreateFlags2CreateInfoKHR& operator=(const safe_VkPipelineCreateFlags2CreateInfoKHR& copy_src);
-    safe_VkPipelineCreateFlags2CreateInfoKHR();
-    ~safe_VkPipelineCreateFlags2CreateInfoKHR();
-    void initialize(const VkPipelineCreateFlags2CreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPipelineCreateFlags2CreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
-    VkPipelineCreateFlags2CreateInfoKHR* ptr() { return reinterpret_cast<VkPipelineCreateFlags2CreateInfoKHR*>(this); }
-    VkPipelineCreateFlags2CreateInfoKHR const* ptr() const {
-        return reinterpret_cast<VkPipelineCreateFlags2CreateInfoKHR const*>(this);
-    }
-};
-struct safe_VkBufferUsageFlags2CreateInfoKHR {
-    VkStructureType sType;
-    const void* pNext{};
-    VkBufferUsageFlags2KHR usage;
-
-    safe_VkBufferUsageFlags2CreateInfoKHR(const VkBufferUsageFlags2CreateInfoKHR* in_struct, PNextCopyState* copy_state = {},
-                                          bool copy_pnext = true);
-    safe_VkBufferUsageFlags2CreateInfoKHR(const safe_VkBufferUsageFlags2CreateInfoKHR& copy_src);
-    safe_VkBufferUsageFlags2CreateInfoKHR& operator=(const safe_VkBufferUsageFlags2CreateInfoKHR& copy_src);
-    safe_VkBufferUsageFlags2CreateInfoKHR();
-    ~safe_VkBufferUsageFlags2CreateInfoKHR();
-    void initialize(const VkBufferUsageFlags2CreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkBufferUsageFlags2CreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
-    VkBufferUsageFlags2CreateInfoKHR* ptr() { return reinterpret_cast<VkBufferUsageFlags2CreateInfoKHR*>(this); }
-    VkBufferUsageFlags2CreateInfoKHR const* ptr() const { return reinterpret_cast<VkBufferUsageFlags2CreateInfoKHR const*>(this); }
-};
 struct safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR {
     VkStructureType sType;
     void* pNext{};
@@ -8519,182 +9190,6 @@ struct safe_VkVideoInlineQueryInfoKHR {
     VkVideoInlineQueryInfoKHR* ptr() { return reinterpret_cast<VkVideoInlineQueryInfoKHR*>(this); }
     VkVideoInlineQueryInfoKHR const* ptr() const { return reinterpret_cast<VkVideoInlineQueryInfoKHR const*>(this); }
 };
-struct safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR {
-    VkStructureType sType;
-    void* pNext{};
-    uint32_t maxVertexAttribDivisor;
-    VkBool32 supportsNonZeroFirstInstance;
-
-    safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR(const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* in_struct,
-                                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR(
-        const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& copy_src);
-    safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& operator=(
-        const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& copy_src);
-    safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR();
-    ~safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR();
-    void initialize(const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
-    VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* ptr() {
-        return reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR*>(this);
-    }
-    VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR const* ptr() const {
-        return reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR const*>(this);
-    }
-};
-struct safe_VkPipelineVertexInputDivisorStateCreateInfoKHR {
-    VkStructureType sType;
-    const void* pNext{};
-    uint32_t vertexBindingDivisorCount;
-    const VkVertexInputBindingDivisorDescriptionKHR* pVertexBindingDivisors{};
-
-    safe_VkPipelineVertexInputDivisorStateCreateInfoKHR(const VkPipelineVertexInputDivisorStateCreateInfoKHR* in_struct,
-                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPipelineVertexInputDivisorStateCreateInfoKHR(const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR& copy_src);
-    safe_VkPipelineVertexInputDivisorStateCreateInfoKHR& operator=(
-        const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR& copy_src);
-    safe_VkPipelineVertexInputDivisorStateCreateInfoKHR();
-    ~safe_VkPipelineVertexInputDivisorStateCreateInfoKHR();
-    void initialize(const VkPipelineVertexInputDivisorStateCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
-    VkPipelineVertexInputDivisorStateCreateInfoKHR* ptr() {
-        return reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoKHR*>(this);
-    }
-    VkPipelineVertexInputDivisorStateCreateInfoKHR const* ptr() const {
-        return reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoKHR const*>(this);
-    }
-};
-struct safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR {
-    VkStructureType sType;
-    void* pNext{};
-    VkBool32 vertexAttributeInstanceRateDivisor;
-    VkBool32 vertexAttributeInstanceRateZeroDivisor;
-
-    safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR(const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* in_struct,
-                                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR(const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& copy_src);
-    safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& operator=(
-        const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& copy_src);
-    safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR();
-    ~safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR();
-    void initialize(const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
-    VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* ptr() {
-        return reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR*>(this);
-    }
-    VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR const* ptr() const {
-        return reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR const*>(this);
-    }
-};
-struct safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR {
-    VkStructureType sType;
-    void* pNext{};
-    VkBool32 shaderFloatControls2;
-
-    safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR(const VkPhysicalDeviceShaderFloatControls2FeaturesKHR* in_struct,
-                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR(const safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR& copy_src);
-    safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR& operator=(
-        const safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR& copy_src);
-    safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR();
-    ~safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR();
-    void initialize(const VkPhysicalDeviceShaderFloatControls2FeaturesKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR* copy_src, PNextCopyState* copy_state = {});
-    VkPhysicalDeviceShaderFloatControls2FeaturesKHR* ptr() {
-        return reinterpret_cast<VkPhysicalDeviceShaderFloatControls2FeaturesKHR*>(this);
-    }
-    VkPhysicalDeviceShaderFloatControls2FeaturesKHR const* ptr() const {
-        return reinterpret_cast<VkPhysicalDeviceShaderFloatControls2FeaturesKHR const*>(this);
-    }
-};
-struct safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR {
-    VkStructureType sType;
-    void* pNext{};
-    VkBool32 indexTypeUint8;
-
-    safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR(const VkPhysicalDeviceIndexTypeUint8FeaturesKHR* in_struct,
-                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR& copy_src);
-    safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR& operator=(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR& copy_src);
-    safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR();
-    ~safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR();
-    void initialize(const VkPhysicalDeviceIndexTypeUint8FeaturesKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR* copy_src, PNextCopyState* copy_state = {});
-    VkPhysicalDeviceIndexTypeUint8FeaturesKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesKHR*>(this); }
-    VkPhysicalDeviceIndexTypeUint8FeaturesKHR const* ptr() const {
-        return reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesKHR const*>(this);
-    }
-};
-struct safe_VkPhysicalDeviceLineRasterizationFeaturesKHR {
-    VkStructureType sType;
-    void* pNext{};
-    VkBool32 rectangularLines;
-    VkBool32 bresenhamLines;
-    VkBool32 smoothLines;
-    VkBool32 stippledRectangularLines;
-    VkBool32 stippledBresenhamLines;
-    VkBool32 stippledSmoothLines;
-
-    safe_VkPhysicalDeviceLineRasterizationFeaturesKHR(const VkPhysicalDeviceLineRasterizationFeaturesKHR* in_struct,
-                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPhysicalDeviceLineRasterizationFeaturesKHR(const safe_VkPhysicalDeviceLineRasterizationFeaturesKHR& copy_src);
-    safe_VkPhysicalDeviceLineRasterizationFeaturesKHR& operator=(const safe_VkPhysicalDeviceLineRasterizationFeaturesKHR& copy_src);
-    safe_VkPhysicalDeviceLineRasterizationFeaturesKHR();
-    ~safe_VkPhysicalDeviceLineRasterizationFeaturesKHR();
-    void initialize(const VkPhysicalDeviceLineRasterizationFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPhysicalDeviceLineRasterizationFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
-    VkPhysicalDeviceLineRasterizationFeaturesKHR* ptr() {
-        return reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesKHR*>(this);
-    }
-    VkPhysicalDeviceLineRasterizationFeaturesKHR const* ptr() const {
-        return reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesKHR const*>(this);
-    }
-};
-struct safe_VkPhysicalDeviceLineRasterizationPropertiesKHR {
-    VkStructureType sType;
-    void* pNext{};
-    uint32_t lineSubPixelPrecisionBits;
-
-    safe_VkPhysicalDeviceLineRasterizationPropertiesKHR(const VkPhysicalDeviceLineRasterizationPropertiesKHR* in_struct,
-                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPhysicalDeviceLineRasterizationPropertiesKHR(const safe_VkPhysicalDeviceLineRasterizationPropertiesKHR& copy_src);
-    safe_VkPhysicalDeviceLineRasterizationPropertiesKHR& operator=(
-        const safe_VkPhysicalDeviceLineRasterizationPropertiesKHR& copy_src);
-    safe_VkPhysicalDeviceLineRasterizationPropertiesKHR();
-    ~safe_VkPhysicalDeviceLineRasterizationPropertiesKHR();
-    void initialize(const VkPhysicalDeviceLineRasterizationPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPhysicalDeviceLineRasterizationPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
-    VkPhysicalDeviceLineRasterizationPropertiesKHR* ptr() {
-        return reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesKHR*>(this);
-    }
-    VkPhysicalDeviceLineRasterizationPropertiesKHR const* ptr() const {
-        return reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesKHR const*>(this);
-    }
-};
-struct safe_VkPipelineRasterizationLineStateCreateInfoKHR {
-    VkStructureType sType;
-    const void* pNext{};
-    VkLineRasterizationModeKHR lineRasterizationMode;
-    VkBool32 stippledLineEnable;
-    uint32_t lineStippleFactor;
-    uint16_t lineStipplePattern;
-
-    safe_VkPipelineRasterizationLineStateCreateInfoKHR(const VkPipelineRasterizationLineStateCreateInfoKHR* in_struct,
-                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPipelineRasterizationLineStateCreateInfoKHR(const safe_VkPipelineRasterizationLineStateCreateInfoKHR& copy_src);
-    safe_VkPipelineRasterizationLineStateCreateInfoKHR& operator=(
-        const safe_VkPipelineRasterizationLineStateCreateInfoKHR& copy_src);
-    safe_VkPipelineRasterizationLineStateCreateInfoKHR();
-    ~safe_VkPipelineRasterizationLineStateCreateInfoKHR();
-    void initialize(const VkPipelineRasterizationLineStateCreateInfoKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPipelineRasterizationLineStateCreateInfoKHR* copy_src, PNextCopyState* copy_state = {});
-    VkPipelineRasterizationLineStateCreateInfoKHR* ptr() {
-        return reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoKHR*>(this);
-    }
-    VkPipelineRasterizationLineStateCreateInfoKHR const* ptr() const {
-        return reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoKHR const*>(this);
-    }
-};
 struct safe_VkCalibratedTimestampInfoKHR {
     VkStructureType sType;
     const void* pNext{};
@@ -8711,162 +9206,6 @@ struct safe_VkCalibratedTimestampInfoKHR {
     VkCalibratedTimestampInfoKHR* ptr() { return reinterpret_cast<VkCalibratedTimestampInfoKHR*>(this); }
     VkCalibratedTimestampInfoKHR const* ptr() const { return reinterpret_cast<VkCalibratedTimestampInfoKHR const*>(this); }
 };
-struct safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR {
-    VkStructureType sType;
-    void* pNext{};
-    VkBool32 shaderExpectAssume;
-
-    safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR(const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* in_struct,
-                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR(const safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR& copy_src);
-    safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR& operator=(
-        const safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR& copy_src);
-    safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR();
-    ~safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR();
-    void initialize(const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
-    VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* ptr() {
-        return reinterpret_cast<VkPhysicalDeviceShaderExpectAssumeFeaturesKHR*>(this);
-    }
-    VkPhysicalDeviceShaderExpectAssumeFeaturesKHR const* ptr() const {
-        return reinterpret_cast<VkPhysicalDeviceShaderExpectAssumeFeaturesKHR const*>(this);
-    }
-};
-struct safe_VkPhysicalDeviceMaintenance6FeaturesKHR {
-    VkStructureType sType;
-    void* pNext{};
-    VkBool32 maintenance6;
-
-    safe_VkPhysicalDeviceMaintenance6FeaturesKHR(const VkPhysicalDeviceMaintenance6FeaturesKHR* in_struct,
-                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPhysicalDeviceMaintenance6FeaturesKHR(const safe_VkPhysicalDeviceMaintenance6FeaturesKHR& copy_src);
-    safe_VkPhysicalDeviceMaintenance6FeaturesKHR& operator=(const safe_VkPhysicalDeviceMaintenance6FeaturesKHR& copy_src);
-    safe_VkPhysicalDeviceMaintenance6FeaturesKHR();
-    ~safe_VkPhysicalDeviceMaintenance6FeaturesKHR();
-    void initialize(const VkPhysicalDeviceMaintenance6FeaturesKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPhysicalDeviceMaintenance6FeaturesKHR* copy_src, PNextCopyState* copy_state = {});
-    VkPhysicalDeviceMaintenance6FeaturesKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceMaintenance6FeaturesKHR*>(this); }
-    VkPhysicalDeviceMaintenance6FeaturesKHR const* ptr() const {
-        return reinterpret_cast<VkPhysicalDeviceMaintenance6FeaturesKHR const*>(this);
-    }
-};
-struct safe_VkPhysicalDeviceMaintenance6PropertiesKHR {
-    VkStructureType sType;
-    void* pNext{};
-    VkBool32 blockTexelViewCompatibleMultipleLayers;
-    uint32_t maxCombinedImageSamplerDescriptorCount;
-    VkBool32 fragmentShadingRateClampCombinerInputs;
-
-    safe_VkPhysicalDeviceMaintenance6PropertiesKHR(const VkPhysicalDeviceMaintenance6PropertiesKHR* in_struct,
-                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPhysicalDeviceMaintenance6PropertiesKHR(const safe_VkPhysicalDeviceMaintenance6PropertiesKHR& copy_src);
-    safe_VkPhysicalDeviceMaintenance6PropertiesKHR& operator=(const safe_VkPhysicalDeviceMaintenance6PropertiesKHR& copy_src);
-    safe_VkPhysicalDeviceMaintenance6PropertiesKHR();
-    ~safe_VkPhysicalDeviceMaintenance6PropertiesKHR();
-    void initialize(const VkPhysicalDeviceMaintenance6PropertiesKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPhysicalDeviceMaintenance6PropertiesKHR* copy_src, PNextCopyState* copy_state = {});
-    VkPhysicalDeviceMaintenance6PropertiesKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceMaintenance6PropertiesKHR*>(this); }
-    VkPhysicalDeviceMaintenance6PropertiesKHR const* ptr() const {
-        return reinterpret_cast<VkPhysicalDeviceMaintenance6PropertiesKHR const*>(this);
-    }
-};
-struct safe_VkBindMemoryStatusKHR {
-    VkStructureType sType;
-    const void* pNext{};
-    VkResult* pResult{};
-
-    safe_VkBindMemoryStatusKHR(const VkBindMemoryStatusKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkBindMemoryStatusKHR(const safe_VkBindMemoryStatusKHR& copy_src);
-    safe_VkBindMemoryStatusKHR& operator=(const safe_VkBindMemoryStatusKHR& copy_src);
-    safe_VkBindMemoryStatusKHR();
-    ~safe_VkBindMemoryStatusKHR();
-    void initialize(const VkBindMemoryStatusKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkBindMemoryStatusKHR* copy_src, PNextCopyState* copy_state = {});
-    VkBindMemoryStatusKHR* ptr() { return reinterpret_cast<VkBindMemoryStatusKHR*>(this); }
-    VkBindMemoryStatusKHR const* ptr() const { return reinterpret_cast<VkBindMemoryStatusKHR const*>(this); }
-};
-struct safe_VkBindDescriptorSetsInfoKHR {
-    VkStructureType sType;
-    const void* pNext{};
-    VkShaderStageFlags stageFlags;
-    VkPipelineLayout layout;
-    uint32_t firstSet;
-    uint32_t descriptorSetCount;
-    VkDescriptorSet* pDescriptorSets{};
-    uint32_t dynamicOffsetCount;
-    const uint32_t* pDynamicOffsets{};
-
-    safe_VkBindDescriptorSetsInfoKHR(const VkBindDescriptorSetsInfoKHR* in_struct, PNextCopyState* copy_state = {},
-                                     bool copy_pnext = true);
-    safe_VkBindDescriptorSetsInfoKHR(const safe_VkBindDescriptorSetsInfoKHR& copy_src);
-    safe_VkBindDescriptorSetsInfoKHR& operator=(const safe_VkBindDescriptorSetsInfoKHR& copy_src);
-    safe_VkBindDescriptorSetsInfoKHR();
-    ~safe_VkBindDescriptorSetsInfoKHR();
-    void initialize(const VkBindDescriptorSetsInfoKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkBindDescriptorSetsInfoKHR* copy_src, PNextCopyState* copy_state = {});
-    VkBindDescriptorSetsInfoKHR* ptr() { return reinterpret_cast<VkBindDescriptorSetsInfoKHR*>(this); }
-    VkBindDescriptorSetsInfoKHR const* ptr() const { return reinterpret_cast<VkBindDescriptorSetsInfoKHR const*>(this); }
-};
-struct safe_VkPushConstantsInfoKHR {
-    VkStructureType sType;
-    const void* pNext{};
-    VkPipelineLayout layout;
-    VkShaderStageFlags stageFlags;
-    uint32_t offset;
-    uint32_t size;
-    const void* pValues{};
-
-    safe_VkPushConstantsInfoKHR(const VkPushConstantsInfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPushConstantsInfoKHR(const safe_VkPushConstantsInfoKHR& copy_src);
-    safe_VkPushConstantsInfoKHR& operator=(const safe_VkPushConstantsInfoKHR& copy_src);
-    safe_VkPushConstantsInfoKHR();
-    ~safe_VkPushConstantsInfoKHR();
-    void initialize(const VkPushConstantsInfoKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPushConstantsInfoKHR* copy_src, PNextCopyState* copy_state = {});
-    VkPushConstantsInfoKHR* ptr() { return reinterpret_cast<VkPushConstantsInfoKHR*>(this); }
-    VkPushConstantsInfoKHR const* ptr() const { return reinterpret_cast<VkPushConstantsInfoKHR const*>(this); }
-};
-struct safe_VkPushDescriptorSetInfoKHR {
-    VkStructureType sType;
-    const void* pNext{};
-    VkShaderStageFlags stageFlags;
-    VkPipelineLayout layout;
-    uint32_t set;
-    uint32_t descriptorWriteCount;
-    safe_VkWriteDescriptorSet* pDescriptorWrites{};
-
-    safe_VkPushDescriptorSetInfoKHR(const VkPushDescriptorSetInfoKHR* in_struct, PNextCopyState* copy_state = {},
-                                    bool copy_pnext = true);
-    safe_VkPushDescriptorSetInfoKHR(const safe_VkPushDescriptorSetInfoKHR& copy_src);
-    safe_VkPushDescriptorSetInfoKHR& operator=(const safe_VkPushDescriptorSetInfoKHR& copy_src);
-    safe_VkPushDescriptorSetInfoKHR();
-    ~safe_VkPushDescriptorSetInfoKHR();
-    void initialize(const VkPushDescriptorSetInfoKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPushDescriptorSetInfoKHR* copy_src, PNextCopyState* copy_state = {});
-    VkPushDescriptorSetInfoKHR* ptr() { return reinterpret_cast<VkPushDescriptorSetInfoKHR*>(this); }
-    VkPushDescriptorSetInfoKHR const* ptr() const { return reinterpret_cast<VkPushDescriptorSetInfoKHR const*>(this); }
-};
-struct safe_VkPushDescriptorSetWithTemplateInfoKHR {
-    VkStructureType sType;
-    const void* pNext{};
-    VkDescriptorUpdateTemplate descriptorUpdateTemplate;
-    VkPipelineLayout layout;
-    uint32_t set;
-    const void* pData{};
-
-    safe_VkPushDescriptorSetWithTemplateInfoKHR(const VkPushDescriptorSetWithTemplateInfoKHR* in_struct,
-                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPushDescriptorSetWithTemplateInfoKHR(const safe_VkPushDescriptorSetWithTemplateInfoKHR& copy_src);
-    safe_VkPushDescriptorSetWithTemplateInfoKHR& operator=(const safe_VkPushDescriptorSetWithTemplateInfoKHR& copy_src);
-    safe_VkPushDescriptorSetWithTemplateInfoKHR();
-    ~safe_VkPushDescriptorSetWithTemplateInfoKHR();
-    void initialize(const VkPushDescriptorSetWithTemplateInfoKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPushDescriptorSetWithTemplateInfoKHR* copy_src, PNextCopyState* copy_state = {});
-    VkPushDescriptorSetWithTemplateInfoKHR* ptr() { return reinterpret_cast<VkPushDescriptorSetWithTemplateInfoKHR*>(this); }
-    VkPushDescriptorSetWithTemplateInfoKHR const* ptr() const {
-        return reinterpret_cast<VkPushDescriptorSetWithTemplateInfoKHR const*>(this);
-    }
-};
 struct safe_VkSetDescriptorBufferOffsetsInfoEXT {
     VkStructureType sType;
     const void* pNext{};
@@ -9811,72 +10150,6 @@ struct safe_VkPhysicalDeviceASTCDecodeFeaturesEXT {
         return reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT const*>(this);
     }
 };
-struct safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT {
-    VkStructureType sType;
-    void* pNext{};
-    VkBool32 pipelineRobustness;
-
-    safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT(const VkPhysicalDevicePipelineRobustnessFeaturesEXT* in_struct,
-                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT(const safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT& copy_src);
-    safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT& operator=(
-        const safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT& copy_src);
-    safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT();
-    ~safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT();
-    void initialize(const VkPhysicalDevicePipelineRobustnessFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
-    VkPhysicalDevicePipelineRobustnessFeaturesEXT* ptr() {
-        return reinterpret_cast<VkPhysicalDevicePipelineRobustnessFeaturesEXT*>(this);
-    }
-    VkPhysicalDevicePipelineRobustnessFeaturesEXT const* ptr() const {
-        return reinterpret_cast<VkPhysicalDevicePipelineRobustnessFeaturesEXT const*>(this);
-    }
-};
-struct safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT {
-    VkStructureType sType;
-    void* pNext{};
-    VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessStorageBuffers;
-    VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessUniformBuffers;
-    VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessVertexInputs;
-    VkPipelineRobustnessImageBehaviorEXT defaultRobustnessImages;
-
-    safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT(const VkPhysicalDevicePipelineRobustnessPropertiesEXT* in_struct,
-                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT(const safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT& copy_src);
-    safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT& operator=(
-        const safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT& copy_src);
-    safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT();
-    ~safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT();
-    void initialize(const VkPhysicalDevicePipelineRobustnessPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
-    VkPhysicalDevicePipelineRobustnessPropertiesEXT* ptr() {
-        return reinterpret_cast<VkPhysicalDevicePipelineRobustnessPropertiesEXT*>(this);
-    }
-    VkPhysicalDevicePipelineRobustnessPropertiesEXT const* ptr() const {
-        return reinterpret_cast<VkPhysicalDevicePipelineRobustnessPropertiesEXT const*>(this);
-    }
-};
-struct safe_VkPipelineRobustnessCreateInfoEXT {
-    VkStructureType sType;
-    const void* pNext{};
-    VkPipelineRobustnessBufferBehaviorEXT storageBuffers;
-    VkPipelineRobustnessBufferBehaviorEXT uniformBuffers;
-    VkPipelineRobustnessBufferBehaviorEXT vertexInputs;
-    VkPipelineRobustnessImageBehaviorEXT images;
-
-    safe_VkPipelineRobustnessCreateInfoEXT(const VkPipelineRobustnessCreateInfoEXT* in_struct, PNextCopyState* copy_state = {},
-                                           bool copy_pnext = true);
-    safe_VkPipelineRobustnessCreateInfoEXT(const safe_VkPipelineRobustnessCreateInfoEXT& copy_src);
-    safe_VkPipelineRobustnessCreateInfoEXT& operator=(const safe_VkPipelineRobustnessCreateInfoEXT& copy_src);
-    safe_VkPipelineRobustnessCreateInfoEXT();
-    ~safe_VkPipelineRobustnessCreateInfoEXT();
-    void initialize(const VkPipelineRobustnessCreateInfoEXT* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPipelineRobustnessCreateInfoEXT* copy_src, PNextCopyState* copy_state = {});
-    VkPipelineRobustnessCreateInfoEXT* ptr() { return reinterpret_cast<VkPipelineRobustnessCreateInfoEXT*>(this); }
-    VkPipelineRobustnessCreateInfoEXT const* ptr() const {
-        return reinterpret_cast<VkPipelineRobustnessCreateInfoEXT const*>(this);
-    }
-};
 struct safe_VkConditionalRenderingBeginInfoEXT {
     VkStructureType sType;
     const void* pNext{};
@@ -12817,207 +13090,6 @@ struct safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT {
         return reinterpret_cast<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT const*>(this);
     }
 };
-struct safe_VkPhysicalDeviceHostImageCopyFeaturesEXT {
-    VkStructureType sType;
-    void* pNext{};
-    VkBool32 hostImageCopy;
-
-    safe_VkPhysicalDeviceHostImageCopyFeaturesEXT(const VkPhysicalDeviceHostImageCopyFeaturesEXT* in_struct,
-                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPhysicalDeviceHostImageCopyFeaturesEXT(const safe_VkPhysicalDeviceHostImageCopyFeaturesEXT& copy_src);
-    safe_VkPhysicalDeviceHostImageCopyFeaturesEXT& operator=(const safe_VkPhysicalDeviceHostImageCopyFeaturesEXT& copy_src);
-    safe_VkPhysicalDeviceHostImageCopyFeaturesEXT();
-    ~safe_VkPhysicalDeviceHostImageCopyFeaturesEXT();
-    void initialize(const VkPhysicalDeviceHostImageCopyFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPhysicalDeviceHostImageCopyFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
-    VkPhysicalDeviceHostImageCopyFeaturesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceHostImageCopyFeaturesEXT*>(this); }
-    VkPhysicalDeviceHostImageCopyFeaturesEXT const* ptr() const {
-        return reinterpret_cast<VkPhysicalDeviceHostImageCopyFeaturesEXT const*>(this);
-    }
-};
-struct safe_VkPhysicalDeviceHostImageCopyPropertiesEXT {
-    VkStructureType sType;
-    void* pNext{};
-    uint32_t copySrcLayoutCount;
-    VkImageLayout* pCopySrcLayouts{};
-    uint32_t copyDstLayoutCount;
-    VkImageLayout* pCopyDstLayouts{};
-    uint8_t optimalTilingLayoutUUID[VK_UUID_SIZE];
-    VkBool32 identicalMemoryTypeRequirements;
-
-    safe_VkPhysicalDeviceHostImageCopyPropertiesEXT(const VkPhysicalDeviceHostImageCopyPropertiesEXT* in_struct,
-                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPhysicalDeviceHostImageCopyPropertiesEXT(const safe_VkPhysicalDeviceHostImageCopyPropertiesEXT& copy_src);
-    safe_VkPhysicalDeviceHostImageCopyPropertiesEXT& operator=(const safe_VkPhysicalDeviceHostImageCopyPropertiesEXT& copy_src);
-    safe_VkPhysicalDeviceHostImageCopyPropertiesEXT();
-    ~safe_VkPhysicalDeviceHostImageCopyPropertiesEXT();
-    void initialize(const VkPhysicalDeviceHostImageCopyPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPhysicalDeviceHostImageCopyPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
-    VkPhysicalDeviceHostImageCopyPropertiesEXT* ptr() {
-        return reinterpret_cast<VkPhysicalDeviceHostImageCopyPropertiesEXT*>(this);
-    }
-    VkPhysicalDeviceHostImageCopyPropertiesEXT const* ptr() const {
-        return reinterpret_cast<VkPhysicalDeviceHostImageCopyPropertiesEXT const*>(this);
-    }
-};
-struct safe_VkMemoryToImageCopyEXT {
-    VkStructureType sType;
-    const void* pNext{};
-    const void* pHostPointer{};
-    uint32_t memoryRowLength;
-    uint32_t memoryImageHeight;
-    VkImageSubresourceLayers imageSubresource;
-    VkOffset3D imageOffset;
-    VkExtent3D imageExtent;
-
-    safe_VkMemoryToImageCopyEXT(const VkMemoryToImageCopyEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkMemoryToImageCopyEXT(const safe_VkMemoryToImageCopyEXT& copy_src);
-    safe_VkMemoryToImageCopyEXT& operator=(const safe_VkMemoryToImageCopyEXT& copy_src);
-    safe_VkMemoryToImageCopyEXT();
-    ~safe_VkMemoryToImageCopyEXT();
-    void initialize(const VkMemoryToImageCopyEXT* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkMemoryToImageCopyEXT* copy_src, PNextCopyState* copy_state = {});
-    VkMemoryToImageCopyEXT* ptr() { return reinterpret_cast<VkMemoryToImageCopyEXT*>(this); }
-    VkMemoryToImageCopyEXT const* ptr() const { return reinterpret_cast<VkMemoryToImageCopyEXT const*>(this); }
-};
-struct safe_VkImageToMemoryCopyEXT {
-    VkStructureType sType;
-    const void* pNext{};
-    void* pHostPointer{};
-    uint32_t memoryRowLength;
-    uint32_t memoryImageHeight;
-    VkImageSubresourceLayers imageSubresource;
-    VkOffset3D imageOffset;
-    VkExtent3D imageExtent;
-
-    safe_VkImageToMemoryCopyEXT(const VkImageToMemoryCopyEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkImageToMemoryCopyEXT(const safe_VkImageToMemoryCopyEXT& copy_src);
-    safe_VkImageToMemoryCopyEXT& operator=(const safe_VkImageToMemoryCopyEXT& copy_src);
-    safe_VkImageToMemoryCopyEXT();
-    ~safe_VkImageToMemoryCopyEXT();
-    void initialize(const VkImageToMemoryCopyEXT* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkImageToMemoryCopyEXT* copy_src, PNextCopyState* copy_state = {});
-    VkImageToMemoryCopyEXT* ptr() { return reinterpret_cast<VkImageToMemoryCopyEXT*>(this); }
-    VkImageToMemoryCopyEXT const* ptr() const { return reinterpret_cast<VkImageToMemoryCopyEXT const*>(this); }
-};
-struct safe_VkCopyMemoryToImageInfoEXT {
-    VkStructureType sType;
-    const void* pNext{};
-    VkHostImageCopyFlagsEXT flags;
-    VkImage dstImage;
-    VkImageLayout dstImageLayout;
-    uint32_t regionCount;
-    safe_VkMemoryToImageCopyEXT* pRegions{};
-
-    safe_VkCopyMemoryToImageInfoEXT(const VkCopyMemoryToImageInfoEXT* in_struct, PNextCopyState* copy_state = {},
-                                    bool copy_pnext = true);
-    safe_VkCopyMemoryToImageInfoEXT(const safe_VkCopyMemoryToImageInfoEXT& copy_src);
-    safe_VkCopyMemoryToImageInfoEXT& operator=(const safe_VkCopyMemoryToImageInfoEXT& copy_src);
-    safe_VkCopyMemoryToImageInfoEXT();
-    ~safe_VkCopyMemoryToImageInfoEXT();
-    void initialize(const VkCopyMemoryToImageInfoEXT* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkCopyMemoryToImageInfoEXT* copy_src, PNextCopyState* copy_state = {});
-    VkCopyMemoryToImageInfoEXT* ptr() { return reinterpret_cast<VkCopyMemoryToImageInfoEXT*>(this); }
-    VkCopyMemoryToImageInfoEXT const* ptr() const { return reinterpret_cast<VkCopyMemoryToImageInfoEXT const*>(this); }
-};
-struct safe_VkCopyImageToMemoryInfoEXT {
-    VkStructureType sType;
-    const void* pNext{};
-    VkHostImageCopyFlagsEXT flags;
-    VkImage srcImage;
-    VkImageLayout srcImageLayout;
-    uint32_t regionCount;
-    safe_VkImageToMemoryCopyEXT* pRegions{};
-
-    safe_VkCopyImageToMemoryInfoEXT(const VkCopyImageToMemoryInfoEXT* in_struct, PNextCopyState* copy_state = {},
-                                    bool copy_pnext = true);
-    safe_VkCopyImageToMemoryInfoEXT(const safe_VkCopyImageToMemoryInfoEXT& copy_src);
-    safe_VkCopyImageToMemoryInfoEXT& operator=(const safe_VkCopyImageToMemoryInfoEXT& copy_src);
-    safe_VkCopyImageToMemoryInfoEXT();
-    ~safe_VkCopyImageToMemoryInfoEXT();
-    void initialize(const VkCopyImageToMemoryInfoEXT* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkCopyImageToMemoryInfoEXT* copy_src, PNextCopyState* copy_state = {});
-    VkCopyImageToMemoryInfoEXT* ptr() { return reinterpret_cast<VkCopyImageToMemoryInfoEXT*>(this); }
-    VkCopyImageToMemoryInfoEXT const* ptr() const { return reinterpret_cast<VkCopyImageToMemoryInfoEXT const*>(this); }
-};
-struct safe_VkCopyImageToImageInfoEXT {
-    VkStructureType sType;
-    const void* pNext{};
-    VkHostImageCopyFlagsEXT flags;
-    VkImage srcImage;
-    VkImageLayout srcImageLayout;
-    VkImage dstImage;
-    VkImageLayout dstImageLayout;
-    uint32_t regionCount;
-    safe_VkImageCopy2* pRegions{};
-
-    safe_VkCopyImageToImageInfoEXT(const VkCopyImageToImageInfoEXT* in_struct, PNextCopyState* copy_state = {},
-                                   bool copy_pnext = true);
-    safe_VkCopyImageToImageInfoEXT(const safe_VkCopyImageToImageInfoEXT& copy_src);
-    safe_VkCopyImageToImageInfoEXT& operator=(const safe_VkCopyImageToImageInfoEXT& copy_src);
-    safe_VkCopyImageToImageInfoEXT();
-    ~safe_VkCopyImageToImageInfoEXT();
-    void initialize(const VkCopyImageToImageInfoEXT* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkCopyImageToImageInfoEXT* copy_src, PNextCopyState* copy_state = {});
-    VkCopyImageToImageInfoEXT* ptr() { return reinterpret_cast<VkCopyImageToImageInfoEXT*>(this); }
-    VkCopyImageToImageInfoEXT const* ptr() const { return reinterpret_cast<VkCopyImageToImageInfoEXT const*>(this); }
-};
-struct safe_VkHostImageLayoutTransitionInfoEXT {
-    VkStructureType sType;
-    const void* pNext{};
-    VkImage image;
-    VkImageLayout oldLayout;
-    VkImageLayout newLayout;
-    VkImageSubresourceRange subresourceRange;
-
-    safe_VkHostImageLayoutTransitionInfoEXT(const VkHostImageLayoutTransitionInfoEXT* in_struct, PNextCopyState* copy_state = {},
-                                            bool copy_pnext = true);
-    safe_VkHostImageLayoutTransitionInfoEXT(const safe_VkHostImageLayoutTransitionInfoEXT& copy_src);
-    safe_VkHostImageLayoutTransitionInfoEXT& operator=(const safe_VkHostImageLayoutTransitionInfoEXT& copy_src);
-    safe_VkHostImageLayoutTransitionInfoEXT();
-    ~safe_VkHostImageLayoutTransitionInfoEXT();
-    void initialize(const VkHostImageLayoutTransitionInfoEXT* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkHostImageLayoutTransitionInfoEXT* copy_src, PNextCopyState* copy_state = {});
-    VkHostImageLayoutTransitionInfoEXT* ptr() { return reinterpret_cast<VkHostImageLayoutTransitionInfoEXT*>(this); }
-    VkHostImageLayoutTransitionInfoEXT const* ptr() const {
-        return reinterpret_cast<VkHostImageLayoutTransitionInfoEXT const*>(this);
-    }
-};
-struct safe_VkSubresourceHostMemcpySizeEXT {
-    VkStructureType sType;
-    void* pNext{};
-    VkDeviceSize size;
-
-    safe_VkSubresourceHostMemcpySizeEXT(const VkSubresourceHostMemcpySizeEXT* in_struct, PNextCopyState* copy_state = {},
-                                        bool copy_pnext = true);
-    safe_VkSubresourceHostMemcpySizeEXT(const safe_VkSubresourceHostMemcpySizeEXT& copy_src);
-    safe_VkSubresourceHostMemcpySizeEXT& operator=(const safe_VkSubresourceHostMemcpySizeEXT& copy_src);
-    safe_VkSubresourceHostMemcpySizeEXT();
-    ~safe_VkSubresourceHostMemcpySizeEXT();
-    void initialize(const VkSubresourceHostMemcpySizeEXT* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkSubresourceHostMemcpySizeEXT* copy_src, PNextCopyState* copy_state = {});
-    VkSubresourceHostMemcpySizeEXT* ptr() { return reinterpret_cast<VkSubresourceHostMemcpySizeEXT*>(this); }
-    VkSubresourceHostMemcpySizeEXT const* ptr() const { return reinterpret_cast<VkSubresourceHostMemcpySizeEXT const*>(this); }
-};
-struct safe_VkHostImageCopyDevicePerformanceQueryEXT {
-    VkStructureType sType;
-    void* pNext{};
-    VkBool32 optimalDeviceAccess;
-    VkBool32 identicalMemoryLayout;
-
-    safe_VkHostImageCopyDevicePerformanceQueryEXT(const VkHostImageCopyDevicePerformanceQueryEXT* in_struct,
-                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkHostImageCopyDevicePerformanceQueryEXT(const safe_VkHostImageCopyDevicePerformanceQueryEXT& copy_src);
-    safe_VkHostImageCopyDevicePerformanceQueryEXT& operator=(const safe_VkHostImageCopyDevicePerformanceQueryEXT& copy_src);
-    safe_VkHostImageCopyDevicePerformanceQueryEXT();
-    ~safe_VkHostImageCopyDevicePerformanceQueryEXT();
-    void initialize(const VkHostImageCopyDevicePerformanceQueryEXT* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkHostImageCopyDevicePerformanceQueryEXT* copy_src, PNextCopyState* copy_state = {});
-    VkHostImageCopyDevicePerformanceQueryEXT* ptr() { return reinterpret_cast<VkHostImageCopyDevicePerformanceQueryEXT*>(this); }
-    VkHostImageCopyDevicePerformanceQueryEXT const* ptr() const {
-        return reinterpret_cast<VkHostImageCopyDevicePerformanceQueryEXT const*>(this);
-    }
-};
 struct safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT {
     VkStructureType sType;
     void* pNext{};
@@ -17674,28 +17746,6 @@ struct safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT {
         return reinterpret_cast<VkPhysicalDeviceLegacyDitheringFeaturesEXT const*>(this);
     }
 };
-struct safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT {
-    VkStructureType sType;
-    void* pNext{};
-    VkBool32 pipelineProtectedAccess;
-
-    safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* in_struct,
-                                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
-        const safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT& copy_src);
-    safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT& operator=(
-        const safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT& copy_src);
-    safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT();
-    ~safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT();
-    void initialize(const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
-    VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* ptr() {
-        return reinterpret_cast<VkPhysicalDevicePipelineProtectedAccessFeaturesEXT*>(this);
-    }
-    VkPhysicalDevicePipelineProtectedAccessFeaturesEXT const* ptr() const {
-        return reinterpret_cast<VkPhysicalDevicePipelineProtectedAccessFeaturesEXT const*>(this);
-    }
-};
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
 struct safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID {
     VkStructureType sType;
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index f5a10d1..ca9e0d9 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -232,6 +232,56 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance4Features
 template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance4Properties>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES; }
 template <> inline VkStructureType GetSType<VkDeviceBufferMemoryRequirements>() { return VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS; }
 template <> inline VkStructureType GetSType<VkDeviceImageMemoryRequirements>() { return VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceVulkan14Features>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceVulkan14Properties>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES; }
+template <> inline VkStructureType GetSType<VkDeviceQueueGlobalPriorityCreateInfo>() { return VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceGlobalPriorityQueryFeatures>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES; }
+template <> inline VkStructureType GetSType<VkQueueFamilyGlobalPriorityProperties>() { return VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderSubgroupRotateFeatures>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderFloatControls2Features>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderExpectAssumeFeatures>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceLineRasterizationFeatures>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceLineRasterizationProperties>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES; }
+template <> inline VkStructureType GetSType<VkPipelineRasterizationLineStateCreateInfo>() { return VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceVertexAttributeDivisorProperties>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES; }
+template <> inline VkStructureType GetSType<VkPipelineVertexInputDivisorStateCreateInfo>() { return VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceVertexAttributeDivisorFeatures>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceIndexTypeUint8Features>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES; }
+template <> inline VkStructureType GetSType<VkMemoryMapInfo>() { return VK_STRUCTURE_TYPE_MEMORY_MAP_INFO; }
+template <> inline VkStructureType GetSType<VkMemoryUnmapInfo>() { return VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance5Features>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance5Properties>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES; }
+template <> inline VkStructureType GetSType<VkRenderingAreaInfo>() { return VK_STRUCTURE_TYPE_RENDERING_AREA_INFO; }
+template <> inline VkStructureType GetSType<VkImageSubresource2>() { return VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2; }
+template <> inline VkStructureType GetSType<VkDeviceImageSubresourceInfo>() { return VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO; }
+template <> inline VkStructureType GetSType<VkSubresourceLayout2>() { return VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2; }
+template <> inline VkStructureType GetSType<VkPipelineCreateFlags2CreateInfo>() { return VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO; }
+template <> inline VkStructureType GetSType<VkBufferUsageFlags2CreateInfo>() { return VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO; }
+template <> inline VkStructureType GetSType<VkPhysicalDevicePushDescriptorProperties>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceDynamicRenderingLocalReadFeatures>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES; }
+template <> inline VkStructureType GetSType<VkRenderingAttachmentLocationInfo>() { return VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO; }
+template <> inline VkStructureType GetSType<VkRenderingInputAttachmentIndexInfo>() { return VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance6Features>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance6Properties>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES; }
+template <> inline VkStructureType GetSType<VkBindMemoryStatus>() { return VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS; }
+template <> inline VkStructureType GetSType<VkBindDescriptorSetsInfo>() { return VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO; }
+template <> inline VkStructureType GetSType<VkPushConstantsInfo>() { return VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO; }
+template <> inline VkStructureType GetSType<VkPushDescriptorSetInfo>() { return VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO; }
+template <> inline VkStructureType GetSType<VkPushDescriptorSetWithTemplateInfo>() { return VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO; }
+template <> inline VkStructureType GetSType<VkPhysicalDevicePipelineProtectedAccessFeatures>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES; }
+template <> inline VkStructureType GetSType<VkPhysicalDevicePipelineRobustnessFeatures>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES; }
+template <> inline VkStructureType GetSType<VkPhysicalDevicePipelineRobustnessProperties>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES; }
+template <> inline VkStructureType GetSType<VkPipelineRobustnessCreateInfo>() { return VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceHostImageCopyFeatures>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceHostImageCopyProperties>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES; }
+template <> inline VkStructureType GetSType<VkMemoryToImageCopy>() { return VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY; }
+template <> inline VkStructureType GetSType<VkImageToMemoryCopy>() { return VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY; }
+template <> inline VkStructureType GetSType<VkCopyMemoryToImageInfo>() { return VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO; }
+template <> inline VkStructureType GetSType<VkCopyImageToMemoryInfo>() { return VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO; }
+template <> inline VkStructureType GetSType<VkCopyImageToImageInfo>() { return VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO; }
+template <> inline VkStructureType GetSType<VkHostImageLayoutTransitionInfo>() { return VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO; }
+template <> inline VkStructureType GetSType<VkSubresourceHostMemcpySize>() { return VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE; }
+template <> inline VkStructureType GetSType<VkHostImageCopyDevicePerformanceQuery>() { return VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY; }
 template <> inline VkStructureType GetSType<VkSwapchainCreateInfoKHR>() { return VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkPresentInfoKHR>() { return VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkImageSwapchainCreateInfoKHR>() { return VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR; }
@@ -330,7 +380,6 @@ template <> inline VkStructureType GetSType<VkSemaphoreGetWin32HandleInfoKHR>()
 #endif  // VK_USE_PLATFORM_WIN32_KHR
 template <> inline VkStructureType GetSType<VkImportSemaphoreFdInfoKHR>() { return VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkSemaphoreGetFdInfoKHR>() { return VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkPhysicalDevicePushDescriptorPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR; }
 template <> inline VkStructureType GetSType<VkPresentRegionsKHR>() { return VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR; }
 template <> inline VkStructureType GetSType<VkSharedPresentSurfaceCapabilitiesKHR>() { return VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR; }
 #ifdef VK_USE_PLATFORM_WIN32_KHR
@@ -366,18 +415,12 @@ template <> inline VkStructureType GetSType<VkVideoDecodeH265SessionParametersAd
 template <> inline VkStructureType GetSType<VkVideoDecodeH265SessionParametersCreateInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkVideoDecodeH265PictureInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkVideoDecodeH265DpbSlotInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkDeviceQueueGlobalPriorityCreateInfoKHR>() { return VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR; }
-template <> inline VkStructureType GetSType<VkQueueFamilyGlobalPriorityPropertiesKHR>() { return VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR; }
 template <> inline VkStructureType GetSType<VkFragmentShadingRateAttachmentInfoKHR>() { return VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkPipelineFragmentShadingRateStateCreateInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceFragmentShadingRateFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceFragmentShadingRatePropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceFragmentShadingRateKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR; }
 template <> inline VkStructureType GetSType<VkRenderingFragmentShadingRateAttachmentInfoKHR>() { return VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR; }
-template <> inline VkStructureType GetSType<VkRenderingAttachmentLocationInfoKHR>() { return VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkRenderingInputAttachmentIndexInfoKHR>() { return VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderQuadControlFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkSurfaceProtectedCapabilitiesKHR>() { return VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDevicePresentWaitFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR; }
@@ -387,8 +430,6 @@ template <> inline VkStructureType GetSType<VkPipelineExecutablePropertiesKHR>()
 template <> inline VkStructureType GetSType<VkPipelineExecutableInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkPipelineExecutableStatisticKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR; }
 template <> inline VkStructureType GetSType<VkPipelineExecutableInternalRepresentationKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR; }
-template <> inline VkStructureType GetSType<VkMemoryMapInfoKHR>() { return VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkMemoryUnmapInfoKHR>() { return VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkPipelineLibraryCreateInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkPresentIdKHR>() { return VK_STRUCTURE_TYPE_PRESENT_ID_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDevicePresentIdFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR; }
@@ -408,16 +449,7 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceFragmentShaderBaryce
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance5FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance5PropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR; }
-template <> inline VkStructureType GetSType<VkRenderingAreaInfoKHR>() { return VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkImageSubresource2KHR>() { return VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR; }
-template <> inline VkStructureType GetSType<VkDeviceImageSubresourceInfoKHR>() { return VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkSubresourceLayout2KHR>() { return VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR; }
-template <> inline VkStructureType GetSType<VkPipelineCreateFlags2CreateInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkBufferUsageFlags2CreateInfoKHR>() { return VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDevicePipelineBinaryFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDevicePipelineBinaryPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR; }
@@ -452,23 +484,7 @@ template <> inline VkStructureType GetSType<VkVideoEncodeAV1RateControlInfoKHR>(
 template <> inline VkStructureType GetSType<VkVideoEncodeAV1RateControlLayerInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceVideoMaintenance1FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkVideoInlineQueryInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR; }
-template <> inline VkStructureType GetSType<VkPipelineVertexInputDivisorStateCreateInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderFloatControls2FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceIndexTypeUint8FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceLineRasterizationFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceLineRasterizationPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR; }
-template <> inline VkStructureType GetSType<VkPipelineRasterizationLineStateCreateInfoKHR>() { return VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkCalibratedTimestampInfoKHR>() { return VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderExpectAssumeFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance6FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance6PropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR; }
-template <> inline VkStructureType GetSType<VkBindMemoryStatusKHR>() { return VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR; }
-template <> inline VkStructureType GetSType<VkBindDescriptorSetsInfoKHR>() { return VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkPushConstantsInfoKHR>() { return VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkPushDescriptorSetInfoKHR>() { return VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkPushDescriptorSetWithTemplateInfoKHR>() { return VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkSetDescriptorBufferOffsetsInfoEXT>() { return VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkBindDescriptorBufferEmbeddedSamplersInfoEXT>() { return VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkVideoEncodeQuantizationMapCapabilitiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR; }
@@ -522,9 +538,6 @@ template <> inline VkStructureType GetSType<VkViSurfaceCreateInfoNN>() { return
 #endif  // VK_USE_PLATFORM_VI_NN
 template <> inline VkStructureType GetSType<VkImageViewASTCDecodeModeEXT>() { return VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceASTCDecodeFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT; }
-template <> inline VkStructureType GetSType<VkPhysicalDevicePipelineRobustnessFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT; }
-template <> inline VkStructureType GetSType<VkPhysicalDevicePipelineRobustnessPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT; }
-template <> inline VkStructureType GetSType<VkPipelineRobustnessCreateInfoEXT>() { return VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkConditionalRenderingBeginInfoEXT>() { return VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceConditionalRenderingFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkCommandBufferInheritanceConditionalRenderingInfoEXT>() { return VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT; }
@@ -681,16 +694,6 @@ template <> inline VkStructureType GetSType<VkSurfaceFullScreenExclusiveWin32Inf
 template <> inline VkStructureType GetSType<VkHeadlessSurfaceCreateInfoEXT>() { return VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceHostImageCopyFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceHostImageCopyPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT; }
-template <> inline VkStructureType GetSType<VkMemoryToImageCopyEXT>() { return VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT; }
-template <> inline VkStructureType GetSType<VkImageToMemoryCopyEXT>() { return VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT; }
-template <> inline VkStructureType GetSType<VkCopyMemoryToImageInfoEXT>() { return VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT; }
-template <> inline VkStructureType GetSType<VkCopyImageToMemoryInfoEXT>() { return VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT; }
-template <> inline VkStructureType GetSType<VkCopyImageToImageInfoEXT>() { return VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT; }
-template <> inline VkStructureType GetSType<VkHostImageLayoutTransitionInfoEXT>() { return VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT; }
-template <> inline VkStructureType GetSType<VkSubresourceHostMemcpySizeEXT>() { return VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT; }
-template <> inline VkStructureType GetSType<VkHostImageCopyDevicePerformanceQueryEXT>() { return VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceMapMemoryPlacedFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceMapMemoryPlacedPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT; }
 template <> inline VkStructureType GetSType<VkMemoryMapPlacedInfoEXT>() { return VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT; }
@@ -924,7 +927,6 @@ template <> inline VkStructureType GetSType<VkOpticalFlowSessionCreateInfoNV>()
 template <> inline VkStructureType GetSType<VkOpticalFlowSessionCreatePrivateDataInfoNV>() { return VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV; }
 template <> inline VkStructureType GetSType<VkOpticalFlowExecuteInfoNV>() { return VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceLegacyDitheringFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT; }
-template <> inline VkStructureType GetSType<VkPhysicalDevicePipelineProtectedAccessFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT; }
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
 template <> inline VkStructureType GetSType<VkPhysicalDeviceExternalFormatResolveFeaturesANDROID>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceExternalFormatResolvePropertiesANDROID>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index ffa113f..d169a27 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -64,6 +64,8 @@ static inline const char* string_VkResult(VkResult input_value) {
             return "VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS";
         case VK_PIPELINE_COMPILE_REQUIRED:
             return "VK_PIPELINE_COMPILE_REQUIRED";
+        case VK_ERROR_NOT_PERMITTED:
+            return "VK_ERROR_NOT_PERMITTED";
         case VK_ERROR_SURFACE_LOST_KHR:
             return "VK_ERROR_SURFACE_LOST_KHR";
         case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR:
@@ -92,8 +94,6 @@ static inline const char* string_VkResult(VkResult input_value) {
             return "VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR";
         case VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT:
             return "VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT";
-        case VK_ERROR_NOT_PERMITTED_KHR:
-            return "VK_ERROR_NOT_PERMITTED_KHR";
         case VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT:
             return "VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT";
         case VK_THREAD_IDLE_KHR:
@@ -552,6 +552,106 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS";
         case VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS:
             return "VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES";
+        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO:
+            return "VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES";
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES:
+            return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES";
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO:
+            return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES";
+        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO:
+            return "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES";
+        case VK_STRUCTURE_TYPE_MEMORY_MAP_INFO:
+            return "VK_STRUCTURE_TYPE_MEMORY_MAP_INFO";
+        case VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO:
+            return "VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES";
+        case VK_STRUCTURE_TYPE_RENDERING_AREA_INFO:
+            return "VK_STRUCTURE_TYPE_RENDERING_AREA_INFO";
+        case VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO:
+            return "VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO";
+        case VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2:
+            return "VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2";
+        case VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2:
+            return "VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2";
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO:
+            return "VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO";
+        case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO:
+            return "VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES";
+        case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO:
+            return "VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO";
+        case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO:
+            return "VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES";
+        case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS:
+            return "VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS";
+        case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO:
+            return "VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO";
+        case VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO:
+            return "VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO";
+        case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO:
+            return "VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO";
+        case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO:
+            return "VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES";
+        case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO:
+            return "VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES";
+        case VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY:
+            return "VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY";
+        case VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY:
+            return "VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY";
+        case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO:
+            return "VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO";
+        case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO:
+            return "VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO";
+        case VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO:
+            return "VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO";
+        case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO:
+            return "VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO";
+        case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE:
+            return "VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE";
+        case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY:
+            return "VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY";
         case VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR:
             return "VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR";
         case VK_STRUCTURE_TYPE_PRESENT_INFO_KHR:
@@ -750,12 +850,6 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT";
-        case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
-            return "VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT";
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
             return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR";
         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
@@ -784,8 +878,6 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR";
         case VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR:
             return "VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR";
         case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
             return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
@@ -1064,12 +1156,6 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR";
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR:
             return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR";
-        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR:
-            return "VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR";
-        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR:
-            return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR";
         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
             return "VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
@@ -1142,12 +1228,6 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR";
-        case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR:
-            return "VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR";
-        case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR:
-            return "VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR:
@@ -1216,30 +1296,6 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR";
         case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR:
             return "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT";
-        case VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT:
-            return "VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT";
-        case VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT:
-            return "VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT";
-        case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT:
-            return "VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT";
-        case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT:
-            return "VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT";
-        case VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT:
-            return "VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT";
-        case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT:
-            return "VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT";
-        case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT:
-            return "VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT";
-        case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT:
-            return "VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT";
-        case VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR:
-            return "VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR";
-        case VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR:
-            return "VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT:
@@ -1618,8 +1674,6 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR";
         case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM:
             return "VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM:
@@ -1730,30 +1784,12 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID";
         case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID:
             return "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR";
-        case VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR:
-            return "VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR";
-        case VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR:
-            return "VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR";
-        case VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR:
-            return "VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR";
-        case VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR:
-            return "VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR";
-        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR:
-            return "VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR";
-        case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR:
-            return "VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD";
         case VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD:
@@ -1914,14 +1950,6 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR";
-        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR:
-            return "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR";
         case VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX:
             return "VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX";
         case VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX:
@@ -1934,32 +1962,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR";
-        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR:
-            return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR";
         case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR:
             return "VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR";
-        case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR:
-            return "VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR";
-        case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR:
-            return "VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR";
-        case VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR:
-            return "VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR";
-        case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR:
-            return "VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR";
-        case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR:
-            return "VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR";
         case VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT:
             return "VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT";
         case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT:
@@ -2110,6 +2114,8 @@ static inline const char* string_VkImageLayout(VkImageLayout input_value) {
             return "VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL";
         case VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL:
             return "VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL";
+        case VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ:
+            return "VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ";
         case VK_IMAGE_LAYOUT_PRESENT_SRC_KHR:
             return "VK_IMAGE_LAYOUT_PRESENT_SRC_KHR";
         case VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR:
@@ -2124,8 +2130,6 @@ static inline const char* string_VkImageLayout(VkImageLayout input_value) {
             return "VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT";
         case VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR:
             return "VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR";
-        case VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR:
-            return "VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR";
         case VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR:
             return "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR";
         case VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR:
@@ -2780,6 +2784,10 @@ static inline const char* string_VkFormat(VkFormat input_value) {
             return "VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK";
         case VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK:
             return "VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK";
+        case VK_FORMAT_A1B5G5R5_UNORM_PACK16:
+            return "VK_FORMAT_A1B5G5R5_UNORM_PACK16";
+        case VK_FORMAT_A8_UNORM:
+            return "VK_FORMAT_A8_UNORM";
         case VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG:
             return "VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG";
         case VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG:
@@ -2798,10 +2806,6 @@ static inline const char* string_VkFormat(VkFormat input_value) {
             return "VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG";
         case VK_FORMAT_R16G16_SFIXED5_NV:
             return "VK_FORMAT_R16G16_SFIXED5_NV";
-        case VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR:
-            return "VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR";
-        case VK_FORMAT_A8_UNORM_KHR:
-            return "VK_FORMAT_A8_UNORM_KHR";
         default:
             return "Unhandled VkFormat";
     }
@@ -3160,6 +3164,8 @@ static inline const char* string_VkDynamicState(VkDynamicState input_value) {
             return "VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE";
         case VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE:
             return "VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE";
+        case VK_DYNAMIC_STATE_LINE_STIPPLE:
+            return "VK_DYNAMIC_STATE_LINE_STIPPLE";
         case VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV:
             return "VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV";
         case VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT:
@@ -3254,8 +3260,6 @@ static inline const char* string_VkDynamicState(VkDynamicState input_value) {
             return "VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV";
         case VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT:
             return "VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT";
-        case VK_DYNAMIC_STATE_LINE_STIPPLE_KHR:
-            return "VK_DYNAMIC_STATE_LINE_STIPPLE_KHR";
         case VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT:
             return "VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT";
         default:
@@ -3492,8 +3496,8 @@ static inline const char* string_VkAttachmentLoadOp(VkAttachmentLoadOp input_val
             return "VK_ATTACHMENT_LOAD_OP_CLEAR";
         case VK_ATTACHMENT_LOAD_OP_DONT_CARE:
             return "VK_ATTACHMENT_LOAD_OP_DONT_CARE";
-        case VK_ATTACHMENT_LOAD_OP_NONE_KHR:
-            return "VK_ATTACHMENT_LOAD_OP_NONE_KHR";
+        case VK_ATTACHMENT_LOAD_OP_NONE:
+            return "VK_ATTACHMENT_LOAD_OP_NONE";
         default:
             return "Unhandled VkAttachmentLoadOp";
     }
@@ -3544,10 +3548,10 @@ static inline const char* string_VkIndexType(VkIndexType input_value) {
             return "VK_INDEX_TYPE_UINT16";
         case VK_INDEX_TYPE_UINT32:
             return "VK_INDEX_TYPE_UINT32";
+        case VK_INDEX_TYPE_UINT8:
+            return "VK_INDEX_TYPE_UINT8";
         case VK_INDEX_TYPE_NONE_KHR:
             return "VK_INDEX_TYPE_NONE_KHR";
-        case VK_INDEX_TYPE_UINT8_KHR:
-            return "VK_INDEX_TYPE_UINT8_KHR";
         default:
             return "Unhandled VkIndexType";
     }
@@ -3624,8 +3628,8 @@ static inline const char* string_VkDescriptorUpdateTemplateType(VkDescriptorUpda
     switch (input_value) {
         case VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET:
             return "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET";
-        case VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR:
-            return "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR";
+        case VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS:
+            return "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS";
         default:
             return "Unhandled VkDescriptorUpdateTemplateType";
     }
@@ -3726,6 +3730,62 @@ static inline const char* string_VkSemaphoreType(VkSemaphoreType input_value) {
             return "Unhandled VkSemaphoreType";
     }
 }
+static inline const char* string_VkPipelineRobustnessBufferBehavior(VkPipelineRobustnessBufferBehavior input_value) {
+    switch (input_value) {
+        case VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT:
+            return "VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT";
+        case VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED:
+            return "VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED";
+        case VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS:
+            return "VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS";
+        case VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2:
+            return "VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2";
+        default:
+            return "Unhandled VkPipelineRobustnessBufferBehavior";
+    }
+}
+static inline const char* string_VkPipelineRobustnessImageBehavior(VkPipelineRobustnessImageBehavior input_value) {
+    switch (input_value) {
+        case VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT:
+            return "VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT";
+        case VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED:
+            return "VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED";
+        case VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS:
+            return "VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS";
+        case VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2:
+            return "VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2";
+        default:
+            return "Unhandled VkPipelineRobustnessImageBehavior";
+    }
+}
+static inline const char* string_VkQueueGlobalPriority(VkQueueGlobalPriority input_value) {
+    switch (input_value) {
+        case VK_QUEUE_GLOBAL_PRIORITY_LOW:
+            return "VK_QUEUE_GLOBAL_PRIORITY_LOW";
+        case VK_QUEUE_GLOBAL_PRIORITY_MEDIUM:
+            return "VK_QUEUE_GLOBAL_PRIORITY_MEDIUM";
+        case VK_QUEUE_GLOBAL_PRIORITY_HIGH:
+            return "VK_QUEUE_GLOBAL_PRIORITY_HIGH";
+        case VK_QUEUE_GLOBAL_PRIORITY_REALTIME:
+            return "VK_QUEUE_GLOBAL_PRIORITY_REALTIME";
+        default:
+            return "Unhandled VkQueueGlobalPriority";
+    }
+}
+static inline const char* string_VkLineRasterizationMode(VkLineRasterizationMode input_value) {
+    switch (input_value) {
+        case VK_LINE_RASTERIZATION_MODE_DEFAULT:
+            return "VK_LINE_RASTERIZATION_MODE_DEFAULT";
+        case VK_LINE_RASTERIZATION_MODE_RECTANGULAR:
+            return "VK_LINE_RASTERIZATION_MODE_RECTANGULAR";
+        case VK_LINE_RASTERIZATION_MODE_BRESENHAM:
+            return "VK_LINE_RASTERIZATION_MODE_BRESENHAM";
+        case VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH:
+            return "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH";
+        default:
+            return "Unhandled VkLineRasterizationMode";
+    }
+}
 static inline const char* string_VkPresentModeKHR(VkPresentModeKHR input_value) {
     switch (input_value) {
         case VK_PRESENT_MODE_IMMEDIATE_KHR:
@@ -3856,20 +3916,6 @@ static inline const char* string_VkPerformanceCounterStorageKHR(VkPerformanceCou
             return "Unhandled VkPerformanceCounterStorageKHR";
     }
 }
-static inline const char* string_VkQueueGlobalPriorityKHR(VkQueueGlobalPriorityKHR input_value) {
-    switch (input_value) {
-        case VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR:
-            return "VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR";
-        case VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR:
-            return "VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR";
-        case VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR:
-            return "VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR";
-        case VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR:
-            return "VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR";
-        default:
-            return "Unhandled VkQueueGlobalPriorityKHR";
-    }
-}
 static inline const char* string_VkFragmentShadingRateCombinerOpKHR(VkFragmentShadingRateCombinerOpKHR input_value) {
     switch (input_value) {
         case VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR:
@@ -3984,20 +4030,6 @@ static inline const char* string_VkVideoEncodeAV1RateControlGroupKHR(VkVideoEnco
             return "Unhandled VkVideoEncodeAV1RateControlGroupKHR";
     }
 }
-static inline const char* string_VkLineRasterizationModeKHR(VkLineRasterizationModeKHR input_value) {
-    switch (input_value) {
-        case VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR:
-            return "VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR";
-        case VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR:
-            return "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR";
-        case VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR:
-            return "VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR";
-        case VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR:
-            return "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR";
-        default:
-            return "Unhandled VkLineRasterizationModeKHR";
-    }
-}
 static inline const char* string_VkTimeDomainKHR(VkTimeDomainKHR input_value) {
     switch (input_value) {
         case VK_TIME_DOMAIN_DEVICE_KHR:
@@ -4148,34 +4180,6 @@ static inline const char* string_VkValidationCheckEXT(VkValidationCheckEXT input
             return "Unhandled VkValidationCheckEXT";
     }
 }
-static inline const char* string_VkPipelineRobustnessBufferBehaviorEXT(VkPipelineRobustnessBufferBehaviorEXT input_value) {
-    switch (input_value) {
-        case VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT_EXT:
-            return "VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT_EXT";
-        case VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT:
-            return "VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT";
-        case VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_EXT:
-            return "VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_EXT";
-        case VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT:
-            return "VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT";
-        default:
-            return "Unhandled VkPipelineRobustnessBufferBehaviorEXT";
-    }
-}
-static inline const char* string_VkPipelineRobustnessImageBehaviorEXT(VkPipelineRobustnessImageBehaviorEXT input_value) {
-    switch (input_value) {
-        case VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT_EXT:
-            return "VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT_EXT";
-        case VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED_EXT:
-            return "VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED_EXT";
-        case VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_EXT:
-            return "VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_EXT";
-        case VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2_EXT:
-            return "VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2_EXT";
-        default:
-            return "Unhandled VkPipelineRobustnessImageBehaviorEXT";
-    }
-}
 static inline const char* string_VkDisplayPowerStateEXT(VkDisplayPowerStateEXT input_value) {
     switch (input_value) {
         case VK_DISPLAY_POWER_STATE_OFF_EXT:
@@ -5412,6 +5416,8 @@ static inline const char* string_VkImageUsageFlagBits(VkImageUsageFlagBits input
             return "VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT";
         case VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT:
             return "VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT";
+        case VK_IMAGE_USAGE_HOST_TRANSFER_BIT:
+            return "VK_IMAGE_USAGE_HOST_TRANSFER_BIT";
         case VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR:
             return "VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR";
         case VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR:
@@ -5422,8 +5428,6 @@ static inline const char* string_VkImageUsageFlagBits(VkImageUsageFlagBits input
             return "VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT";
         case VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR:
             return "VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR";
-        case VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT:
-            return "VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT";
         case VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR:
             return "VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR";
         case VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR:
@@ -6125,6 +6129,10 @@ static inline const char* string_VkPipelineCreateFlagBits(VkPipelineCreateFlagBi
             return "VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT";
         case VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT:
             return "VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT";
+        case VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT:
+            return "VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT";
+        case VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT:
+            return "VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT";
         case VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR:
             return "VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR";
         case VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR:
@@ -6171,10 +6179,6 @@ static inline const char* string_VkPipelineCreateFlagBits(VkPipelineCreateFlagBi
         case VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV:
             return "VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV";
 #endif  // VK_ENABLE_BETA_EXTENSIONS
-        case VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT:
-            return "VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT";
-        case VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT:
-            return "VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT";
         default:
             return "Unhandled VkPipelineCreateFlagBits";
     }
@@ -6457,8 +6461,8 @@ static inline const char* string_VkDescriptorSetLayoutCreateFlagBits(VkDescripto
     switch (input_value) {
         case VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT:
             return "VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT";
-        case VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR:
-            return "VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR";
+        case VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT:
+            return "VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT";
         case VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT:
             return "VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT";
         case VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT:
@@ -6814,12 +6818,12 @@ static inline const char* string_VkSubgroupFeatureFlagBits(VkSubgroupFeatureFlag
             return "VK_SUBGROUP_FEATURE_CLUSTERED_BIT";
         case VK_SUBGROUP_FEATURE_QUAD_BIT:
             return "VK_SUBGROUP_FEATURE_QUAD_BIT";
+        case VK_SUBGROUP_FEATURE_ROTATE_BIT:
+            return "VK_SUBGROUP_FEATURE_ROTATE_BIT";
+        case VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT:
+            return "VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT";
         case VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV:
             return "VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV";
-        case VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR:
-            return "VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR";
-        case VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR:
-            return "VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR";
         default:
             return "Unhandled VkSubgroupFeatureFlagBits";
     }
@@ -7505,7 +7509,6 @@ static inline const char* string_VkFormatFeatureFlagBits2(uint64_t input_value)
     if (input_value == VK_FORMAT_FEATURE_2_BLIT_SRC_BIT) return "VK_FORMAT_FEATURE_2_BLIT_SRC_BIT";
     if (input_value == VK_FORMAT_FEATURE_2_BLIT_DST_BIT) return "VK_FORMAT_FEATURE_2_BLIT_DST_BIT";
     if (input_value == VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT) return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT";
-    if (input_value == VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT) return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT";
     if (input_value == VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT) return "VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT";
     if (input_value == VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT) return "VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT";
     if (input_value == VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT) return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT";
@@ -7519,12 +7522,13 @@ static inline const char* string_VkFormatFeatureFlagBits2(uint64_t input_value)
     if (input_value == VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT) return "VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT";
     if (input_value == VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT) return "VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT";
     if (input_value == VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT) return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT";
+    if (input_value == VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT) return "VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT";
+    if (input_value == VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT) return "VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT";
     if (input_value == VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR) return "VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR";
     if (input_value == VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR) return "VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR";
     if (input_value == VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR) return "VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR";
     if (input_value == VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT) return "VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT";
     if (input_value == VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR) return "VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR";
-    if (input_value == VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT) return "VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT";
     if (input_value == VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR) return "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR";
     if (input_value == VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR) return "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR";
     if (input_value == VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV) return "VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV";
@@ -7556,6 +7560,162 @@ static inline std::string string_VkFormatFeatureFlags2(VkFormatFeatureFlags2 inp
     return ret;
 }
 #endif // __cplusplus
+static inline const char* string_VkMemoryUnmapFlagBits(VkMemoryUnmapFlagBits input_value) {
+    switch (input_value) {
+        case VK_MEMORY_UNMAP_RESERVE_BIT_EXT:
+            return "VK_MEMORY_UNMAP_RESERVE_BIT_EXT";
+        default:
+            return "Unhandled VkMemoryUnmapFlagBits";
+    }
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkMemoryUnmapFlags(VkMemoryUnmapFlags input_value) {
+    std::string ret;
+    int index = 0;
+    while(input_value) {
+        if (input_value & 1) {
+            if( !ret.empty()) ret.append("|");
+            ret.append(string_VkMemoryUnmapFlagBits(static_cast<VkMemoryUnmapFlagBits>(1U << index)));
+        }
+        ++index;
+        input_value >>= 1;
+    }
+    if (ret.empty()) ret.append("VkMemoryUnmapFlags(0)");
+    return ret;
+}
+#endif // __cplusplus
+static inline const char* string_VkPipelineCreateFlagBits2(uint64_t input_value) {
+    if (input_value == VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT) return "VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT";
+    if (input_value == VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT) return "VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT";
+    if (input_value == VK_PIPELINE_CREATE_2_DERIVATIVE_BIT) return "VK_PIPELINE_CREATE_2_DERIVATIVE_BIT";
+    if (input_value == VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT) return "VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT";
+    if (input_value == VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT) return "VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT";
+    if (input_value == VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT) return "VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT";
+    if (input_value == VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT) return "VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT";
+    if (input_value == VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT) return "VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT";
+    if (input_value == VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT) return "VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT";
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    if (input_value == VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX) return "VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX";
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+    if (input_value == VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT) return "VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT";
+    if (input_value == VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV) return "VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV";
+    if (input_value == VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR) return "VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR";
+    if (input_value == VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR) return "VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR";
+    if (input_value == VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT) return "VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT";
+    if (input_value == VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT) return "VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT";
+    if (input_value == VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR) return "VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR";
+    if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR) return "VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR";
+    if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR) return "VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR";
+    if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR) return "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR";
+    if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR) return "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR";
+    if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR) return "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR";
+    if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR) return "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR";
+    if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR) return "VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR";
+    if (input_value == VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV) return "VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV";
+    if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV) return "VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV";
+    if (input_value == VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR) return "VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR";
+    if (input_value == VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT) return "VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT";
+    if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT) return "VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT";
+    if (input_value == VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT) return "VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT";
+    if (input_value == VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT) return "VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT";
+    if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV) return "VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV";
+    if (input_value == VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT) return "VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT";
+    if (input_value == VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR) return "VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR";
+    if (input_value == VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT) return "VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT";
+    return "Unhandled VkPipelineCreateFlagBits2";
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkPipelineCreateFlags2(VkPipelineCreateFlags2 input_value) {
+    std::string ret;
+    int index = 0;
+    while(input_value) {
+        if (input_value & 1) {
+            if( !ret.empty()) ret.append("|");
+            ret.append(string_VkPipelineCreateFlagBits2(static_cast<uint64_t>(1ULL << index)));
+        }
+        ++index;
+        input_value >>= 1;
+    }
+    if (ret.empty()) ret.append("VkPipelineCreateFlags2(0)");
+    return ret;
+}
+#endif // __cplusplus
+static inline const char* string_VkBufferUsageFlagBits2(uint64_t input_value) {
+    if (input_value == VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT) return "VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT";
+    if (input_value == VK_BUFFER_USAGE_2_TRANSFER_DST_BIT) return "VK_BUFFER_USAGE_2_TRANSFER_DST_BIT";
+    if (input_value == VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT) return "VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT";
+    if (input_value == VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT) return "VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT";
+    if (input_value == VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT) return "VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT";
+    if (input_value == VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT) return "VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT";
+    if (input_value == VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT) return "VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT";
+    if (input_value == VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT) return "VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT";
+    if (input_value == VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT) return "VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT";
+    if (input_value == VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT) return "VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT";
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+    if (input_value == VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX) return "VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX";
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+    if (input_value == VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT) return "VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT";
+    if (input_value == VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR) return "VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR";
+    if (input_value == VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT";
+    if (input_value == VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT";
+    if (input_value == VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR) return "VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR";
+    if (input_value == VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR) return "VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR";
+    if (input_value == VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR) return "VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR";
+    if (input_value == VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR) return "VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR";
+    if (input_value == VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR) return "VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR";
+    if (input_value == VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR) return "VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR";
+    if (input_value == VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT";
+    if (input_value == VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT";
+    if (input_value == VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT";
+    if (input_value == VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT) return "VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT";
+    if (input_value == VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT) return "VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT";
+    if (input_value == VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT";
+    return "Unhandled VkBufferUsageFlagBits2";
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkBufferUsageFlags2(VkBufferUsageFlags2 input_value) {
+    std::string ret;
+    int index = 0;
+    while(input_value) {
+        if (input_value & 1) {
+            if( !ret.empty()) ret.append("|");
+            ret.append(string_VkBufferUsageFlagBits2(static_cast<uint64_t>(1ULL << index)));
+        }
+        ++index;
+        input_value >>= 1;
+    }
+    if (ret.empty()) ret.append("VkBufferUsageFlags2(0)");
+    return ret;
+}
+#endif // __cplusplus
+static inline const char* string_VkHostImageCopyFlagBits(VkHostImageCopyFlagBits input_value) {
+    switch (input_value) {
+        case VK_HOST_IMAGE_COPY_MEMCPY:
+            return "VK_HOST_IMAGE_COPY_MEMCPY";
+        default:
+            return "Unhandled VkHostImageCopyFlagBits";
+    }
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkHostImageCopyFlags(VkHostImageCopyFlags input_value) {
+    std::string ret;
+    int index = 0;
+    while(input_value) {
+        if (input_value & 1) {
+            if( !ret.empty()) ret.append("|");
+            ret.append(string_VkHostImageCopyFlagBits(static_cast<VkHostImageCopyFlagBits>(1U << index)));
+        }
+        ++index;
+        input_value >>= 1;
+    }
+    if (ret.empty()) ret.append("VkHostImageCopyFlags(0)");
+    return ret;
+}
+#endif // __cplusplus
 static inline const char* string_VkSurfaceTransformFlagBitsKHR(VkSurfaceTransformFlagBitsKHR input_value) {
     switch (input_value) {
         case VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR:
@@ -8392,31 +8552,6 @@ static inline std::string string_VkPerformanceCounterDescriptionFlagsKHR(VkPerfo
     return ret;
 }
 #endif // __cplusplus
-static inline const char* string_VkMemoryUnmapFlagBitsKHR(VkMemoryUnmapFlagBitsKHR input_value) {
-    switch (input_value) {
-        case VK_MEMORY_UNMAP_RESERVE_BIT_EXT:
-            return "VK_MEMORY_UNMAP_RESERVE_BIT_EXT";
-        default:
-            return "Unhandled VkMemoryUnmapFlagBitsKHR";
-    }
-}
-
-#ifdef __cplusplus
-static inline std::string string_VkMemoryUnmapFlagsKHR(VkMemoryUnmapFlagsKHR input_value) {
-    std::string ret;
-    int index = 0;
-    while(input_value) {
-        if (input_value & 1) {
-            if( !ret.empty()) ret.append("|");
-            ret.append(string_VkMemoryUnmapFlagBitsKHR(static_cast<VkMemoryUnmapFlagBitsKHR>(1U << index)));
-        }
-        ++index;
-        input_value >>= 1;
-    }
-    if (ret.empty()) ret.append("VkMemoryUnmapFlagsKHR(0)");
-    return ret;
-}
-#endif // __cplusplus
 static inline const char* string_VkVideoEncodeFlagBitsKHR(VkVideoEncodeFlagBitsKHR input_value) {
     switch (input_value) {
         case VK_VIDEO_ENCODE_WITH_QUANTIZATION_DELTA_MAP_BIT_KHR:
@@ -8599,112 +8734,6 @@ static inline std::string string_VkVideoEncodeContentFlagsKHR(VkVideoEncodeConte
     return ret;
 }
 #endif // __cplusplus
-static inline const char* string_VkPipelineCreateFlagBits2KHR(uint64_t input_value) {
-    if (input_value == VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR) return "VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR";
-    if (input_value == VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR) return "VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR";
-    if (input_value == VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR) return "VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR";
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    if (input_value == VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX) return "VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX";
-#endif  // VK_ENABLE_BETA_EXTENSIONS
-    if (input_value == VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT) return "VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT";
-    if (input_value == VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR) return "VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR";
-    if (input_value == VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR) return "VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR";
-    if (input_value == VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV) return "VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV";
-    if (input_value == VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR) return "VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR";
-    if (input_value == VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR) return "VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR";
-    if (input_value == VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_KHR) return "VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_KHR";
-    if (input_value == VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT_KHR) return "VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT_KHR";
-    if (input_value == VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT) return "VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT";
-    if (input_value == VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT) return "VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT";
-    if (input_value == VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR) return "VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR";
-    if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR) return "VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR";
-    if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR) return "VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR";
-    if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR) return "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR";
-    if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR) return "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR";
-    if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR) return "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR";
-    if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR) return "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR";
-    if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR) return "VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR";
-    if (input_value == VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV) return "VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV";
-    if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV) return "VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV";
-    if (input_value == VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR) return "VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR";
-    if (input_value == VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT) return "VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT";
-    if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT) return "VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT";
-    if (input_value == VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT) return "VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT";
-    if (input_value == VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT) return "VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT";
-    if (input_value == VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT) return "VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT";
-    if (input_value == VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT) return "VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT";
-    if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV) return "VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV";
-    if (input_value == VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT) return "VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT";
-    if (input_value == VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR) return "VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR";
-    if (input_value == VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT) return "VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT";
-    return "Unhandled VkPipelineCreateFlagBits2KHR";
-}
-
-#ifdef __cplusplus
-static inline std::string string_VkPipelineCreateFlags2KHR(VkPipelineCreateFlags2KHR input_value) {
-    std::string ret;
-    int index = 0;
-    while(input_value) {
-        if (input_value & 1) {
-            if( !ret.empty()) ret.append("|");
-            ret.append(string_VkPipelineCreateFlagBits2KHR(static_cast<uint64_t>(1ULL << index)));
-        }
-        ++index;
-        input_value >>= 1;
-    }
-    if (ret.empty()) ret.append("VkPipelineCreateFlags2KHR(0)");
-    return ret;
-}
-#endif // __cplusplus
-static inline const char* string_VkBufferUsageFlagBits2KHR(uint64_t input_value) {
-    if (input_value == VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT_KHR) return "VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT_KHR";
-    if (input_value == VK_BUFFER_USAGE_2_TRANSFER_DST_BIT_KHR) return "VK_BUFFER_USAGE_2_TRANSFER_DST_BIT_KHR";
-    if (input_value == VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR) return "VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR";
-    if (input_value == VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT_KHR) return "VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT_KHR";
-    if (input_value == VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT_KHR) return "VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT_KHR";
-    if (input_value == VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT_KHR) return "VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT_KHR";
-    if (input_value == VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT_KHR) return "VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT_KHR";
-    if (input_value == VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT_KHR) return "VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT_KHR";
-    if (input_value == VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT_KHR) return "VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT_KHR";
-#ifdef VK_ENABLE_BETA_EXTENSIONS
-    if (input_value == VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX) return "VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX";
-#endif  // VK_ENABLE_BETA_EXTENSIONS
-    if (input_value == VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT) return "VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT";
-    if (input_value == VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR) return "VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR";
-    if (input_value == VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT";
-    if (input_value == VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT";
-    if (input_value == VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR) return "VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR";
-    if (input_value == VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR) return "VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR";
-    if (input_value == VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR) return "VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR";
-    if (input_value == VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR) return "VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR";
-    if (input_value == VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT_KHR) return "VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT_KHR";
-    if (input_value == VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR) return "VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR";
-    if (input_value == VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR) return "VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR";
-    if (input_value == VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT";
-    if (input_value == VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT";
-    if (input_value == VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT";
-    if (input_value == VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT) return "VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT";
-    if (input_value == VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT) return "VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT";
-    if (input_value == VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT";
-    return "Unhandled VkBufferUsageFlagBits2KHR";
-}
-
-#ifdef __cplusplus
-static inline std::string string_VkBufferUsageFlags2KHR(VkBufferUsageFlags2KHR input_value) {
-    std::string ret;
-    int index = 0;
-    while(input_value) {
-        if (input_value & 1) {
-            if( !ret.empty()) ret.append("|");
-            ret.append(string_VkBufferUsageFlagBits2KHR(static_cast<uint64_t>(1ULL << index)));
-        }
-        ++index;
-        input_value >>= 1;
-    }
-    if (ret.empty()) ret.append("VkBufferUsageFlags2KHR(0)");
-    return ret;
-}
-#endif // __cplusplus
 static inline const char* string_VkVideoEncodeAV1CapabilityFlagBitsKHR(VkVideoEncodeAV1CapabilityFlagBitsKHR input_value) {
     switch (input_value) {
         case VK_VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR:
@@ -9141,31 +9170,6 @@ static inline std::string string_VkBuildAccelerationStructureFlagsKHR(VkBuildAcc
     return ret;
 }
 #endif // __cplusplus
-static inline const char* string_VkHostImageCopyFlagBitsEXT(VkHostImageCopyFlagBitsEXT input_value) {
-    switch (input_value) {
-        case VK_HOST_IMAGE_COPY_MEMCPY_EXT:
-            return "VK_HOST_IMAGE_COPY_MEMCPY_EXT";
-        default:
-            return "Unhandled VkHostImageCopyFlagBitsEXT";
-    }
-}
-
-#ifdef __cplusplus
-static inline std::string string_VkHostImageCopyFlagsEXT(VkHostImageCopyFlagsEXT input_value) {
-    std::string ret;
-    int index = 0;
-    while(input_value) {
-        if (input_value & 1) {
-            if( !ret.empty()) ret.append("|");
-            ret.append(string_VkHostImageCopyFlagBitsEXT(static_cast<VkHostImageCopyFlagBitsEXT>(1U << index)));
-        }
-        ++index;
-        input_value >>= 1;
-    }
-    if (ret.empty()) ret.append("VkHostImageCopyFlagsEXT(0)");
-    return ret;
-}
-#endif // __cplusplus
 static inline const char* string_VkPresentScalingFlagBitsEXT(VkPresentScalingFlagBitsEXT input_value) {
     switch (input_value) {
         case VK_PRESENT_SCALING_ONE_TO_ONE_BIT_EXT:
diff --git a/scripts/generators/safe_struct_generator.py b/scripts/generators/safe_struct_generator.py
index e7d8086..282115e 100644
--- a/scripts/generators/safe_struct_generator.py
+++ b/scripts/generators/safe_struct_generator.py
@@ -487,9 +487,9 @@ void FreePnextChain(const void *pNext) {
                         }
                     }
                 ''',
-                # TODO: VkPushDescriptorSetWithTemplateInfoKHR needs a custom constructor to handle pData
-                # https://github.com/KhronosGroup/Vulkan-ValidationLayers/issues/7169
-                'VkPushDescriptorSetWithTemplateInfoKHR': '''
+                # TODO: VkPushDescriptorSetWithTemplateInfo needs a custom constructor to handle pData
+                # https://github.com/KhronosGroup/Vulkan-Utility-Libraries/issues/193
+                'VkPushDescriptorSetWithTemplateInfo': '''
                 ''',
             }
 
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 07e048e..5de8cec 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.3.302"
+            "commit": "v1.4.303"
         },
         {
             "name": "googletest",
diff --git a/src/vulkan/vk_safe_struct_core.cpp b/src/vulkan/vk_safe_struct_core.cpp
index 21e9108..f99de19 100644
--- a/src/vulkan/vk_safe_struct_core.cpp
+++ b/src/vulkan/vk_safe_struct_core.cpp
@@ -18768,6 +18768,3820 @@ void safe_VkDeviceImageMemoryRequirements::initialize(const safe_VkDeviceImageMe
     if (copy_src->pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(*copy_src->pCreateInfo);
 }
 
+safe_VkPhysicalDeviceVulkan14Features::safe_VkPhysicalDeviceVulkan14Features(const VkPhysicalDeviceVulkan14Features* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType),
+      globalPriorityQuery(in_struct->globalPriorityQuery),
+      shaderSubgroupRotate(in_struct->shaderSubgroupRotate),
+      shaderSubgroupRotateClustered(in_struct->shaderSubgroupRotateClustered),
+      shaderFloatControls2(in_struct->shaderFloatControls2),
+      shaderExpectAssume(in_struct->shaderExpectAssume),
+      rectangularLines(in_struct->rectangularLines),
+      bresenhamLines(in_struct->bresenhamLines),
+      smoothLines(in_struct->smoothLines),
+      stippledRectangularLines(in_struct->stippledRectangularLines),
+      stippledBresenhamLines(in_struct->stippledBresenhamLines),
+      stippledSmoothLines(in_struct->stippledSmoothLines),
+      vertexAttributeInstanceRateDivisor(in_struct->vertexAttributeInstanceRateDivisor),
+      vertexAttributeInstanceRateZeroDivisor(in_struct->vertexAttributeInstanceRateZeroDivisor),
+      indexTypeUint8(in_struct->indexTypeUint8),
+      dynamicRenderingLocalRead(in_struct->dynamicRenderingLocalRead),
+      maintenance5(in_struct->maintenance5),
+      maintenance6(in_struct->maintenance6),
+      pipelineProtectedAccess(in_struct->pipelineProtectedAccess),
+      pipelineRobustness(in_struct->pipelineRobustness),
+      hostImageCopy(in_struct->hostImageCopy),
+      pushDescriptor(in_struct->pushDescriptor) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceVulkan14Features::safe_VkPhysicalDeviceVulkan14Features()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES),
+      pNext(nullptr),
+      globalPriorityQuery(),
+      shaderSubgroupRotate(),
+      shaderSubgroupRotateClustered(),
+      shaderFloatControls2(),
+      shaderExpectAssume(),
+      rectangularLines(),
+      bresenhamLines(),
+      smoothLines(),
+      stippledRectangularLines(),
+      stippledBresenhamLines(),
+      stippledSmoothLines(),
+      vertexAttributeInstanceRateDivisor(),
+      vertexAttributeInstanceRateZeroDivisor(),
+      indexTypeUint8(),
+      dynamicRenderingLocalRead(),
+      maintenance5(),
+      maintenance6(),
+      pipelineProtectedAccess(),
+      pipelineRobustness(),
+      hostImageCopy(),
+      pushDescriptor() {}
+
+safe_VkPhysicalDeviceVulkan14Features::safe_VkPhysicalDeviceVulkan14Features(
+    const safe_VkPhysicalDeviceVulkan14Features& copy_src) {
+    sType = copy_src.sType;
+    globalPriorityQuery = copy_src.globalPriorityQuery;
+    shaderSubgroupRotate = copy_src.shaderSubgroupRotate;
+    shaderSubgroupRotateClustered = copy_src.shaderSubgroupRotateClustered;
+    shaderFloatControls2 = copy_src.shaderFloatControls2;
+    shaderExpectAssume = copy_src.shaderExpectAssume;
+    rectangularLines = copy_src.rectangularLines;
+    bresenhamLines = copy_src.bresenhamLines;
+    smoothLines = copy_src.smoothLines;
+    stippledRectangularLines = copy_src.stippledRectangularLines;
+    stippledBresenhamLines = copy_src.stippledBresenhamLines;
+    stippledSmoothLines = copy_src.stippledSmoothLines;
+    vertexAttributeInstanceRateDivisor = copy_src.vertexAttributeInstanceRateDivisor;
+    vertexAttributeInstanceRateZeroDivisor = copy_src.vertexAttributeInstanceRateZeroDivisor;
+    indexTypeUint8 = copy_src.indexTypeUint8;
+    dynamicRenderingLocalRead = copy_src.dynamicRenderingLocalRead;
+    maintenance5 = copy_src.maintenance5;
+    maintenance6 = copy_src.maintenance6;
+    pipelineProtectedAccess = copy_src.pipelineProtectedAccess;
+    pipelineRobustness = copy_src.pipelineRobustness;
+    hostImageCopy = copy_src.hostImageCopy;
+    pushDescriptor = copy_src.pushDescriptor;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceVulkan14Features& safe_VkPhysicalDeviceVulkan14Features::operator=(
+    const safe_VkPhysicalDeviceVulkan14Features& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    globalPriorityQuery = copy_src.globalPriorityQuery;
+    shaderSubgroupRotate = copy_src.shaderSubgroupRotate;
+    shaderSubgroupRotateClustered = copy_src.shaderSubgroupRotateClustered;
+    shaderFloatControls2 = copy_src.shaderFloatControls2;
+    shaderExpectAssume = copy_src.shaderExpectAssume;
+    rectangularLines = copy_src.rectangularLines;
+    bresenhamLines = copy_src.bresenhamLines;
+    smoothLines = copy_src.smoothLines;
+    stippledRectangularLines = copy_src.stippledRectangularLines;
+    stippledBresenhamLines = copy_src.stippledBresenhamLines;
+    stippledSmoothLines = copy_src.stippledSmoothLines;
+    vertexAttributeInstanceRateDivisor = copy_src.vertexAttributeInstanceRateDivisor;
+    vertexAttributeInstanceRateZeroDivisor = copy_src.vertexAttributeInstanceRateZeroDivisor;
+    indexTypeUint8 = copy_src.indexTypeUint8;
+    dynamicRenderingLocalRead = copy_src.dynamicRenderingLocalRead;
+    maintenance5 = copy_src.maintenance5;
+    maintenance6 = copy_src.maintenance6;
+    pipelineProtectedAccess = copy_src.pipelineProtectedAccess;
+    pipelineRobustness = copy_src.pipelineRobustness;
+    hostImageCopy = copy_src.hostImageCopy;
+    pushDescriptor = copy_src.pushDescriptor;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceVulkan14Features::~safe_VkPhysicalDeviceVulkan14Features() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceVulkan14Features::initialize(const VkPhysicalDeviceVulkan14Features* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    globalPriorityQuery = in_struct->globalPriorityQuery;
+    shaderSubgroupRotate = in_struct->shaderSubgroupRotate;
+    shaderSubgroupRotateClustered = in_struct->shaderSubgroupRotateClustered;
+    shaderFloatControls2 = in_struct->shaderFloatControls2;
+    shaderExpectAssume = in_struct->shaderExpectAssume;
+    rectangularLines = in_struct->rectangularLines;
+    bresenhamLines = in_struct->bresenhamLines;
+    smoothLines = in_struct->smoothLines;
+    stippledRectangularLines = in_struct->stippledRectangularLines;
+    stippledBresenhamLines = in_struct->stippledBresenhamLines;
+    stippledSmoothLines = in_struct->stippledSmoothLines;
+    vertexAttributeInstanceRateDivisor = in_struct->vertexAttributeInstanceRateDivisor;
+    vertexAttributeInstanceRateZeroDivisor = in_struct->vertexAttributeInstanceRateZeroDivisor;
+    indexTypeUint8 = in_struct->indexTypeUint8;
+    dynamicRenderingLocalRead = in_struct->dynamicRenderingLocalRead;
+    maintenance5 = in_struct->maintenance5;
+    maintenance6 = in_struct->maintenance6;
+    pipelineProtectedAccess = in_struct->pipelineProtectedAccess;
+    pipelineRobustness = in_struct->pipelineRobustness;
+    hostImageCopy = in_struct->hostImageCopy;
+    pushDescriptor = in_struct->pushDescriptor;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceVulkan14Features::initialize(const safe_VkPhysicalDeviceVulkan14Features* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    globalPriorityQuery = copy_src->globalPriorityQuery;
+    shaderSubgroupRotate = copy_src->shaderSubgroupRotate;
+    shaderSubgroupRotateClustered = copy_src->shaderSubgroupRotateClustered;
+    shaderFloatControls2 = copy_src->shaderFloatControls2;
+    shaderExpectAssume = copy_src->shaderExpectAssume;
+    rectangularLines = copy_src->rectangularLines;
+    bresenhamLines = copy_src->bresenhamLines;
+    smoothLines = copy_src->smoothLines;
+    stippledRectangularLines = copy_src->stippledRectangularLines;
+    stippledBresenhamLines = copy_src->stippledBresenhamLines;
+    stippledSmoothLines = copy_src->stippledSmoothLines;
+    vertexAttributeInstanceRateDivisor = copy_src->vertexAttributeInstanceRateDivisor;
+    vertexAttributeInstanceRateZeroDivisor = copy_src->vertexAttributeInstanceRateZeroDivisor;
+    indexTypeUint8 = copy_src->indexTypeUint8;
+    dynamicRenderingLocalRead = copy_src->dynamicRenderingLocalRead;
+    maintenance5 = copy_src->maintenance5;
+    maintenance6 = copy_src->maintenance6;
+    pipelineProtectedAccess = copy_src->pipelineProtectedAccess;
+    pipelineRobustness = copy_src->pipelineRobustness;
+    hostImageCopy = copy_src->hostImageCopy;
+    pushDescriptor = copy_src->pushDescriptor;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceVulkan14Properties::safe_VkPhysicalDeviceVulkan14Properties(
+    const VkPhysicalDeviceVulkan14Properties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      lineSubPixelPrecisionBits(in_struct->lineSubPixelPrecisionBits),
+      maxVertexAttribDivisor(in_struct->maxVertexAttribDivisor),
+      supportsNonZeroFirstInstance(in_struct->supportsNonZeroFirstInstance),
+      maxPushDescriptors(in_struct->maxPushDescriptors),
+      dynamicRenderingLocalReadDepthStencilAttachments(in_struct->dynamicRenderingLocalReadDepthStencilAttachments),
+      dynamicRenderingLocalReadMultisampledAttachments(in_struct->dynamicRenderingLocalReadMultisampledAttachments),
+      earlyFragmentMultisampleCoverageAfterSampleCounting(in_struct->earlyFragmentMultisampleCoverageAfterSampleCounting),
+      earlyFragmentSampleMaskTestBeforeSampleCounting(in_struct->earlyFragmentSampleMaskTestBeforeSampleCounting),
+      depthStencilSwizzleOneSupport(in_struct->depthStencilSwizzleOneSupport),
+      polygonModePointSize(in_struct->polygonModePointSize),
+      nonStrictSinglePixelWideLinesUseParallelogram(in_struct->nonStrictSinglePixelWideLinesUseParallelogram),
+      nonStrictWideLinesUseParallelogram(in_struct->nonStrictWideLinesUseParallelogram),
+      blockTexelViewCompatibleMultipleLayers(in_struct->blockTexelViewCompatibleMultipleLayers),
+      maxCombinedImageSamplerDescriptorCount(in_struct->maxCombinedImageSamplerDescriptorCount),
+      fragmentShadingRateClampCombinerInputs(in_struct->fragmentShadingRateClampCombinerInputs),
+      defaultRobustnessStorageBuffers(in_struct->defaultRobustnessStorageBuffers),
+      defaultRobustnessUniformBuffers(in_struct->defaultRobustnessUniformBuffers),
+      defaultRobustnessVertexInputs(in_struct->defaultRobustnessVertexInputs),
+      defaultRobustnessImages(in_struct->defaultRobustnessImages),
+      copySrcLayoutCount(in_struct->copySrcLayoutCount),
+      pCopySrcLayouts(nullptr),
+      copyDstLayoutCount(in_struct->copyDstLayoutCount),
+      pCopyDstLayouts(nullptr),
+      identicalMemoryTypeRequirements(in_struct->identicalMemoryTypeRequirements) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pCopySrcLayouts) {
+        pCopySrcLayouts = new VkImageLayout[in_struct->copySrcLayoutCount];
+        memcpy((void*)pCopySrcLayouts, (void*)in_struct->pCopySrcLayouts, sizeof(VkImageLayout) * in_struct->copySrcLayoutCount);
+    }
+
+    if (in_struct->pCopyDstLayouts) {
+        pCopyDstLayouts = new VkImageLayout[in_struct->copyDstLayoutCount];
+        memcpy((void*)pCopyDstLayouts, (void*)in_struct->pCopyDstLayouts, sizeof(VkImageLayout) * in_struct->copyDstLayoutCount);
+    }
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        optimalTilingLayoutUUID[i] = in_struct->optimalTilingLayoutUUID[i];
+    }
+}
+
+safe_VkPhysicalDeviceVulkan14Properties::safe_VkPhysicalDeviceVulkan14Properties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES),
+      pNext(nullptr),
+      lineSubPixelPrecisionBits(),
+      maxVertexAttribDivisor(),
+      supportsNonZeroFirstInstance(),
+      maxPushDescriptors(),
+      dynamicRenderingLocalReadDepthStencilAttachments(),
+      dynamicRenderingLocalReadMultisampledAttachments(),
+      earlyFragmentMultisampleCoverageAfterSampleCounting(),
+      earlyFragmentSampleMaskTestBeforeSampleCounting(),
+      depthStencilSwizzleOneSupport(),
+      polygonModePointSize(),
+      nonStrictSinglePixelWideLinesUseParallelogram(),
+      nonStrictWideLinesUseParallelogram(),
+      blockTexelViewCompatibleMultipleLayers(),
+      maxCombinedImageSamplerDescriptorCount(),
+      fragmentShadingRateClampCombinerInputs(),
+      defaultRobustnessStorageBuffers(),
+      defaultRobustnessUniformBuffers(),
+      defaultRobustnessVertexInputs(),
+      defaultRobustnessImages(),
+      copySrcLayoutCount(),
+      pCopySrcLayouts(nullptr),
+      copyDstLayoutCount(),
+      pCopyDstLayouts(nullptr),
+      identicalMemoryTypeRequirements() {}
+
+safe_VkPhysicalDeviceVulkan14Properties::safe_VkPhysicalDeviceVulkan14Properties(
+    const safe_VkPhysicalDeviceVulkan14Properties& copy_src) {
+    sType = copy_src.sType;
+    lineSubPixelPrecisionBits = copy_src.lineSubPixelPrecisionBits;
+    maxVertexAttribDivisor = copy_src.maxVertexAttribDivisor;
+    supportsNonZeroFirstInstance = copy_src.supportsNonZeroFirstInstance;
+    maxPushDescriptors = copy_src.maxPushDescriptors;
+    dynamicRenderingLocalReadDepthStencilAttachments = copy_src.dynamicRenderingLocalReadDepthStencilAttachments;
+    dynamicRenderingLocalReadMultisampledAttachments = copy_src.dynamicRenderingLocalReadMultisampledAttachments;
+    earlyFragmentMultisampleCoverageAfterSampleCounting = copy_src.earlyFragmentMultisampleCoverageAfterSampleCounting;
+    earlyFragmentSampleMaskTestBeforeSampleCounting = copy_src.earlyFragmentSampleMaskTestBeforeSampleCounting;
+    depthStencilSwizzleOneSupport = copy_src.depthStencilSwizzleOneSupport;
+    polygonModePointSize = copy_src.polygonModePointSize;
+    nonStrictSinglePixelWideLinesUseParallelogram = copy_src.nonStrictSinglePixelWideLinesUseParallelogram;
+    nonStrictWideLinesUseParallelogram = copy_src.nonStrictWideLinesUseParallelogram;
+    blockTexelViewCompatibleMultipleLayers = copy_src.blockTexelViewCompatibleMultipleLayers;
+    maxCombinedImageSamplerDescriptorCount = copy_src.maxCombinedImageSamplerDescriptorCount;
+    fragmentShadingRateClampCombinerInputs = copy_src.fragmentShadingRateClampCombinerInputs;
+    defaultRobustnessStorageBuffers = copy_src.defaultRobustnessStorageBuffers;
+    defaultRobustnessUniformBuffers = copy_src.defaultRobustnessUniformBuffers;
+    defaultRobustnessVertexInputs = copy_src.defaultRobustnessVertexInputs;
+    defaultRobustnessImages = copy_src.defaultRobustnessImages;
+    copySrcLayoutCount = copy_src.copySrcLayoutCount;
+    pCopySrcLayouts = nullptr;
+    copyDstLayoutCount = copy_src.copyDstLayoutCount;
+    pCopyDstLayouts = nullptr;
+    identicalMemoryTypeRequirements = copy_src.identicalMemoryTypeRequirements;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pCopySrcLayouts) {
+        pCopySrcLayouts = new VkImageLayout[copy_src.copySrcLayoutCount];
+        memcpy((void*)pCopySrcLayouts, (void*)copy_src.pCopySrcLayouts, sizeof(VkImageLayout) * copy_src.copySrcLayoutCount);
+    }
+
+    if (copy_src.pCopyDstLayouts) {
+        pCopyDstLayouts = new VkImageLayout[copy_src.copyDstLayoutCount];
+        memcpy((void*)pCopyDstLayouts, (void*)copy_src.pCopyDstLayouts, sizeof(VkImageLayout) * copy_src.copyDstLayoutCount);
+    }
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        optimalTilingLayoutUUID[i] = copy_src.optimalTilingLayoutUUID[i];
+    }
+}
+
+safe_VkPhysicalDeviceVulkan14Properties& safe_VkPhysicalDeviceVulkan14Properties::operator=(
+    const safe_VkPhysicalDeviceVulkan14Properties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pCopySrcLayouts) delete[] pCopySrcLayouts;
+    if (pCopyDstLayouts) delete[] pCopyDstLayouts;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    lineSubPixelPrecisionBits = copy_src.lineSubPixelPrecisionBits;
+    maxVertexAttribDivisor = copy_src.maxVertexAttribDivisor;
+    supportsNonZeroFirstInstance = copy_src.supportsNonZeroFirstInstance;
+    maxPushDescriptors = copy_src.maxPushDescriptors;
+    dynamicRenderingLocalReadDepthStencilAttachments = copy_src.dynamicRenderingLocalReadDepthStencilAttachments;
+    dynamicRenderingLocalReadMultisampledAttachments = copy_src.dynamicRenderingLocalReadMultisampledAttachments;
+    earlyFragmentMultisampleCoverageAfterSampleCounting = copy_src.earlyFragmentMultisampleCoverageAfterSampleCounting;
+    earlyFragmentSampleMaskTestBeforeSampleCounting = copy_src.earlyFragmentSampleMaskTestBeforeSampleCounting;
+    depthStencilSwizzleOneSupport = copy_src.depthStencilSwizzleOneSupport;
+    polygonModePointSize = copy_src.polygonModePointSize;
+    nonStrictSinglePixelWideLinesUseParallelogram = copy_src.nonStrictSinglePixelWideLinesUseParallelogram;
+    nonStrictWideLinesUseParallelogram = copy_src.nonStrictWideLinesUseParallelogram;
+    blockTexelViewCompatibleMultipleLayers = copy_src.blockTexelViewCompatibleMultipleLayers;
+    maxCombinedImageSamplerDescriptorCount = copy_src.maxCombinedImageSamplerDescriptorCount;
+    fragmentShadingRateClampCombinerInputs = copy_src.fragmentShadingRateClampCombinerInputs;
+    defaultRobustnessStorageBuffers = copy_src.defaultRobustnessStorageBuffers;
+    defaultRobustnessUniformBuffers = copy_src.defaultRobustnessUniformBuffers;
+    defaultRobustnessVertexInputs = copy_src.defaultRobustnessVertexInputs;
+    defaultRobustnessImages = copy_src.defaultRobustnessImages;
+    copySrcLayoutCount = copy_src.copySrcLayoutCount;
+    pCopySrcLayouts = nullptr;
+    copyDstLayoutCount = copy_src.copyDstLayoutCount;
+    pCopyDstLayouts = nullptr;
+    identicalMemoryTypeRequirements = copy_src.identicalMemoryTypeRequirements;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pCopySrcLayouts) {
+        pCopySrcLayouts = new VkImageLayout[copy_src.copySrcLayoutCount];
+        memcpy((void*)pCopySrcLayouts, (void*)copy_src.pCopySrcLayouts, sizeof(VkImageLayout) * copy_src.copySrcLayoutCount);
+    }
+
+    if (copy_src.pCopyDstLayouts) {
+        pCopyDstLayouts = new VkImageLayout[copy_src.copyDstLayoutCount];
+        memcpy((void*)pCopyDstLayouts, (void*)copy_src.pCopyDstLayouts, sizeof(VkImageLayout) * copy_src.copyDstLayoutCount);
+    }
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        optimalTilingLayoutUUID[i] = copy_src.optimalTilingLayoutUUID[i];
+    }
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceVulkan14Properties::~safe_VkPhysicalDeviceVulkan14Properties() {
+    if (pCopySrcLayouts) delete[] pCopySrcLayouts;
+    if (pCopyDstLayouts) delete[] pCopyDstLayouts;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceVulkan14Properties::initialize(const VkPhysicalDeviceVulkan14Properties* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pCopySrcLayouts) delete[] pCopySrcLayouts;
+    if (pCopyDstLayouts) delete[] pCopyDstLayouts;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    lineSubPixelPrecisionBits = in_struct->lineSubPixelPrecisionBits;
+    maxVertexAttribDivisor = in_struct->maxVertexAttribDivisor;
+    supportsNonZeroFirstInstance = in_struct->supportsNonZeroFirstInstance;
+    maxPushDescriptors = in_struct->maxPushDescriptors;
+    dynamicRenderingLocalReadDepthStencilAttachments = in_struct->dynamicRenderingLocalReadDepthStencilAttachments;
+    dynamicRenderingLocalReadMultisampledAttachments = in_struct->dynamicRenderingLocalReadMultisampledAttachments;
+    earlyFragmentMultisampleCoverageAfterSampleCounting = in_struct->earlyFragmentMultisampleCoverageAfterSampleCounting;
+    earlyFragmentSampleMaskTestBeforeSampleCounting = in_struct->earlyFragmentSampleMaskTestBeforeSampleCounting;
+    depthStencilSwizzleOneSupport = in_struct->depthStencilSwizzleOneSupport;
+    polygonModePointSize = in_struct->polygonModePointSize;
+    nonStrictSinglePixelWideLinesUseParallelogram = in_struct->nonStrictSinglePixelWideLinesUseParallelogram;
+    nonStrictWideLinesUseParallelogram = in_struct->nonStrictWideLinesUseParallelogram;
+    blockTexelViewCompatibleMultipleLayers = in_struct->blockTexelViewCompatibleMultipleLayers;
+    maxCombinedImageSamplerDescriptorCount = in_struct->maxCombinedImageSamplerDescriptorCount;
+    fragmentShadingRateClampCombinerInputs = in_struct->fragmentShadingRateClampCombinerInputs;
+    defaultRobustnessStorageBuffers = in_struct->defaultRobustnessStorageBuffers;
+    defaultRobustnessUniformBuffers = in_struct->defaultRobustnessUniformBuffers;
+    defaultRobustnessVertexInputs = in_struct->defaultRobustnessVertexInputs;
+    defaultRobustnessImages = in_struct->defaultRobustnessImages;
+    copySrcLayoutCount = in_struct->copySrcLayoutCount;
+    pCopySrcLayouts = nullptr;
+    copyDstLayoutCount = in_struct->copyDstLayoutCount;
+    pCopyDstLayouts = nullptr;
+    identicalMemoryTypeRequirements = in_struct->identicalMemoryTypeRequirements;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pCopySrcLayouts) {
+        pCopySrcLayouts = new VkImageLayout[in_struct->copySrcLayoutCount];
+        memcpy((void*)pCopySrcLayouts, (void*)in_struct->pCopySrcLayouts, sizeof(VkImageLayout) * in_struct->copySrcLayoutCount);
+    }
+
+    if (in_struct->pCopyDstLayouts) {
+        pCopyDstLayouts = new VkImageLayout[in_struct->copyDstLayoutCount];
+        memcpy((void*)pCopyDstLayouts, (void*)in_struct->pCopyDstLayouts, sizeof(VkImageLayout) * in_struct->copyDstLayoutCount);
+    }
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        optimalTilingLayoutUUID[i] = in_struct->optimalTilingLayoutUUID[i];
+    }
+}
+
+void safe_VkPhysicalDeviceVulkan14Properties::initialize(const safe_VkPhysicalDeviceVulkan14Properties* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    lineSubPixelPrecisionBits = copy_src->lineSubPixelPrecisionBits;
+    maxVertexAttribDivisor = copy_src->maxVertexAttribDivisor;
+    supportsNonZeroFirstInstance = copy_src->supportsNonZeroFirstInstance;
+    maxPushDescriptors = copy_src->maxPushDescriptors;
+    dynamicRenderingLocalReadDepthStencilAttachments = copy_src->dynamicRenderingLocalReadDepthStencilAttachments;
+    dynamicRenderingLocalReadMultisampledAttachments = copy_src->dynamicRenderingLocalReadMultisampledAttachments;
+    earlyFragmentMultisampleCoverageAfterSampleCounting = copy_src->earlyFragmentMultisampleCoverageAfterSampleCounting;
+    earlyFragmentSampleMaskTestBeforeSampleCounting = copy_src->earlyFragmentSampleMaskTestBeforeSampleCounting;
+    depthStencilSwizzleOneSupport = copy_src->depthStencilSwizzleOneSupport;
+    polygonModePointSize = copy_src->polygonModePointSize;
+    nonStrictSinglePixelWideLinesUseParallelogram = copy_src->nonStrictSinglePixelWideLinesUseParallelogram;
+    nonStrictWideLinesUseParallelogram = copy_src->nonStrictWideLinesUseParallelogram;
+    blockTexelViewCompatibleMultipleLayers = copy_src->blockTexelViewCompatibleMultipleLayers;
+    maxCombinedImageSamplerDescriptorCount = copy_src->maxCombinedImageSamplerDescriptorCount;
+    fragmentShadingRateClampCombinerInputs = copy_src->fragmentShadingRateClampCombinerInputs;
+    defaultRobustnessStorageBuffers = copy_src->defaultRobustnessStorageBuffers;
+    defaultRobustnessUniformBuffers = copy_src->defaultRobustnessUniformBuffers;
+    defaultRobustnessVertexInputs = copy_src->defaultRobustnessVertexInputs;
+    defaultRobustnessImages = copy_src->defaultRobustnessImages;
+    copySrcLayoutCount = copy_src->copySrcLayoutCount;
+    pCopySrcLayouts = nullptr;
+    copyDstLayoutCount = copy_src->copyDstLayoutCount;
+    pCopyDstLayouts = nullptr;
+    identicalMemoryTypeRequirements = copy_src->identicalMemoryTypeRequirements;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pCopySrcLayouts) {
+        pCopySrcLayouts = new VkImageLayout[copy_src->copySrcLayoutCount];
+        memcpy((void*)pCopySrcLayouts, (void*)copy_src->pCopySrcLayouts, sizeof(VkImageLayout) * copy_src->copySrcLayoutCount);
+    }
+
+    if (copy_src->pCopyDstLayouts) {
+        pCopyDstLayouts = new VkImageLayout[copy_src->copyDstLayoutCount];
+        memcpy((void*)pCopyDstLayouts, (void*)copy_src->pCopyDstLayouts, sizeof(VkImageLayout) * copy_src->copyDstLayoutCount);
+    }
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        optimalTilingLayoutUUID[i] = copy_src->optimalTilingLayoutUUID[i];
+    }
+}
+
+safe_VkDeviceQueueGlobalPriorityCreateInfo::safe_VkDeviceQueueGlobalPriorityCreateInfo(
+    const VkDeviceQueueGlobalPriorityCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), globalPriority(in_struct->globalPriority) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDeviceQueueGlobalPriorityCreateInfo::safe_VkDeviceQueueGlobalPriorityCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO), pNext(nullptr), globalPriority() {}
+
+safe_VkDeviceQueueGlobalPriorityCreateInfo::safe_VkDeviceQueueGlobalPriorityCreateInfo(
+    const safe_VkDeviceQueueGlobalPriorityCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    globalPriority = copy_src.globalPriority;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDeviceQueueGlobalPriorityCreateInfo& safe_VkDeviceQueueGlobalPriorityCreateInfo::operator=(
+    const safe_VkDeviceQueueGlobalPriorityCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    globalPriority = copy_src.globalPriority;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDeviceQueueGlobalPriorityCreateInfo::~safe_VkDeviceQueueGlobalPriorityCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkDeviceQueueGlobalPriorityCreateInfo::initialize(const VkDeviceQueueGlobalPriorityCreateInfo* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    globalPriority = in_struct->globalPriority;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDeviceQueueGlobalPriorityCreateInfo::initialize(const safe_VkDeviceQueueGlobalPriorityCreateInfo* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    globalPriority = copy_src->globalPriority;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceGlobalPriorityQueryFeatures::safe_VkPhysicalDeviceGlobalPriorityQueryFeatures(
+    const VkPhysicalDeviceGlobalPriorityQueryFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), globalPriorityQuery(in_struct->globalPriorityQuery) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceGlobalPriorityQueryFeatures::safe_VkPhysicalDeviceGlobalPriorityQueryFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES), pNext(nullptr), globalPriorityQuery() {}
+
+safe_VkPhysicalDeviceGlobalPriorityQueryFeatures::safe_VkPhysicalDeviceGlobalPriorityQueryFeatures(
+    const safe_VkPhysicalDeviceGlobalPriorityQueryFeatures& copy_src) {
+    sType = copy_src.sType;
+    globalPriorityQuery = copy_src.globalPriorityQuery;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceGlobalPriorityQueryFeatures& safe_VkPhysicalDeviceGlobalPriorityQueryFeatures::operator=(
+    const safe_VkPhysicalDeviceGlobalPriorityQueryFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    globalPriorityQuery = copy_src.globalPriorityQuery;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceGlobalPriorityQueryFeatures::~safe_VkPhysicalDeviceGlobalPriorityQueryFeatures() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceGlobalPriorityQueryFeatures::initialize(const VkPhysicalDeviceGlobalPriorityQueryFeatures* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    globalPriorityQuery = in_struct->globalPriorityQuery;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceGlobalPriorityQueryFeatures::initialize(const safe_VkPhysicalDeviceGlobalPriorityQueryFeatures* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    globalPriorityQuery = copy_src->globalPriorityQuery;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkQueueFamilyGlobalPriorityProperties::safe_VkQueueFamilyGlobalPriorityProperties(
+    const VkQueueFamilyGlobalPriorityProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), priorityCount(in_struct->priorityCount) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    for (uint32_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE; ++i) {
+        priorities[i] = in_struct->priorities[i];
+    }
+}
+
+safe_VkQueueFamilyGlobalPriorityProperties::safe_VkQueueFamilyGlobalPriorityProperties()
+    : sType(VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES), pNext(nullptr), priorityCount() {}
+
+safe_VkQueueFamilyGlobalPriorityProperties::safe_VkQueueFamilyGlobalPriorityProperties(
+    const safe_VkQueueFamilyGlobalPriorityProperties& copy_src) {
+    sType = copy_src.sType;
+    priorityCount = copy_src.priorityCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE; ++i) {
+        priorities[i] = copy_src.priorities[i];
+    }
+}
+
+safe_VkQueueFamilyGlobalPriorityProperties& safe_VkQueueFamilyGlobalPriorityProperties::operator=(
+    const safe_VkQueueFamilyGlobalPriorityProperties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    priorityCount = copy_src.priorityCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE; ++i) {
+        priorities[i] = copy_src.priorities[i];
+    }
+
+    return *this;
+}
+
+safe_VkQueueFamilyGlobalPriorityProperties::~safe_VkQueueFamilyGlobalPriorityProperties() { FreePnextChain(pNext); }
+
+void safe_VkQueueFamilyGlobalPriorityProperties::initialize(const VkQueueFamilyGlobalPriorityProperties* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    priorityCount = in_struct->priorityCount;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    for (uint32_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE; ++i) {
+        priorities[i] = in_struct->priorities[i];
+    }
+}
+
+void safe_VkQueueFamilyGlobalPriorityProperties::initialize(const safe_VkQueueFamilyGlobalPriorityProperties* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    priorityCount = copy_src->priorityCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    for (uint32_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE; ++i) {
+        priorities[i] = copy_src->priorities[i];
+    }
+}
+
+safe_VkPhysicalDeviceShaderSubgroupRotateFeatures::safe_VkPhysicalDeviceShaderSubgroupRotateFeatures(
+    const VkPhysicalDeviceShaderSubgroupRotateFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      shaderSubgroupRotate(in_struct->shaderSubgroupRotate),
+      shaderSubgroupRotateClustered(in_struct->shaderSubgroupRotateClustered) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderSubgroupRotateFeatures::safe_VkPhysicalDeviceShaderSubgroupRotateFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES),
+      pNext(nullptr),
+      shaderSubgroupRotate(),
+      shaderSubgroupRotateClustered() {}
+
+safe_VkPhysicalDeviceShaderSubgroupRotateFeatures::safe_VkPhysicalDeviceShaderSubgroupRotateFeatures(
+    const safe_VkPhysicalDeviceShaderSubgroupRotateFeatures& copy_src) {
+    sType = copy_src.sType;
+    shaderSubgroupRotate = copy_src.shaderSubgroupRotate;
+    shaderSubgroupRotateClustered = copy_src.shaderSubgroupRotateClustered;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderSubgroupRotateFeatures& safe_VkPhysicalDeviceShaderSubgroupRotateFeatures::operator=(
+    const safe_VkPhysicalDeviceShaderSubgroupRotateFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderSubgroupRotate = copy_src.shaderSubgroupRotate;
+    shaderSubgroupRotateClustered = copy_src.shaderSubgroupRotateClustered;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderSubgroupRotateFeatures::~safe_VkPhysicalDeviceShaderSubgroupRotateFeatures() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceShaderSubgroupRotateFeatures::initialize(const VkPhysicalDeviceShaderSubgroupRotateFeatures* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderSubgroupRotate = in_struct->shaderSubgroupRotate;
+    shaderSubgroupRotateClustered = in_struct->shaderSubgroupRotateClustered;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderSubgroupRotateFeatures::initialize(
+    const safe_VkPhysicalDeviceShaderSubgroupRotateFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderSubgroupRotate = copy_src->shaderSubgroupRotate;
+    shaderSubgroupRotateClustered = copy_src->shaderSubgroupRotateClustered;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceShaderFloatControls2Features::safe_VkPhysicalDeviceShaderFloatControls2Features(
+    const VkPhysicalDeviceShaderFloatControls2Features* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), shaderFloatControls2(in_struct->shaderFloatControls2) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderFloatControls2Features::safe_VkPhysicalDeviceShaderFloatControls2Features()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES), pNext(nullptr), shaderFloatControls2() {}
+
+safe_VkPhysicalDeviceShaderFloatControls2Features::safe_VkPhysicalDeviceShaderFloatControls2Features(
+    const safe_VkPhysicalDeviceShaderFloatControls2Features& copy_src) {
+    sType = copy_src.sType;
+    shaderFloatControls2 = copy_src.shaderFloatControls2;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderFloatControls2Features& safe_VkPhysicalDeviceShaderFloatControls2Features::operator=(
+    const safe_VkPhysicalDeviceShaderFloatControls2Features& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderFloatControls2 = copy_src.shaderFloatControls2;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderFloatControls2Features::~safe_VkPhysicalDeviceShaderFloatControls2Features() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceShaderFloatControls2Features::initialize(const VkPhysicalDeviceShaderFloatControls2Features* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderFloatControls2 = in_struct->shaderFloatControls2;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderFloatControls2Features::initialize(
+    const safe_VkPhysicalDeviceShaderFloatControls2Features* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderFloatControls2 = copy_src->shaderFloatControls2;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceShaderExpectAssumeFeatures::safe_VkPhysicalDeviceShaderExpectAssumeFeatures(
+    const VkPhysicalDeviceShaderExpectAssumeFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), shaderExpectAssume(in_struct->shaderExpectAssume) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderExpectAssumeFeatures::safe_VkPhysicalDeviceShaderExpectAssumeFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES), pNext(nullptr), shaderExpectAssume() {}
+
+safe_VkPhysicalDeviceShaderExpectAssumeFeatures::safe_VkPhysicalDeviceShaderExpectAssumeFeatures(
+    const safe_VkPhysicalDeviceShaderExpectAssumeFeatures& copy_src) {
+    sType = copy_src.sType;
+    shaderExpectAssume = copy_src.shaderExpectAssume;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderExpectAssumeFeatures& safe_VkPhysicalDeviceShaderExpectAssumeFeatures::operator=(
+    const safe_VkPhysicalDeviceShaderExpectAssumeFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderExpectAssume = copy_src.shaderExpectAssume;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderExpectAssumeFeatures::~safe_VkPhysicalDeviceShaderExpectAssumeFeatures() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceShaderExpectAssumeFeatures::initialize(const VkPhysicalDeviceShaderExpectAssumeFeatures* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderExpectAssume = in_struct->shaderExpectAssume;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderExpectAssumeFeatures::initialize(const safe_VkPhysicalDeviceShaderExpectAssumeFeatures* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderExpectAssume = copy_src->shaderExpectAssume;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceLineRasterizationFeatures::safe_VkPhysicalDeviceLineRasterizationFeatures(
+    const VkPhysicalDeviceLineRasterizationFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      rectangularLines(in_struct->rectangularLines),
+      bresenhamLines(in_struct->bresenhamLines),
+      smoothLines(in_struct->smoothLines),
+      stippledRectangularLines(in_struct->stippledRectangularLines),
+      stippledBresenhamLines(in_struct->stippledBresenhamLines),
+      stippledSmoothLines(in_struct->stippledSmoothLines) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceLineRasterizationFeatures::safe_VkPhysicalDeviceLineRasterizationFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES),
+      pNext(nullptr),
+      rectangularLines(),
+      bresenhamLines(),
+      smoothLines(),
+      stippledRectangularLines(),
+      stippledBresenhamLines(),
+      stippledSmoothLines() {}
+
+safe_VkPhysicalDeviceLineRasterizationFeatures::safe_VkPhysicalDeviceLineRasterizationFeatures(
+    const safe_VkPhysicalDeviceLineRasterizationFeatures& copy_src) {
+    sType = copy_src.sType;
+    rectangularLines = copy_src.rectangularLines;
+    bresenhamLines = copy_src.bresenhamLines;
+    smoothLines = copy_src.smoothLines;
+    stippledRectangularLines = copy_src.stippledRectangularLines;
+    stippledBresenhamLines = copy_src.stippledBresenhamLines;
+    stippledSmoothLines = copy_src.stippledSmoothLines;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceLineRasterizationFeatures& safe_VkPhysicalDeviceLineRasterizationFeatures::operator=(
+    const safe_VkPhysicalDeviceLineRasterizationFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    rectangularLines = copy_src.rectangularLines;
+    bresenhamLines = copy_src.bresenhamLines;
+    smoothLines = copy_src.smoothLines;
+    stippledRectangularLines = copy_src.stippledRectangularLines;
+    stippledBresenhamLines = copy_src.stippledBresenhamLines;
+    stippledSmoothLines = copy_src.stippledSmoothLines;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceLineRasterizationFeatures::~safe_VkPhysicalDeviceLineRasterizationFeatures() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceLineRasterizationFeatures::initialize(const VkPhysicalDeviceLineRasterizationFeatures* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    rectangularLines = in_struct->rectangularLines;
+    bresenhamLines = in_struct->bresenhamLines;
+    smoothLines = in_struct->smoothLines;
+    stippledRectangularLines = in_struct->stippledRectangularLines;
+    stippledBresenhamLines = in_struct->stippledBresenhamLines;
+    stippledSmoothLines = in_struct->stippledSmoothLines;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceLineRasterizationFeatures::initialize(const safe_VkPhysicalDeviceLineRasterizationFeatures* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    rectangularLines = copy_src->rectangularLines;
+    bresenhamLines = copy_src->bresenhamLines;
+    smoothLines = copy_src->smoothLines;
+    stippledRectangularLines = copy_src->stippledRectangularLines;
+    stippledBresenhamLines = copy_src->stippledBresenhamLines;
+    stippledSmoothLines = copy_src->stippledSmoothLines;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceLineRasterizationProperties::safe_VkPhysicalDeviceLineRasterizationProperties(
+    const VkPhysicalDeviceLineRasterizationProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), lineSubPixelPrecisionBits(in_struct->lineSubPixelPrecisionBits) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceLineRasterizationProperties::safe_VkPhysicalDeviceLineRasterizationProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES), pNext(nullptr), lineSubPixelPrecisionBits() {}
+
+safe_VkPhysicalDeviceLineRasterizationProperties::safe_VkPhysicalDeviceLineRasterizationProperties(
+    const safe_VkPhysicalDeviceLineRasterizationProperties& copy_src) {
+    sType = copy_src.sType;
+    lineSubPixelPrecisionBits = copy_src.lineSubPixelPrecisionBits;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceLineRasterizationProperties& safe_VkPhysicalDeviceLineRasterizationProperties::operator=(
+    const safe_VkPhysicalDeviceLineRasterizationProperties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    lineSubPixelPrecisionBits = copy_src.lineSubPixelPrecisionBits;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceLineRasterizationProperties::~safe_VkPhysicalDeviceLineRasterizationProperties() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceLineRasterizationProperties::initialize(const VkPhysicalDeviceLineRasterizationProperties* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    lineSubPixelPrecisionBits = in_struct->lineSubPixelPrecisionBits;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceLineRasterizationProperties::initialize(const safe_VkPhysicalDeviceLineRasterizationProperties* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    lineSubPixelPrecisionBits = copy_src->lineSubPixelPrecisionBits;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineRasterizationLineStateCreateInfo::safe_VkPipelineRasterizationLineStateCreateInfo(
+    const VkPipelineRasterizationLineStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      lineRasterizationMode(in_struct->lineRasterizationMode),
+      stippledLineEnable(in_struct->stippledLineEnable),
+      lineStippleFactor(in_struct->lineStippleFactor),
+      lineStipplePattern(in_struct->lineStipplePattern) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPipelineRasterizationLineStateCreateInfo::safe_VkPipelineRasterizationLineStateCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO),
+      pNext(nullptr),
+      lineRasterizationMode(),
+      stippledLineEnable(),
+      lineStippleFactor(),
+      lineStipplePattern() {}
+
+safe_VkPipelineRasterizationLineStateCreateInfo::safe_VkPipelineRasterizationLineStateCreateInfo(
+    const safe_VkPipelineRasterizationLineStateCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    lineRasterizationMode = copy_src.lineRasterizationMode;
+    stippledLineEnable = copy_src.stippledLineEnable;
+    lineStippleFactor = copy_src.lineStippleFactor;
+    lineStipplePattern = copy_src.lineStipplePattern;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPipelineRasterizationLineStateCreateInfo& safe_VkPipelineRasterizationLineStateCreateInfo::operator=(
+    const safe_VkPipelineRasterizationLineStateCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    lineRasterizationMode = copy_src.lineRasterizationMode;
+    stippledLineEnable = copy_src.stippledLineEnable;
+    lineStippleFactor = copy_src.lineStippleFactor;
+    lineStipplePattern = copy_src.lineStipplePattern;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineRasterizationLineStateCreateInfo::~safe_VkPipelineRasterizationLineStateCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkPipelineRasterizationLineStateCreateInfo::initialize(const VkPipelineRasterizationLineStateCreateInfo* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    lineRasterizationMode = in_struct->lineRasterizationMode;
+    stippledLineEnable = in_struct->stippledLineEnable;
+    lineStippleFactor = in_struct->lineStippleFactor;
+    lineStipplePattern = in_struct->lineStipplePattern;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPipelineRasterizationLineStateCreateInfo::initialize(const safe_VkPipelineRasterizationLineStateCreateInfo* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    lineRasterizationMode = copy_src->lineRasterizationMode;
+    stippledLineEnable = copy_src->stippledLineEnable;
+    lineStippleFactor = copy_src->lineStippleFactor;
+    lineStipplePattern = copy_src->lineStipplePattern;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceVertexAttributeDivisorProperties::safe_VkPhysicalDeviceVertexAttributeDivisorProperties(
+    const VkPhysicalDeviceVertexAttributeDivisorProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      maxVertexAttribDivisor(in_struct->maxVertexAttribDivisor),
+      supportsNonZeroFirstInstance(in_struct->supportsNonZeroFirstInstance) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceVertexAttributeDivisorProperties::safe_VkPhysicalDeviceVertexAttributeDivisorProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES),
+      pNext(nullptr),
+      maxVertexAttribDivisor(),
+      supportsNonZeroFirstInstance() {}
+
+safe_VkPhysicalDeviceVertexAttributeDivisorProperties::safe_VkPhysicalDeviceVertexAttributeDivisorProperties(
+    const safe_VkPhysicalDeviceVertexAttributeDivisorProperties& copy_src) {
+    sType = copy_src.sType;
+    maxVertexAttribDivisor = copy_src.maxVertexAttribDivisor;
+    supportsNonZeroFirstInstance = copy_src.supportsNonZeroFirstInstance;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceVertexAttributeDivisorProperties& safe_VkPhysicalDeviceVertexAttributeDivisorProperties::operator=(
+    const safe_VkPhysicalDeviceVertexAttributeDivisorProperties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxVertexAttribDivisor = copy_src.maxVertexAttribDivisor;
+    supportsNonZeroFirstInstance = copy_src.supportsNonZeroFirstInstance;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceVertexAttributeDivisorProperties::~safe_VkPhysicalDeviceVertexAttributeDivisorProperties() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceVertexAttributeDivisorProperties::initialize(
+    const VkPhysicalDeviceVertexAttributeDivisorProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxVertexAttribDivisor = in_struct->maxVertexAttribDivisor;
+    supportsNonZeroFirstInstance = in_struct->supportsNonZeroFirstInstance;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceVertexAttributeDivisorProperties::initialize(
+    const safe_VkPhysicalDeviceVertexAttributeDivisorProperties* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxVertexAttribDivisor = copy_src->maxVertexAttribDivisor;
+    supportsNonZeroFirstInstance = copy_src->supportsNonZeroFirstInstance;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineVertexInputDivisorStateCreateInfo::safe_VkPipelineVertexInputDivisorStateCreateInfo(
+    const VkPipelineVertexInputDivisorStateCreateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), vertexBindingDivisorCount(in_struct->vertexBindingDivisorCount), pVertexBindingDivisors(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pVertexBindingDivisors) {
+        pVertexBindingDivisors = new VkVertexInputBindingDivisorDescription[in_struct->vertexBindingDivisorCount];
+        memcpy((void*)pVertexBindingDivisors, (void*)in_struct->pVertexBindingDivisors,
+               sizeof(VkVertexInputBindingDivisorDescription) * in_struct->vertexBindingDivisorCount);
+    }
+}
+
+safe_VkPipelineVertexInputDivisorStateCreateInfo::safe_VkPipelineVertexInputDivisorStateCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO),
+      pNext(nullptr),
+      vertexBindingDivisorCount(),
+      pVertexBindingDivisors(nullptr) {}
+
+safe_VkPipelineVertexInputDivisorStateCreateInfo::safe_VkPipelineVertexInputDivisorStateCreateInfo(
+    const safe_VkPipelineVertexInputDivisorStateCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    vertexBindingDivisorCount = copy_src.vertexBindingDivisorCount;
+    pVertexBindingDivisors = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pVertexBindingDivisors) {
+        pVertexBindingDivisors = new VkVertexInputBindingDivisorDescription[copy_src.vertexBindingDivisorCount];
+        memcpy((void*)pVertexBindingDivisors, (void*)copy_src.pVertexBindingDivisors,
+               sizeof(VkVertexInputBindingDivisorDescription) * copy_src.vertexBindingDivisorCount);
+    }
+}
+
+safe_VkPipelineVertexInputDivisorStateCreateInfo& safe_VkPipelineVertexInputDivisorStateCreateInfo::operator=(
+    const safe_VkPipelineVertexInputDivisorStateCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pVertexBindingDivisors) delete[] pVertexBindingDivisors;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    vertexBindingDivisorCount = copy_src.vertexBindingDivisorCount;
+    pVertexBindingDivisors = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pVertexBindingDivisors) {
+        pVertexBindingDivisors = new VkVertexInputBindingDivisorDescription[copy_src.vertexBindingDivisorCount];
+        memcpy((void*)pVertexBindingDivisors, (void*)copy_src.pVertexBindingDivisors,
+               sizeof(VkVertexInputBindingDivisorDescription) * copy_src.vertexBindingDivisorCount);
+    }
+
+    return *this;
+}
+
+safe_VkPipelineVertexInputDivisorStateCreateInfo::~safe_VkPipelineVertexInputDivisorStateCreateInfo() {
+    if (pVertexBindingDivisors) delete[] pVertexBindingDivisors;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPipelineVertexInputDivisorStateCreateInfo::initialize(const VkPipelineVertexInputDivisorStateCreateInfo* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pVertexBindingDivisors) delete[] pVertexBindingDivisors;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    vertexBindingDivisorCount = in_struct->vertexBindingDivisorCount;
+    pVertexBindingDivisors = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pVertexBindingDivisors) {
+        pVertexBindingDivisors = new VkVertexInputBindingDivisorDescription[in_struct->vertexBindingDivisorCount];
+        memcpy((void*)pVertexBindingDivisors, (void*)in_struct->pVertexBindingDivisors,
+               sizeof(VkVertexInputBindingDivisorDescription) * in_struct->vertexBindingDivisorCount);
+    }
+}
+
+void safe_VkPipelineVertexInputDivisorStateCreateInfo::initialize(const safe_VkPipelineVertexInputDivisorStateCreateInfo* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    vertexBindingDivisorCount = copy_src->vertexBindingDivisorCount;
+    pVertexBindingDivisors = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pVertexBindingDivisors) {
+        pVertexBindingDivisors = new VkVertexInputBindingDivisorDescription[copy_src->vertexBindingDivisorCount];
+        memcpy((void*)pVertexBindingDivisors, (void*)copy_src->pVertexBindingDivisors,
+               sizeof(VkVertexInputBindingDivisorDescription) * copy_src->vertexBindingDivisorCount);
+    }
+}
+
+safe_VkPhysicalDeviceVertexAttributeDivisorFeatures::safe_VkPhysicalDeviceVertexAttributeDivisorFeatures(
+    const VkPhysicalDeviceVertexAttributeDivisorFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      vertexAttributeInstanceRateDivisor(in_struct->vertexAttributeInstanceRateDivisor),
+      vertexAttributeInstanceRateZeroDivisor(in_struct->vertexAttributeInstanceRateZeroDivisor) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceVertexAttributeDivisorFeatures::safe_VkPhysicalDeviceVertexAttributeDivisorFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES),
+      pNext(nullptr),
+      vertexAttributeInstanceRateDivisor(),
+      vertexAttributeInstanceRateZeroDivisor() {}
+
+safe_VkPhysicalDeviceVertexAttributeDivisorFeatures::safe_VkPhysicalDeviceVertexAttributeDivisorFeatures(
+    const safe_VkPhysicalDeviceVertexAttributeDivisorFeatures& copy_src) {
+    sType = copy_src.sType;
+    vertexAttributeInstanceRateDivisor = copy_src.vertexAttributeInstanceRateDivisor;
+    vertexAttributeInstanceRateZeroDivisor = copy_src.vertexAttributeInstanceRateZeroDivisor;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceVertexAttributeDivisorFeatures& safe_VkPhysicalDeviceVertexAttributeDivisorFeatures::operator=(
+    const safe_VkPhysicalDeviceVertexAttributeDivisorFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    vertexAttributeInstanceRateDivisor = copy_src.vertexAttributeInstanceRateDivisor;
+    vertexAttributeInstanceRateZeroDivisor = copy_src.vertexAttributeInstanceRateZeroDivisor;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceVertexAttributeDivisorFeatures::~safe_VkPhysicalDeviceVertexAttributeDivisorFeatures() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceVertexAttributeDivisorFeatures::initialize(
+    const VkPhysicalDeviceVertexAttributeDivisorFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    vertexAttributeInstanceRateDivisor = in_struct->vertexAttributeInstanceRateDivisor;
+    vertexAttributeInstanceRateZeroDivisor = in_struct->vertexAttributeInstanceRateZeroDivisor;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceVertexAttributeDivisorFeatures::initialize(
+    const safe_VkPhysicalDeviceVertexAttributeDivisorFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    vertexAttributeInstanceRateDivisor = copy_src->vertexAttributeInstanceRateDivisor;
+    vertexAttributeInstanceRateZeroDivisor = copy_src->vertexAttributeInstanceRateZeroDivisor;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceIndexTypeUint8Features::safe_VkPhysicalDeviceIndexTypeUint8Features(
+    const VkPhysicalDeviceIndexTypeUint8Features* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), indexTypeUint8(in_struct->indexTypeUint8) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceIndexTypeUint8Features::safe_VkPhysicalDeviceIndexTypeUint8Features()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES), pNext(nullptr), indexTypeUint8() {}
+
+safe_VkPhysicalDeviceIndexTypeUint8Features::safe_VkPhysicalDeviceIndexTypeUint8Features(
+    const safe_VkPhysicalDeviceIndexTypeUint8Features& copy_src) {
+    sType = copy_src.sType;
+    indexTypeUint8 = copy_src.indexTypeUint8;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceIndexTypeUint8Features& safe_VkPhysicalDeviceIndexTypeUint8Features::operator=(
+    const safe_VkPhysicalDeviceIndexTypeUint8Features& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    indexTypeUint8 = copy_src.indexTypeUint8;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceIndexTypeUint8Features::~safe_VkPhysicalDeviceIndexTypeUint8Features() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceIndexTypeUint8Features::initialize(const VkPhysicalDeviceIndexTypeUint8Features* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    indexTypeUint8 = in_struct->indexTypeUint8;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceIndexTypeUint8Features::initialize(const safe_VkPhysicalDeviceIndexTypeUint8Features* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    indexTypeUint8 = copy_src->indexTypeUint8;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkMemoryMapInfo::safe_VkMemoryMapInfo(const VkMemoryMapInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                           bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      memory(in_struct->memory),
+      offset(in_struct->offset),
+      size(in_struct->size) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMemoryMapInfo::safe_VkMemoryMapInfo()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_MAP_INFO), pNext(nullptr), flags(), memory(), offset(), size() {}
+
+safe_VkMemoryMapInfo::safe_VkMemoryMapInfo(const safe_VkMemoryMapInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    memory = copy_src.memory;
+    offset = copy_src.offset;
+    size = copy_src.size;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMemoryMapInfo& safe_VkMemoryMapInfo::operator=(const safe_VkMemoryMapInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    memory = copy_src.memory;
+    offset = copy_src.offset;
+    size = copy_src.size;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMemoryMapInfo::~safe_VkMemoryMapInfo() { FreePnextChain(pNext); }
+
+void safe_VkMemoryMapInfo::initialize(const VkMemoryMapInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    memory = in_struct->memory;
+    offset = in_struct->offset;
+    size = in_struct->size;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMemoryMapInfo::initialize(const safe_VkMemoryMapInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    memory = copy_src->memory;
+    offset = copy_src->offset;
+    size = copy_src->size;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkMemoryUnmapInfo::safe_VkMemoryUnmapInfo(const VkMemoryUnmapInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                               bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags), memory(in_struct->memory) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMemoryUnmapInfo::safe_VkMemoryUnmapInfo() : sType(VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO), pNext(nullptr), flags(), memory() {}
+
+safe_VkMemoryUnmapInfo::safe_VkMemoryUnmapInfo(const safe_VkMemoryUnmapInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    memory = copy_src.memory;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMemoryUnmapInfo& safe_VkMemoryUnmapInfo::operator=(const safe_VkMemoryUnmapInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    memory = copy_src.memory;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMemoryUnmapInfo::~safe_VkMemoryUnmapInfo() { FreePnextChain(pNext); }
+
+void safe_VkMemoryUnmapInfo::initialize(const VkMemoryUnmapInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    memory = in_struct->memory;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMemoryUnmapInfo::initialize(const safe_VkMemoryUnmapInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    memory = copy_src->memory;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceMaintenance5Features::safe_VkPhysicalDeviceMaintenance5Features(
+    const VkPhysicalDeviceMaintenance5Features* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), maintenance5(in_struct->maintenance5) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMaintenance5Features::safe_VkPhysicalDeviceMaintenance5Features()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES), pNext(nullptr), maintenance5() {}
+
+safe_VkPhysicalDeviceMaintenance5Features::safe_VkPhysicalDeviceMaintenance5Features(
+    const safe_VkPhysicalDeviceMaintenance5Features& copy_src) {
+    sType = copy_src.sType;
+    maintenance5 = copy_src.maintenance5;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMaintenance5Features& safe_VkPhysicalDeviceMaintenance5Features::operator=(
+    const safe_VkPhysicalDeviceMaintenance5Features& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maintenance5 = copy_src.maintenance5;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMaintenance5Features::~safe_VkPhysicalDeviceMaintenance5Features() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceMaintenance5Features::initialize(const VkPhysicalDeviceMaintenance5Features* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maintenance5 = in_struct->maintenance5;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMaintenance5Features::initialize(const safe_VkPhysicalDeviceMaintenance5Features* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maintenance5 = copy_src->maintenance5;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceMaintenance5Properties::safe_VkPhysicalDeviceMaintenance5Properties(
+    const VkPhysicalDeviceMaintenance5Properties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      earlyFragmentMultisampleCoverageAfterSampleCounting(in_struct->earlyFragmentMultisampleCoverageAfterSampleCounting),
+      earlyFragmentSampleMaskTestBeforeSampleCounting(in_struct->earlyFragmentSampleMaskTestBeforeSampleCounting),
+      depthStencilSwizzleOneSupport(in_struct->depthStencilSwizzleOneSupport),
+      polygonModePointSize(in_struct->polygonModePointSize),
+      nonStrictSinglePixelWideLinesUseParallelogram(in_struct->nonStrictSinglePixelWideLinesUseParallelogram),
+      nonStrictWideLinesUseParallelogram(in_struct->nonStrictWideLinesUseParallelogram) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMaintenance5Properties::safe_VkPhysicalDeviceMaintenance5Properties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES),
+      pNext(nullptr),
+      earlyFragmentMultisampleCoverageAfterSampleCounting(),
+      earlyFragmentSampleMaskTestBeforeSampleCounting(),
+      depthStencilSwizzleOneSupport(),
+      polygonModePointSize(),
+      nonStrictSinglePixelWideLinesUseParallelogram(),
+      nonStrictWideLinesUseParallelogram() {}
+
+safe_VkPhysicalDeviceMaintenance5Properties::safe_VkPhysicalDeviceMaintenance5Properties(
+    const safe_VkPhysicalDeviceMaintenance5Properties& copy_src) {
+    sType = copy_src.sType;
+    earlyFragmentMultisampleCoverageAfterSampleCounting = copy_src.earlyFragmentMultisampleCoverageAfterSampleCounting;
+    earlyFragmentSampleMaskTestBeforeSampleCounting = copy_src.earlyFragmentSampleMaskTestBeforeSampleCounting;
+    depthStencilSwizzleOneSupport = copy_src.depthStencilSwizzleOneSupport;
+    polygonModePointSize = copy_src.polygonModePointSize;
+    nonStrictSinglePixelWideLinesUseParallelogram = copy_src.nonStrictSinglePixelWideLinesUseParallelogram;
+    nonStrictWideLinesUseParallelogram = copy_src.nonStrictWideLinesUseParallelogram;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMaintenance5Properties& safe_VkPhysicalDeviceMaintenance5Properties::operator=(
+    const safe_VkPhysicalDeviceMaintenance5Properties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    earlyFragmentMultisampleCoverageAfterSampleCounting = copy_src.earlyFragmentMultisampleCoverageAfterSampleCounting;
+    earlyFragmentSampleMaskTestBeforeSampleCounting = copy_src.earlyFragmentSampleMaskTestBeforeSampleCounting;
+    depthStencilSwizzleOneSupport = copy_src.depthStencilSwizzleOneSupport;
+    polygonModePointSize = copy_src.polygonModePointSize;
+    nonStrictSinglePixelWideLinesUseParallelogram = copy_src.nonStrictSinglePixelWideLinesUseParallelogram;
+    nonStrictWideLinesUseParallelogram = copy_src.nonStrictWideLinesUseParallelogram;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMaintenance5Properties::~safe_VkPhysicalDeviceMaintenance5Properties() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceMaintenance5Properties::initialize(const VkPhysicalDeviceMaintenance5Properties* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    earlyFragmentMultisampleCoverageAfterSampleCounting = in_struct->earlyFragmentMultisampleCoverageAfterSampleCounting;
+    earlyFragmentSampleMaskTestBeforeSampleCounting = in_struct->earlyFragmentSampleMaskTestBeforeSampleCounting;
+    depthStencilSwizzleOneSupport = in_struct->depthStencilSwizzleOneSupport;
+    polygonModePointSize = in_struct->polygonModePointSize;
+    nonStrictSinglePixelWideLinesUseParallelogram = in_struct->nonStrictSinglePixelWideLinesUseParallelogram;
+    nonStrictWideLinesUseParallelogram = in_struct->nonStrictWideLinesUseParallelogram;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMaintenance5Properties::initialize(const safe_VkPhysicalDeviceMaintenance5Properties* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    earlyFragmentMultisampleCoverageAfterSampleCounting = copy_src->earlyFragmentMultisampleCoverageAfterSampleCounting;
+    earlyFragmentSampleMaskTestBeforeSampleCounting = copy_src->earlyFragmentSampleMaskTestBeforeSampleCounting;
+    depthStencilSwizzleOneSupport = copy_src->depthStencilSwizzleOneSupport;
+    polygonModePointSize = copy_src->polygonModePointSize;
+    nonStrictSinglePixelWideLinesUseParallelogram = copy_src->nonStrictSinglePixelWideLinesUseParallelogram;
+    nonStrictWideLinesUseParallelogram = copy_src->nonStrictWideLinesUseParallelogram;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkRenderingAreaInfo::safe_VkRenderingAreaInfo(const VkRenderingAreaInfo* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      viewMask(in_struct->viewMask),
+      colorAttachmentCount(in_struct->colorAttachmentCount),
+      pColorAttachmentFormats(nullptr),
+      depthAttachmentFormat(in_struct->depthAttachmentFormat),
+      stencilAttachmentFormat(in_struct->stencilAttachmentFormat) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pColorAttachmentFormats) {
+        pColorAttachmentFormats = new VkFormat[in_struct->colorAttachmentCount];
+        memcpy((void*)pColorAttachmentFormats, (void*)in_struct->pColorAttachmentFormats,
+               sizeof(VkFormat) * in_struct->colorAttachmentCount);
+    }
+}
+
+safe_VkRenderingAreaInfo::safe_VkRenderingAreaInfo()
+    : sType(VK_STRUCTURE_TYPE_RENDERING_AREA_INFO),
+      pNext(nullptr),
+      viewMask(),
+      colorAttachmentCount(),
+      pColorAttachmentFormats(nullptr),
+      depthAttachmentFormat(),
+      stencilAttachmentFormat() {}
+
+safe_VkRenderingAreaInfo::safe_VkRenderingAreaInfo(const safe_VkRenderingAreaInfo& copy_src) {
+    sType = copy_src.sType;
+    viewMask = copy_src.viewMask;
+    colorAttachmentCount = copy_src.colorAttachmentCount;
+    pColorAttachmentFormats = nullptr;
+    depthAttachmentFormat = copy_src.depthAttachmentFormat;
+    stencilAttachmentFormat = copy_src.stencilAttachmentFormat;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pColorAttachmentFormats) {
+        pColorAttachmentFormats = new VkFormat[copy_src.colorAttachmentCount];
+        memcpy((void*)pColorAttachmentFormats, (void*)copy_src.pColorAttachmentFormats,
+               sizeof(VkFormat) * copy_src.colorAttachmentCount);
+    }
+}
+
+safe_VkRenderingAreaInfo& safe_VkRenderingAreaInfo::operator=(const safe_VkRenderingAreaInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pColorAttachmentFormats) delete[] pColorAttachmentFormats;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    viewMask = copy_src.viewMask;
+    colorAttachmentCount = copy_src.colorAttachmentCount;
+    pColorAttachmentFormats = nullptr;
+    depthAttachmentFormat = copy_src.depthAttachmentFormat;
+    stencilAttachmentFormat = copy_src.stencilAttachmentFormat;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pColorAttachmentFormats) {
+        pColorAttachmentFormats = new VkFormat[copy_src.colorAttachmentCount];
+        memcpy((void*)pColorAttachmentFormats, (void*)copy_src.pColorAttachmentFormats,
+               sizeof(VkFormat) * copy_src.colorAttachmentCount);
+    }
+
+    return *this;
+}
+
+safe_VkRenderingAreaInfo::~safe_VkRenderingAreaInfo() {
+    if (pColorAttachmentFormats) delete[] pColorAttachmentFormats;
+    FreePnextChain(pNext);
+}
+
+void safe_VkRenderingAreaInfo::initialize(const VkRenderingAreaInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pColorAttachmentFormats) delete[] pColorAttachmentFormats;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    viewMask = in_struct->viewMask;
+    colorAttachmentCount = in_struct->colorAttachmentCount;
+    pColorAttachmentFormats = nullptr;
+    depthAttachmentFormat = in_struct->depthAttachmentFormat;
+    stencilAttachmentFormat = in_struct->stencilAttachmentFormat;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pColorAttachmentFormats) {
+        pColorAttachmentFormats = new VkFormat[in_struct->colorAttachmentCount];
+        memcpy((void*)pColorAttachmentFormats, (void*)in_struct->pColorAttachmentFormats,
+               sizeof(VkFormat) * in_struct->colorAttachmentCount);
+    }
+}
+
+void safe_VkRenderingAreaInfo::initialize(const safe_VkRenderingAreaInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    viewMask = copy_src->viewMask;
+    colorAttachmentCount = copy_src->colorAttachmentCount;
+    pColorAttachmentFormats = nullptr;
+    depthAttachmentFormat = copy_src->depthAttachmentFormat;
+    stencilAttachmentFormat = copy_src->stencilAttachmentFormat;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pColorAttachmentFormats) {
+        pColorAttachmentFormats = new VkFormat[copy_src->colorAttachmentCount];
+        memcpy((void*)pColorAttachmentFormats, (void*)copy_src->pColorAttachmentFormats,
+               sizeof(VkFormat) * copy_src->colorAttachmentCount);
+    }
+}
+
+safe_VkImageSubresource2::safe_VkImageSubresource2(const VkImageSubresource2* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), imageSubresource(in_struct->imageSubresource) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImageSubresource2::safe_VkImageSubresource2()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2), pNext(nullptr), imageSubresource() {}
+
+safe_VkImageSubresource2::safe_VkImageSubresource2(const safe_VkImageSubresource2& copy_src) {
+    sType = copy_src.sType;
+    imageSubresource = copy_src.imageSubresource;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImageSubresource2& safe_VkImageSubresource2::operator=(const safe_VkImageSubresource2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    imageSubresource = copy_src.imageSubresource;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImageSubresource2::~safe_VkImageSubresource2() { FreePnextChain(pNext); }
+
+void safe_VkImageSubresource2::initialize(const VkImageSubresource2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    imageSubresource = in_struct->imageSubresource;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImageSubresource2::initialize(const safe_VkImageSubresource2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    imageSubresource = copy_src->imageSubresource;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDeviceImageSubresourceInfo::safe_VkDeviceImageSubresourceInfo(const VkDeviceImageSubresourceInfo* in_struct,
+                                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), pCreateInfo(nullptr), pSubresource(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(in_struct->pCreateInfo);
+    if (in_struct->pSubresource) pSubresource = new safe_VkImageSubresource2(in_struct->pSubresource);
+}
+
+safe_VkDeviceImageSubresourceInfo::safe_VkDeviceImageSubresourceInfo()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO), pNext(nullptr), pCreateInfo(nullptr), pSubresource(nullptr) {}
+
+safe_VkDeviceImageSubresourceInfo::safe_VkDeviceImageSubresourceInfo(const safe_VkDeviceImageSubresourceInfo& copy_src) {
+    sType = copy_src.sType;
+    pCreateInfo = nullptr;
+    pSubresource = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(*copy_src.pCreateInfo);
+    if (copy_src.pSubresource) pSubresource = new safe_VkImageSubresource2(*copy_src.pSubresource);
+}
+
+safe_VkDeviceImageSubresourceInfo& safe_VkDeviceImageSubresourceInfo::operator=(const safe_VkDeviceImageSubresourceInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pCreateInfo) delete pCreateInfo;
+    if (pSubresource) delete pSubresource;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pCreateInfo = nullptr;
+    pSubresource = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(*copy_src.pCreateInfo);
+    if (copy_src.pSubresource) pSubresource = new safe_VkImageSubresource2(*copy_src.pSubresource);
+
+    return *this;
+}
+
+safe_VkDeviceImageSubresourceInfo::~safe_VkDeviceImageSubresourceInfo() {
+    if (pCreateInfo) delete pCreateInfo;
+    if (pSubresource) delete pSubresource;
+    FreePnextChain(pNext);
+}
+
+void safe_VkDeviceImageSubresourceInfo::initialize(const VkDeviceImageSubresourceInfo* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pCreateInfo) delete pCreateInfo;
+    if (pSubresource) delete pSubresource;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pCreateInfo = nullptr;
+    pSubresource = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (in_struct->pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(in_struct->pCreateInfo);
+    if (in_struct->pSubresource) pSubresource = new safe_VkImageSubresource2(in_struct->pSubresource);
+}
+
+void safe_VkDeviceImageSubresourceInfo::initialize(const safe_VkDeviceImageSubresourceInfo* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pCreateInfo = nullptr;
+    pSubresource = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (copy_src->pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(*copy_src->pCreateInfo);
+    if (copy_src->pSubresource) pSubresource = new safe_VkImageSubresource2(*copy_src->pSubresource);
+}
+
+safe_VkSubresourceLayout2::safe_VkSubresourceLayout2(const VkSubresourceLayout2* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), subresourceLayout(in_struct->subresourceLayout) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSubresourceLayout2::safe_VkSubresourceLayout2()
+    : sType(VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2), pNext(nullptr), subresourceLayout() {}
+
+safe_VkSubresourceLayout2::safe_VkSubresourceLayout2(const safe_VkSubresourceLayout2& copy_src) {
+    sType = copy_src.sType;
+    subresourceLayout = copy_src.subresourceLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSubresourceLayout2& safe_VkSubresourceLayout2::operator=(const safe_VkSubresourceLayout2& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    subresourceLayout = copy_src.subresourceLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSubresourceLayout2::~safe_VkSubresourceLayout2() { FreePnextChain(pNext); }
+
+void safe_VkSubresourceLayout2::initialize(const VkSubresourceLayout2* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    subresourceLayout = in_struct->subresourceLayout;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSubresourceLayout2::initialize(const safe_VkSubresourceLayout2* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    subresourceLayout = copy_src->subresourceLayout;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineCreateFlags2CreateInfo::safe_VkPipelineCreateFlags2CreateInfo(const VkPipelineCreateFlags2CreateInfo* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPipelineCreateFlags2CreateInfo::safe_VkPipelineCreateFlags2CreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO), pNext(nullptr), flags() {}
+
+safe_VkPipelineCreateFlags2CreateInfo::safe_VkPipelineCreateFlags2CreateInfo(
+    const safe_VkPipelineCreateFlags2CreateInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPipelineCreateFlags2CreateInfo& safe_VkPipelineCreateFlags2CreateInfo::operator=(
+    const safe_VkPipelineCreateFlags2CreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineCreateFlags2CreateInfo::~safe_VkPipelineCreateFlags2CreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkPipelineCreateFlags2CreateInfo::initialize(const VkPipelineCreateFlags2CreateInfo* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPipelineCreateFlags2CreateInfo::initialize(const safe_VkPipelineCreateFlags2CreateInfo* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkBufferUsageFlags2CreateInfo::safe_VkBufferUsageFlags2CreateInfo(const VkBufferUsageFlags2CreateInfo* in_struct,
+                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), usage(in_struct->usage) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkBufferUsageFlags2CreateInfo::safe_VkBufferUsageFlags2CreateInfo()
+    : sType(VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO), pNext(nullptr), usage() {}
+
+safe_VkBufferUsageFlags2CreateInfo::safe_VkBufferUsageFlags2CreateInfo(const safe_VkBufferUsageFlags2CreateInfo& copy_src) {
+    sType = copy_src.sType;
+    usage = copy_src.usage;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBufferUsageFlags2CreateInfo& safe_VkBufferUsageFlags2CreateInfo::operator=(
+    const safe_VkBufferUsageFlags2CreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    usage = copy_src.usage;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkBufferUsageFlags2CreateInfo::~safe_VkBufferUsageFlags2CreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkBufferUsageFlags2CreateInfo::initialize(const VkBufferUsageFlags2CreateInfo* in_struct,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    usage = in_struct->usage;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkBufferUsageFlags2CreateInfo::initialize(const safe_VkBufferUsageFlags2CreateInfo* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    usage = copy_src->usage;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDevicePushDescriptorProperties::safe_VkPhysicalDevicePushDescriptorProperties(
+    const VkPhysicalDevicePushDescriptorProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), maxPushDescriptors(in_struct->maxPushDescriptors) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePushDescriptorProperties::safe_VkPhysicalDevicePushDescriptorProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES), pNext(nullptr), maxPushDescriptors() {}
+
+safe_VkPhysicalDevicePushDescriptorProperties::safe_VkPhysicalDevicePushDescriptorProperties(
+    const safe_VkPhysicalDevicePushDescriptorProperties& copy_src) {
+    sType = copy_src.sType;
+    maxPushDescriptors = copy_src.maxPushDescriptors;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePushDescriptorProperties& safe_VkPhysicalDevicePushDescriptorProperties::operator=(
+    const safe_VkPhysicalDevicePushDescriptorProperties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxPushDescriptors = copy_src.maxPushDescriptors;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePushDescriptorProperties::~safe_VkPhysicalDevicePushDescriptorProperties() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDevicePushDescriptorProperties::initialize(const VkPhysicalDevicePushDescriptorProperties* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxPushDescriptors = in_struct->maxPushDescriptors;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePushDescriptorProperties::initialize(const safe_VkPhysicalDevicePushDescriptorProperties* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxPushDescriptors = copy_src->maxPushDescriptors;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures::safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(
+    const VkPhysicalDeviceDynamicRenderingLocalReadFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), dynamicRenderingLocalRead(in_struct->dynamicRenderingLocalRead) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures::safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES), pNext(nullptr), dynamicRenderingLocalRead() {}
+
+safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures::safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(
+    const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures& copy_src) {
+    sType = copy_src.sType;
+    dynamicRenderingLocalRead = copy_src.dynamicRenderingLocalRead;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures& safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures::operator=(
+    const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    dynamicRenderingLocalRead = copy_src.dynamicRenderingLocalRead;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures::~safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures::initialize(
+    const VkPhysicalDeviceDynamicRenderingLocalReadFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    dynamicRenderingLocalRead = in_struct->dynamicRenderingLocalRead;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures::initialize(
+    const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    dynamicRenderingLocalRead = copy_src->dynamicRenderingLocalRead;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkRenderingAttachmentLocationInfo::safe_VkRenderingAttachmentLocationInfo(const VkRenderingAttachmentLocationInfo* in_struct,
+                                                                               [[maybe_unused]] PNextCopyState* copy_state,
+                                                                               bool copy_pnext)
+    : sType(in_struct->sType), colorAttachmentCount(in_struct->colorAttachmentCount), pColorAttachmentLocations(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pColorAttachmentLocations) {
+        pColorAttachmentLocations = new uint32_t[in_struct->colorAttachmentCount];
+        memcpy((void*)pColorAttachmentLocations, (void*)in_struct->pColorAttachmentLocations,
+               sizeof(uint32_t) * in_struct->colorAttachmentCount);
+    }
+}
+
+safe_VkRenderingAttachmentLocationInfo::safe_VkRenderingAttachmentLocationInfo()
+    : sType(VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO),
+      pNext(nullptr),
+      colorAttachmentCount(),
+      pColorAttachmentLocations(nullptr) {}
+
+safe_VkRenderingAttachmentLocationInfo::safe_VkRenderingAttachmentLocationInfo(
+    const safe_VkRenderingAttachmentLocationInfo& copy_src) {
+    sType = copy_src.sType;
+    colorAttachmentCount = copy_src.colorAttachmentCount;
+    pColorAttachmentLocations = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pColorAttachmentLocations) {
+        pColorAttachmentLocations = new uint32_t[copy_src.colorAttachmentCount];
+        memcpy((void*)pColorAttachmentLocations, (void*)copy_src.pColorAttachmentLocations,
+               sizeof(uint32_t) * copy_src.colorAttachmentCount);
+    }
+}
+
+safe_VkRenderingAttachmentLocationInfo& safe_VkRenderingAttachmentLocationInfo::operator=(
+    const safe_VkRenderingAttachmentLocationInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pColorAttachmentLocations) delete[] pColorAttachmentLocations;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    colorAttachmentCount = copy_src.colorAttachmentCount;
+    pColorAttachmentLocations = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pColorAttachmentLocations) {
+        pColorAttachmentLocations = new uint32_t[copy_src.colorAttachmentCount];
+        memcpy((void*)pColorAttachmentLocations, (void*)copy_src.pColorAttachmentLocations,
+               sizeof(uint32_t) * copy_src.colorAttachmentCount);
+    }
+
+    return *this;
+}
+
+safe_VkRenderingAttachmentLocationInfo::~safe_VkRenderingAttachmentLocationInfo() {
+    if (pColorAttachmentLocations) delete[] pColorAttachmentLocations;
+    FreePnextChain(pNext);
+}
+
+void safe_VkRenderingAttachmentLocationInfo::initialize(const VkRenderingAttachmentLocationInfo* in_struct,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pColorAttachmentLocations) delete[] pColorAttachmentLocations;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    colorAttachmentCount = in_struct->colorAttachmentCount;
+    pColorAttachmentLocations = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pColorAttachmentLocations) {
+        pColorAttachmentLocations = new uint32_t[in_struct->colorAttachmentCount];
+        memcpy((void*)pColorAttachmentLocations, (void*)in_struct->pColorAttachmentLocations,
+               sizeof(uint32_t) * in_struct->colorAttachmentCount);
+    }
+}
+
+void safe_VkRenderingAttachmentLocationInfo::initialize(const safe_VkRenderingAttachmentLocationInfo* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    colorAttachmentCount = copy_src->colorAttachmentCount;
+    pColorAttachmentLocations = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pColorAttachmentLocations) {
+        pColorAttachmentLocations = new uint32_t[copy_src->colorAttachmentCount];
+        memcpy((void*)pColorAttachmentLocations, (void*)copy_src->pColorAttachmentLocations,
+               sizeof(uint32_t) * copy_src->colorAttachmentCount);
+    }
+}
+
+safe_VkRenderingInputAttachmentIndexInfo::safe_VkRenderingInputAttachmentIndexInfo(
+    const VkRenderingInputAttachmentIndexInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      colorAttachmentCount(in_struct->colorAttachmentCount),
+      pColorAttachmentInputIndices(nullptr),
+      pDepthInputAttachmentIndex(nullptr),
+      pStencilInputAttachmentIndex(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pColorAttachmentInputIndices) {
+        pColorAttachmentInputIndices = new uint32_t[in_struct->colorAttachmentCount];
+        memcpy((void*)pColorAttachmentInputIndices, (void*)in_struct->pColorAttachmentInputIndices,
+               sizeof(uint32_t) * in_struct->colorAttachmentCount);
+    }
+
+    if (in_struct->pDepthInputAttachmentIndex) {
+        pDepthInputAttachmentIndex = new uint32_t(*in_struct->pDepthInputAttachmentIndex);
+    }
+
+    if (in_struct->pStencilInputAttachmentIndex) {
+        pStencilInputAttachmentIndex = new uint32_t(*in_struct->pStencilInputAttachmentIndex);
+    }
+}
+
+safe_VkRenderingInputAttachmentIndexInfo::safe_VkRenderingInputAttachmentIndexInfo()
+    : sType(VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO),
+      pNext(nullptr),
+      colorAttachmentCount(),
+      pColorAttachmentInputIndices(nullptr),
+      pDepthInputAttachmentIndex(nullptr),
+      pStencilInputAttachmentIndex(nullptr) {}
+
+safe_VkRenderingInputAttachmentIndexInfo::safe_VkRenderingInputAttachmentIndexInfo(
+    const safe_VkRenderingInputAttachmentIndexInfo& copy_src) {
+    sType = copy_src.sType;
+    colorAttachmentCount = copy_src.colorAttachmentCount;
+    pColorAttachmentInputIndices = nullptr;
+    pDepthInputAttachmentIndex = nullptr;
+    pStencilInputAttachmentIndex = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pColorAttachmentInputIndices) {
+        pColorAttachmentInputIndices = new uint32_t[copy_src.colorAttachmentCount];
+        memcpy((void*)pColorAttachmentInputIndices, (void*)copy_src.pColorAttachmentInputIndices,
+               sizeof(uint32_t) * copy_src.colorAttachmentCount);
+    }
+
+    if (copy_src.pDepthInputAttachmentIndex) {
+        pDepthInputAttachmentIndex = new uint32_t(*copy_src.pDepthInputAttachmentIndex);
+    }
+
+    if (copy_src.pStencilInputAttachmentIndex) {
+        pStencilInputAttachmentIndex = new uint32_t(*copy_src.pStencilInputAttachmentIndex);
+    }
+}
+
+safe_VkRenderingInputAttachmentIndexInfo& safe_VkRenderingInputAttachmentIndexInfo::operator=(
+    const safe_VkRenderingInputAttachmentIndexInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pColorAttachmentInputIndices) delete[] pColorAttachmentInputIndices;
+    if (pDepthInputAttachmentIndex) delete pDepthInputAttachmentIndex;
+    if (pStencilInputAttachmentIndex) delete pStencilInputAttachmentIndex;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    colorAttachmentCount = copy_src.colorAttachmentCount;
+    pColorAttachmentInputIndices = nullptr;
+    pDepthInputAttachmentIndex = nullptr;
+    pStencilInputAttachmentIndex = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pColorAttachmentInputIndices) {
+        pColorAttachmentInputIndices = new uint32_t[copy_src.colorAttachmentCount];
+        memcpy((void*)pColorAttachmentInputIndices, (void*)copy_src.pColorAttachmentInputIndices,
+               sizeof(uint32_t) * copy_src.colorAttachmentCount);
+    }
+
+    if (copy_src.pDepthInputAttachmentIndex) {
+        pDepthInputAttachmentIndex = new uint32_t(*copy_src.pDepthInputAttachmentIndex);
+    }
+
+    if (copy_src.pStencilInputAttachmentIndex) {
+        pStencilInputAttachmentIndex = new uint32_t(*copy_src.pStencilInputAttachmentIndex);
+    }
+
+    return *this;
+}
+
+safe_VkRenderingInputAttachmentIndexInfo::~safe_VkRenderingInputAttachmentIndexInfo() {
+    if (pColorAttachmentInputIndices) delete[] pColorAttachmentInputIndices;
+    if (pDepthInputAttachmentIndex) delete pDepthInputAttachmentIndex;
+    if (pStencilInputAttachmentIndex) delete pStencilInputAttachmentIndex;
+    FreePnextChain(pNext);
+}
+
+void safe_VkRenderingInputAttachmentIndexInfo::initialize(const VkRenderingInputAttachmentIndexInfo* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pColorAttachmentInputIndices) delete[] pColorAttachmentInputIndices;
+    if (pDepthInputAttachmentIndex) delete pDepthInputAttachmentIndex;
+    if (pStencilInputAttachmentIndex) delete pStencilInputAttachmentIndex;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    colorAttachmentCount = in_struct->colorAttachmentCount;
+    pColorAttachmentInputIndices = nullptr;
+    pDepthInputAttachmentIndex = nullptr;
+    pStencilInputAttachmentIndex = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pColorAttachmentInputIndices) {
+        pColorAttachmentInputIndices = new uint32_t[in_struct->colorAttachmentCount];
+        memcpy((void*)pColorAttachmentInputIndices, (void*)in_struct->pColorAttachmentInputIndices,
+               sizeof(uint32_t) * in_struct->colorAttachmentCount);
+    }
+
+    if (in_struct->pDepthInputAttachmentIndex) {
+        pDepthInputAttachmentIndex = new uint32_t(*in_struct->pDepthInputAttachmentIndex);
+    }
+
+    if (in_struct->pStencilInputAttachmentIndex) {
+        pStencilInputAttachmentIndex = new uint32_t(*in_struct->pStencilInputAttachmentIndex);
+    }
+}
+
+void safe_VkRenderingInputAttachmentIndexInfo::initialize(const safe_VkRenderingInputAttachmentIndexInfo* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    colorAttachmentCount = copy_src->colorAttachmentCount;
+    pColorAttachmentInputIndices = nullptr;
+    pDepthInputAttachmentIndex = nullptr;
+    pStencilInputAttachmentIndex = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pColorAttachmentInputIndices) {
+        pColorAttachmentInputIndices = new uint32_t[copy_src->colorAttachmentCount];
+        memcpy((void*)pColorAttachmentInputIndices, (void*)copy_src->pColorAttachmentInputIndices,
+               sizeof(uint32_t) * copy_src->colorAttachmentCount);
+    }
+
+    if (copy_src->pDepthInputAttachmentIndex) {
+        pDepthInputAttachmentIndex = new uint32_t(*copy_src->pDepthInputAttachmentIndex);
+    }
+
+    if (copy_src->pStencilInputAttachmentIndex) {
+        pStencilInputAttachmentIndex = new uint32_t(*copy_src->pStencilInputAttachmentIndex);
+    }
+}
+
+safe_VkPhysicalDeviceMaintenance6Features::safe_VkPhysicalDeviceMaintenance6Features(
+    const VkPhysicalDeviceMaintenance6Features* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), maintenance6(in_struct->maintenance6) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMaintenance6Features::safe_VkPhysicalDeviceMaintenance6Features()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES), pNext(nullptr), maintenance6() {}
+
+safe_VkPhysicalDeviceMaintenance6Features::safe_VkPhysicalDeviceMaintenance6Features(
+    const safe_VkPhysicalDeviceMaintenance6Features& copy_src) {
+    sType = copy_src.sType;
+    maintenance6 = copy_src.maintenance6;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMaintenance6Features& safe_VkPhysicalDeviceMaintenance6Features::operator=(
+    const safe_VkPhysicalDeviceMaintenance6Features& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maintenance6 = copy_src.maintenance6;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMaintenance6Features::~safe_VkPhysicalDeviceMaintenance6Features() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceMaintenance6Features::initialize(const VkPhysicalDeviceMaintenance6Features* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maintenance6 = in_struct->maintenance6;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMaintenance6Features::initialize(const safe_VkPhysicalDeviceMaintenance6Features* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maintenance6 = copy_src->maintenance6;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceMaintenance6Properties::safe_VkPhysicalDeviceMaintenance6Properties(
+    const VkPhysicalDeviceMaintenance6Properties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      blockTexelViewCompatibleMultipleLayers(in_struct->blockTexelViewCompatibleMultipleLayers),
+      maxCombinedImageSamplerDescriptorCount(in_struct->maxCombinedImageSamplerDescriptorCount),
+      fragmentShadingRateClampCombinerInputs(in_struct->fragmentShadingRateClampCombinerInputs) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMaintenance6Properties::safe_VkPhysicalDeviceMaintenance6Properties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES),
+      pNext(nullptr),
+      blockTexelViewCompatibleMultipleLayers(),
+      maxCombinedImageSamplerDescriptorCount(),
+      fragmentShadingRateClampCombinerInputs() {}
+
+safe_VkPhysicalDeviceMaintenance6Properties::safe_VkPhysicalDeviceMaintenance6Properties(
+    const safe_VkPhysicalDeviceMaintenance6Properties& copy_src) {
+    sType = copy_src.sType;
+    blockTexelViewCompatibleMultipleLayers = copy_src.blockTexelViewCompatibleMultipleLayers;
+    maxCombinedImageSamplerDescriptorCount = copy_src.maxCombinedImageSamplerDescriptorCount;
+    fragmentShadingRateClampCombinerInputs = copy_src.fragmentShadingRateClampCombinerInputs;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMaintenance6Properties& safe_VkPhysicalDeviceMaintenance6Properties::operator=(
+    const safe_VkPhysicalDeviceMaintenance6Properties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    blockTexelViewCompatibleMultipleLayers = copy_src.blockTexelViewCompatibleMultipleLayers;
+    maxCombinedImageSamplerDescriptorCount = copy_src.maxCombinedImageSamplerDescriptorCount;
+    fragmentShadingRateClampCombinerInputs = copy_src.fragmentShadingRateClampCombinerInputs;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMaintenance6Properties::~safe_VkPhysicalDeviceMaintenance6Properties() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceMaintenance6Properties::initialize(const VkPhysicalDeviceMaintenance6Properties* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    blockTexelViewCompatibleMultipleLayers = in_struct->blockTexelViewCompatibleMultipleLayers;
+    maxCombinedImageSamplerDescriptorCount = in_struct->maxCombinedImageSamplerDescriptorCount;
+    fragmentShadingRateClampCombinerInputs = in_struct->fragmentShadingRateClampCombinerInputs;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMaintenance6Properties::initialize(const safe_VkPhysicalDeviceMaintenance6Properties* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    blockTexelViewCompatibleMultipleLayers = copy_src->blockTexelViewCompatibleMultipleLayers;
+    maxCombinedImageSamplerDescriptorCount = copy_src->maxCombinedImageSamplerDescriptorCount;
+    fragmentShadingRateClampCombinerInputs = copy_src->fragmentShadingRateClampCombinerInputs;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkBindMemoryStatus::safe_VkBindMemoryStatus(const VkBindMemoryStatus* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                                 bool copy_pnext)
+    : sType(in_struct->sType), pResult(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pResult) {
+        pResult = new VkResult(*in_struct->pResult);
+    }
+}
+
+safe_VkBindMemoryStatus::safe_VkBindMemoryStatus()
+    : sType(VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS), pNext(nullptr), pResult(nullptr) {}
+
+safe_VkBindMemoryStatus::safe_VkBindMemoryStatus(const safe_VkBindMemoryStatus& copy_src) {
+    sType = copy_src.sType;
+    pResult = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pResult) {
+        pResult = new VkResult(*copy_src.pResult);
+    }
+}
+
+safe_VkBindMemoryStatus& safe_VkBindMemoryStatus::operator=(const safe_VkBindMemoryStatus& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pResult) delete pResult;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pResult = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pResult) {
+        pResult = new VkResult(*copy_src.pResult);
+    }
+
+    return *this;
+}
+
+safe_VkBindMemoryStatus::~safe_VkBindMemoryStatus() {
+    if (pResult) delete pResult;
+    FreePnextChain(pNext);
+}
+
+void safe_VkBindMemoryStatus::initialize(const VkBindMemoryStatus* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pResult) delete pResult;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pResult = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pResult) {
+        pResult = new VkResult(*in_struct->pResult);
+    }
+}
+
+void safe_VkBindMemoryStatus::initialize(const safe_VkBindMemoryStatus* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pResult = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pResult) {
+        pResult = new VkResult(*copy_src->pResult);
+    }
+}
+
+safe_VkBindDescriptorSetsInfo::safe_VkBindDescriptorSetsInfo(const VkBindDescriptorSetsInfo* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      stageFlags(in_struct->stageFlags),
+      layout(in_struct->layout),
+      firstSet(in_struct->firstSet),
+      descriptorSetCount(in_struct->descriptorSetCount),
+      pDescriptorSets(nullptr),
+      dynamicOffsetCount(in_struct->dynamicOffsetCount),
+      pDynamicOffsets(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (descriptorSetCount && in_struct->pDescriptorSets) {
+        pDescriptorSets = new VkDescriptorSet[descriptorSetCount];
+        for (uint32_t i = 0; i < descriptorSetCount; ++i) {
+            pDescriptorSets[i] = in_struct->pDescriptorSets[i];
+        }
+    }
+
+    if (in_struct->pDynamicOffsets) {
+        pDynamicOffsets = new uint32_t[in_struct->dynamicOffsetCount];
+        memcpy((void*)pDynamicOffsets, (void*)in_struct->pDynamicOffsets, sizeof(uint32_t) * in_struct->dynamicOffsetCount);
+    }
+}
+
+safe_VkBindDescriptorSetsInfo::safe_VkBindDescriptorSetsInfo()
+    : sType(VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO),
+      pNext(nullptr),
+      stageFlags(),
+      layout(),
+      firstSet(),
+      descriptorSetCount(),
+      pDescriptorSets(nullptr),
+      dynamicOffsetCount(),
+      pDynamicOffsets(nullptr) {}
+
+safe_VkBindDescriptorSetsInfo::safe_VkBindDescriptorSetsInfo(const safe_VkBindDescriptorSetsInfo& copy_src) {
+    sType = copy_src.sType;
+    stageFlags = copy_src.stageFlags;
+    layout = copy_src.layout;
+    firstSet = copy_src.firstSet;
+    descriptorSetCount = copy_src.descriptorSetCount;
+    pDescriptorSets = nullptr;
+    dynamicOffsetCount = copy_src.dynamicOffsetCount;
+    pDynamicOffsets = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (descriptorSetCount && copy_src.pDescriptorSets) {
+        pDescriptorSets = new VkDescriptorSet[descriptorSetCount];
+        for (uint32_t i = 0; i < descriptorSetCount; ++i) {
+            pDescriptorSets[i] = copy_src.pDescriptorSets[i];
+        }
+    }
+
+    if (copy_src.pDynamicOffsets) {
+        pDynamicOffsets = new uint32_t[copy_src.dynamicOffsetCount];
+        memcpy((void*)pDynamicOffsets, (void*)copy_src.pDynamicOffsets, sizeof(uint32_t) * copy_src.dynamicOffsetCount);
+    }
+}
+
+safe_VkBindDescriptorSetsInfo& safe_VkBindDescriptorSetsInfo::operator=(const safe_VkBindDescriptorSetsInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pDescriptorSets) delete[] pDescriptorSets;
+    if (pDynamicOffsets) delete[] pDynamicOffsets;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    stageFlags = copy_src.stageFlags;
+    layout = copy_src.layout;
+    firstSet = copy_src.firstSet;
+    descriptorSetCount = copy_src.descriptorSetCount;
+    pDescriptorSets = nullptr;
+    dynamicOffsetCount = copy_src.dynamicOffsetCount;
+    pDynamicOffsets = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (descriptorSetCount && copy_src.pDescriptorSets) {
+        pDescriptorSets = new VkDescriptorSet[descriptorSetCount];
+        for (uint32_t i = 0; i < descriptorSetCount; ++i) {
+            pDescriptorSets[i] = copy_src.pDescriptorSets[i];
+        }
+    }
+
+    if (copy_src.pDynamicOffsets) {
+        pDynamicOffsets = new uint32_t[copy_src.dynamicOffsetCount];
+        memcpy((void*)pDynamicOffsets, (void*)copy_src.pDynamicOffsets, sizeof(uint32_t) * copy_src.dynamicOffsetCount);
+    }
+
+    return *this;
+}
+
+safe_VkBindDescriptorSetsInfo::~safe_VkBindDescriptorSetsInfo() {
+    if (pDescriptorSets) delete[] pDescriptorSets;
+    if (pDynamicOffsets) delete[] pDynamicOffsets;
+    FreePnextChain(pNext);
+}
+
+void safe_VkBindDescriptorSetsInfo::initialize(const VkBindDescriptorSetsInfo* in_struct,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pDescriptorSets) delete[] pDescriptorSets;
+    if (pDynamicOffsets) delete[] pDynamicOffsets;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    stageFlags = in_struct->stageFlags;
+    layout = in_struct->layout;
+    firstSet = in_struct->firstSet;
+    descriptorSetCount = in_struct->descriptorSetCount;
+    pDescriptorSets = nullptr;
+    dynamicOffsetCount = in_struct->dynamicOffsetCount;
+    pDynamicOffsets = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (descriptorSetCount && in_struct->pDescriptorSets) {
+        pDescriptorSets = new VkDescriptorSet[descriptorSetCount];
+        for (uint32_t i = 0; i < descriptorSetCount; ++i) {
+            pDescriptorSets[i] = in_struct->pDescriptorSets[i];
+        }
+    }
+
+    if (in_struct->pDynamicOffsets) {
+        pDynamicOffsets = new uint32_t[in_struct->dynamicOffsetCount];
+        memcpy((void*)pDynamicOffsets, (void*)in_struct->pDynamicOffsets, sizeof(uint32_t) * in_struct->dynamicOffsetCount);
+    }
+}
+
+void safe_VkBindDescriptorSetsInfo::initialize(const safe_VkBindDescriptorSetsInfo* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stageFlags = copy_src->stageFlags;
+    layout = copy_src->layout;
+    firstSet = copy_src->firstSet;
+    descriptorSetCount = copy_src->descriptorSetCount;
+    pDescriptorSets = nullptr;
+    dynamicOffsetCount = copy_src->dynamicOffsetCount;
+    pDynamicOffsets = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (descriptorSetCount && copy_src->pDescriptorSets) {
+        pDescriptorSets = new VkDescriptorSet[descriptorSetCount];
+        for (uint32_t i = 0; i < descriptorSetCount; ++i) {
+            pDescriptorSets[i] = copy_src->pDescriptorSets[i];
+        }
+    }
+
+    if (copy_src->pDynamicOffsets) {
+        pDynamicOffsets = new uint32_t[copy_src->dynamicOffsetCount];
+        memcpy((void*)pDynamicOffsets, (void*)copy_src->pDynamicOffsets, sizeof(uint32_t) * copy_src->dynamicOffsetCount);
+    }
+}
+
+safe_VkPushConstantsInfo::safe_VkPushConstantsInfo(const VkPushConstantsInfo* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      layout(in_struct->layout),
+      stageFlags(in_struct->stageFlags),
+      offset(in_struct->offset),
+      size(in_struct->size),
+      pValues(in_struct->pValues) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPushConstantsInfo::safe_VkPushConstantsInfo()
+    : sType(VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO), pNext(nullptr), layout(), stageFlags(), offset(), size(), pValues(nullptr) {}
+
+safe_VkPushConstantsInfo::safe_VkPushConstantsInfo(const safe_VkPushConstantsInfo& copy_src) {
+    sType = copy_src.sType;
+    layout = copy_src.layout;
+    stageFlags = copy_src.stageFlags;
+    offset = copy_src.offset;
+    size = copy_src.size;
+    pValues = copy_src.pValues;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPushConstantsInfo& safe_VkPushConstantsInfo::operator=(const safe_VkPushConstantsInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    layout = copy_src.layout;
+    stageFlags = copy_src.stageFlags;
+    offset = copy_src.offset;
+    size = copy_src.size;
+    pValues = copy_src.pValues;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPushConstantsInfo::~safe_VkPushConstantsInfo() { FreePnextChain(pNext); }
+
+void safe_VkPushConstantsInfo::initialize(const VkPushConstantsInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    layout = in_struct->layout;
+    stageFlags = in_struct->stageFlags;
+    offset = in_struct->offset;
+    size = in_struct->size;
+    pValues = in_struct->pValues;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPushConstantsInfo::initialize(const safe_VkPushConstantsInfo* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    layout = copy_src->layout;
+    stageFlags = copy_src->stageFlags;
+    offset = copy_src->offset;
+    size = copy_src->size;
+    pValues = copy_src->pValues;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPushDescriptorSetInfo::safe_VkPushDescriptorSetInfo(const VkPushDescriptorSetInfo* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      stageFlags(in_struct->stageFlags),
+      layout(in_struct->layout),
+      set(in_struct->set),
+      descriptorWriteCount(in_struct->descriptorWriteCount),
+      pDescriptorWrites(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (descriptorWriteCount && in_struct->pDescriptorWrites) {
+        pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount];
+        for (uint32_t i = 0; i < descriptorWriteCount; ++i) {
+            pDescriptorWrites[i].initialize(&in_struct->pDescriptorWrites[i]);
+        }
+    }
+}
+
+safe_VkPushDescriptorSetInfo::safe_VkPushDescriptorSetInfo()
+    : sType(VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO),
+      pNext(nullptr),
+      stageFlags(),
+      layout(),
+      set(),
+      descriptorWriteCount(),
+      pDescriptorWrites(nullptr) {}
+
+safe_VkPushDescriptorSetInfo::safe_VkPushDescriptorSetInfo(const safe_VkPushDescriptorSetInfo& copy_src) {
+    sType = copy_src.sType;
+    stageFlags = copy_src.stageFlags;
+    layout = copy_src.layout;
+    set = copy_src.set;
+    descriptorWriteCount = copy_src.descriptorWriteCount;
+    pDescriptorWrites = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (descriptorWriteCount && copy_src.pDescriptorWrites) {
+        pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount];
+        for (uint32_t i = 0; i < descriptorWriteCount; ++i) {
+            pDescriptorWrites[i].initialize(&copy_src.pDescriptorWrites[i]);
+        }
+    }
+}
+
+safe_VkPushDescriptorSetInfo& safe_VkPushDescriptorSetInfo::operator=(const safe_VkPushDescriptorSetInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pDescriptorWrites) delete[] pDescriptorWrites;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    stageFlags = copy_src.stageFlags;
+    layout = copy_src.layout;
+    set = copy_src.set;
+    descriptorWriteCount = copy_src.descriptorWriteCount;
+    pDescriptorWrites = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (descriptorWriteCount && copy_src.pDescriptorWrites) {
+        pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount];
+        for (uint32_t i = 0; i < descriptorWriteCount; ++i) {
+            pDescriptorWrites[i].initialize(&copy_src.pDescriptorWrites[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkPushDescriptorSetInfo::~safe_VkPushDescriptorSetInfo() {
+    if (pDescriptorWrites) delete[] pDescriptorWrites;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPushDescriptorSetInfo::initialize(const VkPushDescriptorSetInfo* in_struct,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pDescriptorWrites) delete[] pDescriptorWrites;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    stageFlags = in_struct->stageFlags;
+    layout = in_struct->layout;
+    set = in_struct->set;
+    descriptorWriteCount = in_struct->descriptorWriteCount;
+    pDescriptorWrites = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (descriptorWriteCount && in_struct->pDescriptorWrites) {
+        pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount];
+        for (uint32_t i = 0; i < descriptorWriteCount; ++i) {
+            pDescriptorWrites[i].initialize(&in_struct->pDescriptorWrites[i]);
+        }
+    }
+}
+
+void safe_VkPushDescriptorSetInfo::initialize(const safe_VkPushDescriptorSetInfo* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stageFlags = copy_src->stageFlags;
+    layout = copy_src->layout;
+    set = copy_src->set;
+    descriptorWriteCount = copy_src->descriptorWriteCount;
+    pDescriptorWrites = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (descriptorWriteCount && copy_src->pDescriptorWrites) {
+        pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount];
+        for (uint32_t i = 0; i < descriptorWriteCount; ++i) {
+            pDescriptorWrites[i].initialize(&copy_src->pDescriptorWrites[i]);
+        }
+    }
+}
+
+safe_VkPushDescriptorSetWithTemplateInfo::safe_VkPushDescriptorSetWithTemplateInfo(
+    const VkPushDescriptorSetWithTemplateInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      descriptorUpdateTemplate(in_struct->descriptorUpdateTemplate),
+      layout(in_struct->layout),
+      set(in_struct->set),
+      pData(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPushDescriptorSetWithTemplateInfo::safe_VkPushDescriptorSetWithTemplateInfo()
+    : sType(VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO),
+      pNext(nullptr),
+      descriptorUpdateTemplate(),
+      layout(),
+      set(),
+      pData(nullptr) {}
+
+safe_VkPushDescriptorSetWithTemplateInfo::safe_VkPushDescriptorSetWithTemplateInfo(
+    const safe_VkPushDescriptorSetWithTemplateInfo& copy_src) {
+    sType = copy_src.sType;
+    descriptorUpdateTemplate = copy_src.descriptorUpdateTemplate;
+    layout = copy_src.layout;
+    set = copy_src.set;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPushDescriptorSetWithTemplateInfo& safe_VkPushDescriptorSetWithTemplateInfo::operator=(
+    const safe_VkPushDescriptorSetWithTemplateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pData != nullptr) {
+        auto temp = reinterpret_cast<const std::byte*>(pData);
+        delete[] temp;
+    }
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    descriptorUpdateTemplate = copy_src.descriptorUpdateTemplate;
+    layout = copy_src.layout;
+    set = copy_src.set;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPushDescriptorSetWithTemplateInfo::~safe_VkPushDescriptorSetWithTemplateInfo() {
+    if (pData != nullptr) {
+        auto temp = reinterpret_cast<const std::byte*>(pData);
+        delete[] temp;
+    }
+    FreePnextChain(pNext);
+}
+
+void safe_VkPushDescriptorSetWithTemplateInfo::initialize(const VkPushDescriptorSetWithTemplateInfo* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pData != nullptr) {
+        auto temp = reinterpret_cast<const std::byte*>(pData);
+        delete[] temp;
+    }
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    descriptorUpdateTemplate = in_struct->descriptorUpdateTemplate;
+    layout = in_struct->layout;
+    set = in_struct->set;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPushDescriptorSetWithTemplateInfo::initialize(const safe_VkPushDescriptorSetWithTemplateInfo* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    descriptorUpdateTemplate = copy_src->descriptorUpdateTemplate;
+    layout = copy_src->layout;
+    set = copy_src->set;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDevicePipelineProtectedAccessFeatures::safe_VkPhysicalDevicePipelineProtectedAccessFeatures(
+    const VkPhysicalDevicePipelineProtectedAccessFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), pipelineProtectedAccess(in_struct->pipelineProtectedAccess) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePipelineProtectedAccessFeatures::safe_VkPhysicalDevicePipelineProtectedAccessFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES), pNext(nullptr), pipelineProtectedAccess() {}
+
+safe_VkPhysicalDevicePipelineProtectedAccessFeatures::safe_VkPhysicalDevicePipelineProtectedAccessFeatures(
+    const safe_VkPhysicalDevicePipelineProtectedAccessFeatures& copy_src) {
+    sType = copy_src.sType;
+    pipelineProtectedAccess = copy_src.pipelineProtectedAccess;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePipelineProtectedAccessFeatures& safe_VkPhysicalDevicePipelineProtectedAccessFeatures::operator=(
+    const safe_VkPhysicalDevicePipelineProtectedAccessFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pipelineProtectedAccess = copy_src.pipelineProtectedAccess;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePipelineProtectedAccessFeatures::~safe_VkPhysicalDevicePipelineProtectedAccessFeatures() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDevicePipelineProtectedAccessFeatures::initialize(
+    const VkPhysicalDevicePipelineProtectedAccessFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pipelineProtectedAccess = in_struct->pipelineProtectedAccess;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePipelineProtectedAccessFeatures::initialize(
+    const safe_VkPhysicalDevicePipelineProtectedAccessFeatures* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pipelineProtectedAccess = copy_src->pipelineProtectedAccess;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDevicePipelineRobustnessFeatures::safe_VkPhysicalDevicePipelineRobustnessFeatures(
+    const VkPhysicalDevicePipelineRobustnessFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), pipelineRobustness(in_struct->pipelineRobustness) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePipelineRobustnessFeatures::safe_VkPhysicalDevicePipelineRobustnessFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES), pNext(nullptr), pipelineRobustness() {}
+
+safe_VkPhysicalDevicePipelineRobustnessFeatures::safe_VkPhysicalDevicePipelineRobustnessFeatures(
+    const safe_VkPhysicalDevicePipelineRobustnessFeatures& copy_src) {
+    sType = copy_src.sType;
+    pipelineRobustness = copy_src.pipelineRobustness;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePipelineRobustnessFeatures& safe_VkPhysicalDevicePipelineRobustnessFeatures::operator=(
+    const safe_VkPhysicalDevicePipelineRobustnessFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pipelineRobustness = copy_src.pipelineRobustness;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePipelineRobustnessFeatures::~safe_VkPhysicalDevicePipelineRobustnessFeatures() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDevicePipelineRobustnessFeatures::initialize(const VkPhysicalDevicePipelineRobustnessFeatures* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pipelineRobustness = in_struct->pipelineRobustness;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePipelineRobustnessFeatures::initialize(const safe_VkPhysicalDevicePipelineRobustnessFeatures* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pipelineRobustness = copy_src->pipelineRobustness;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDevicePipelineRobustnessProperties::safe_VkPhysicalDevicePipelineRobustnessProperties(
+    const VkPhysicalDevicePipelineRobustnessProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      defaultRobustnessStorageBuffers(in_struct->defaultRobustnessStorageBuffers),
+      defaultRobustnessUniformBuffers(in_struct->defaultRobustnessUniformBuffers),
+      defaultRobustnessVertexInputs(in_struct->defaultRobustnessVertexInputs),
+      defaultRobustnessImages(in_struct->defaultRobustnessImages) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePipelineRobustnessProperties::safe_VkPhysicalDevicePipelineRobustnessProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES),
+      pNext(nullptr),
+      defaultRobustnessStorageBuffers(),
+      defaultRobustnessUniformBuffers(),
+      defaultRobustnessVertexInputs(),
+      defaultRobustnessImages() {}
+
+safe_VkPhysicalDevicePipelineRobustnessProperties::safe_VkPhysicalDevicePipelineRobustnessProperties(
+    const safe_VkPhysicalDevicePipelineRobustnessProperties& copy_src) {
+    sType = copy_src.sType;
+    defaultRobustnessStorageBuffers = copy_src.defaultRobustnessStorageBuffers;
+    defaultRobustnessUniformBuffers = copy_src.defaultRobustnessUniformBuffers;
+    defaultRobustnessVertexInputs = copy_src.defaultRobustnessVertexInputs;
+    defaultRobustnessImages = copy_src.defaultRobustnessImages;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePipelineRobustnessProperties& safe_VkPhysicalDevicePipelineRobustnessProperties::operator=(
+    const safe_VkPhysicalDevicePipelineRobustnessProperties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    defaultRobustnessStorageBuffers = copy_src.defaultRobustnessStorageBuffers;
+    defaultRobustnessUniformBuffers = copy_src.defaultRobustnessUniformBuffers;
+    defaultRobustnessVertexInputs = copy_src.defaultRobustnessVertexInputs;
+    defaultRobustnessImages = copy_src.defaultRobustnessImages;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePipelineRobustnessProperties::~safe_VkPhysicalDevicePipelineRobustnessProperties() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDevicePipelineRobustnessProperties::initialize(const VkPhysicalDevicePipelineRobustnessProperties* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    defaultRobustnessStorageBuffers = in_struct->defaultRobustnessStorageBuffers;
+    defaultRobustnessUniformBuffers = in_struct->defaultRobustnessUniformBuffers;
+    defaultRobustnessVertexInputs = in_struct->defaultRobustnessVertexInputs;
+    defaultRobustnessImages = in_struct->defaultRobustnessImages;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePipelineRobustnessProperties::initialize(
+    const safe_VkPhysicalDevicePipelineRobustnessProperties* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    defaultRobustnessStorageBuffers = copy_src->defaultRobustnessStorageBuffers;
+    defaultRobustnessUniformBuffers = copy_src->defaultRobustnessUniformBuffers;
+    defaultRobustnessVertexInputs = copy_src->defaultRobustnessVertexInputs;
+    defaultRobustnessImages = copy_src->defaultRobustnessImages;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPipelineRobustnessCreateInfo::safe_VkPipelineRobustnessCreateInfo(const VkPipelineRobustnessCreateInfo* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType),
+      storageBuffers(in_struct->storageBuffers),
+      uniformBuffers(in_struct->uniformBuffers),
+      vertexInputs(in_struct->vertexInputs),
+      images(in_struct->images) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPipelineRobustnessCreateInfo::safe_VkPipelineRobustnessCreateInfo()
+    : sType(VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO),
+      pNext(nullptr),
+      storageBuffers(),
+      uniformBuffers(),
+      vertexInputs(),
+      images() {}
+
+safe_VkPipelineRobustnessCreateInfo::safe_VkPipelineRobustnessCreateInfo(const safe_VkPipelineRobustnessCreateInfo& copy_src) {
+    sType = copy_src.sType;
+    storageBuffers = copy_src.storageBuffers;
+    uniformBuffers = copy_src.uniformBuffers;
+    vertexInputs = copy_src.vertexInputs;
+    images = copy_src.images;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPipelineRobustnessCreateInfo& safe_VkPipelineRobustnessCreateInfo::operator=(
+    const safe_VkPipelineRobustnessCreateInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    storageBuffers = copy_src.storageBuffers;
+    uniformBuffers = copy_src.uniformBuffers;
+    vertexInputs = copy_src.vertexInputs;
+    images = copy_src.images;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineRobustnessCreateInfo::~safe_VkPipelineRobustnessCreateInfo() { FreePnextChain(pNext); }
+
+void safe_VkPipelineRobustnessCreateInfo::initialize(const VkPipelineRobustnessCreateInfo* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    storageBuffers = in_struct->storageBuffers;
+    uniformBuffers = in_struct->uniformBuffers;
+    vertexInputs = in_struct->vertexInputs;
+    images = in_struct->images;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPipelineRobustnessCreateInfo::initialize(const safe_VkPipelineRobustnessCreateInfo* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    storageBuffers = copy_src->storageBuffers;
+    uniformBuffers = copy_src->uniformBuffers;
+    vertexInputs = copy_src->vertexInputs;
+    images = copy_src->images;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceHostImageCopyFeatures::safe_VkPhysicalDeviceHostImageCopyFeatures(
+    const VkPhysicalDeviceHostImageCopyFeatures* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), hostImageCopy(in_struct->hostImageCopy) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceHostImageCopyFeatures::safe_VkPhysicalDeviceHostImageCopyFeatures()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES), pNext(nullptr), hostImageCopy() {}
+
+safe_VkPhysicalDeviceHostImageCopyFeatures::safe_VkPhysicalDeviceHostImageCopyFeatures(
+    const safe_VkPhysicalDeviceHostImageCopyFeatures& copy_src) {
+    sType = copy_src.sType;
+    hostImageCopy = copy_src.hostImageCopy;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceHostImageCopyFeatures& safe_VkPhysicalDeviceHostImageCopyFeatures::operator=(
+    const safe_VkPhysicalDeviceHostImageCopyFeatures& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    hostImageCopy = copy_src.hostImageCopy;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceHostImageCopyFeatures::~safe_VkPhysicalDeviceHostImageCopyFeatures() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceHostImageCopyFeatures::initialize(const VkPhysicalDeviceHostImageCopyFeatures* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    hostImageCopy = in_struct->hostImageCopy;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceHostImageCopyFeatures::initialize(const safe_VkPhysicalDeviceHostImageCopyFeatures* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    hostImageCopy = copy_src->hostImageCopy;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceHostImageCopyProperties::safe_VkPhysicalDeviceHostImageCopyProperties(
+    const VkPhysicalDeviceHostImageCopyProperties* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      copySrcLayoutCount(in_struct->copySrcLayoutCount),
+      pCopySrcLayouts(nullptr),
+      copyDstLayoutCount(in_struct->copyDstLayoutCount),
+      pCopyDstLayouts(nullptr),
+      identicalMemoryTypeRequirements(in_struct->identicalMemoryTypeRequirements) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pCopySrcLayouts) {
+        pCopySrcLayouts = new VkImageLayout[in_struct->copySrcLayoutCount];
+        memcpy((void*)pCopySrcLayouts, (void*)in_struct->pCopySrcLayouts, sizeof(VkImageLayout) * in_struct->copySrcLayoutCount);
+    }
+
+    if (in_struct->pCopyDstLayouts) {
+        pCopyDstLayouts = new VkImageLayout[in_struct->copyDstLayoutCount];
+        memcpy((void*)pCopyDstLayouts, (void*)in_struct->pCopyDstLayouts, sizeof(VkImageLayout) * in_struct->copyDstLayoutCount);
+    }
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        optimalTilingLayoutUUID[i] = in_struct->optimalTilingLayoutUUID[i];
+    }
+}
+
+safe_VkPhysicalDeviceHostImageCopyProperties::safe_VkPhysicalDeviceHostImageCopyProperties()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES),
+      pNext(nullptr),
+      copySrcLayoutCount(),
+      pCopySrcLayouts(nullptr),
+      copyDstLayoutCount(),
+      pCopyDstLayouts(nullptr),
+      identicalMemoryTypeRequirements() {}
+
+safe_VkPhysicalDeviceHostImageCopyProperties::safe_VkPhysicalDeviceHostImageCopyProperties(
+    const safe_VkPhysicalDeviceHostImageCopyProperties& copy_src) {
+    sType = copy_src.sType;
+    copySrcLayoutCount = copy_src.copySrcLayoutCount;
+    pCopySrcLayouts = nullptr;
+    copyDstLayoutCount = copy_src.copyDstLayoutCount;
+    pCopyDstLayouts = nullptr;
+    identicalMemoryTypeRequirements = copy_src.identicalMemoryTypeRequirements;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pCopySrcLayouts) {
+        pCopySrcLayouts = new VkImageLayout[copy_src.copySrcLayoutCount];
+        memcpy((void*)pCopySrcLayouts, (void*)copy_src.pCopySrcLayouts, sizeof(VkImageLayout) * copy_src.copySrcLayoutCount);
+    }
+
+    if (copy_src.pCopyDstLayouts) {
+        pCopyDstLayouts = new VkImageLayout[copy_src.copyDstLayoutCount];
+        memcpy((void*)pCopyDstLayouts, (void*)copy_src.pCopyDstLayouts, sizeof(VkImageLayout) * copy_src.copyDstLayoutCount);
+    }
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        optimalTilingLayoutUUID[i] = copy_src.optimalTilingLayoutUUID[i];
+    }
+}
+
+safe_VkPhysicalDeviceHostImageCopyProperties& safe_VkPhysicalDeviceHostImageCopyProperties::operator=(
+    const safe_VkPhysicalDeviceHostImageCopyProperties& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pCopySrcLayouts) delete[] pCopySrcLayouts;
+    if (pCopyDstLayouts) delete[] pCopyDstLayouts;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    copySrcLayoutCount = copy_src.copySrcLayoutCount;
+    pCopySrcLayouts = nullptr;
+    copyDstLayoutCount = copy_src.copyDstLayoutCount;
+    pCopyDstLayouts = nullptr;
+    identicalMemoryTypeRequirements = copy_src.identicalMemoryTypeRequirements;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pCopySrcLayouts) {
+        pCopySrcLayouts = new VkImageLayout[copy_src.copySrcLayoutCount];
+        memcpy((void*)pCopySrcLayouts, (void*)copy_src.pCopySrcLayouts, sizeof(VkImageLayout) * copy_src.copySrcLayoutCount);
+    }
+
+    if (copy_src.pCopyDstLayouts) {
+        pCopyDstLayouts = new VkImageLayout[copy_src.copyDstLayoutCount];
+        memcpy((void*)pCopyDstLayouts, (void*)copy_src.pCopyDstLayouts, sizeof(VkImageLayout) * copy_src.copyDstLayoutCount);
+    }
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        optimalTilingLayoutUUID[i] = copy_src.optimalTilingLayoutUUID[i];
+    }
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceHostImageCopyProperties::~safe_VkPhysicalDeviceHostImageCopyProperties() {
+    if (pCopySrcLayouts) delete[] pCopySrcLayouts;
+    if (pCopyDstLayouts) delete[] pCopyDstLayouts;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceHostImageCopyProperties::initialize(const VkPhysicalDeviceHostImageCopyProperties* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pCopySrcLayouts) delete[] pCopySrcLayouts;
+    if (pCopyDstLayouts) delete[] pCopyDstLayouts;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    copySrcLayoutCount = in_struct->copySrcLayoutCount;
+    pCopySrcLayouts = nullptr;
+    copyDstLayoutCount = in_struct->copyDstLayoutCount;
+    pCopyDstLayouts = nullptr;
+    identicalMemoryTypeRequirements = in_struct->identicalMemoryTypeRequirements;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pCopySrcLayouts) {
+        pCopySrcLayouts = new VkImageLayout[in_struct->copySrcLayoutCount];
+        memcpy((void*)pCopySrcLayouts, (void*)in_struct->pCopySrcLayouts, sizeof(VkImageLayout) * in_struct->copySrcLayoutCount);
+    }
+
+    if (in_struct->pCopyDstLayouts) {
+        pCopyDstLayouts = new VkImageLayout[in_struct->copyDstLayoutCount];
+        memcpy((void*)pCopyDstLayouts, (void*)in_struct->pCopyDstLayouts, sizeof(VkImageLayout) * in_struct->copyDstLayoutCount);
+    }
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        optimalTilingLayoutUUID[i] = in_struct->optimalTilingLayoutUUID[i];
+    }
+}
+
+void safe_VkPhysicalDeviceHostImageCopyProperties::initialize(const safe_VkPhysicalDeviceHostImageCopyProperties* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    copySrcLayoutCount = copy_src->copySrcLayoutCount;
+    pCopySrcLayouts = nullptr;
+    copyDstLayoutCount = copy_src->copyDstLayoutCount;
+    pCopyDstLayouts = nullptr;
+    identicalMemoryTypeRequirements = copy_src->identicalMemoryTypeRequirements;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pCopySrcLayouts) {
+        pCopySrcLayouts = new VkImageLayout[copy_src->copySrcLayoutCount];
+        memcpy((void*)pCopySrcLayouts, (void*)copy_src->pCopySrcLayouts, sizeof(VkImageLayout) * copy_src->copySrcLayoutCount);
+    }
+
+    if (copy_src->pCopyDstLayouts) {
+        pCopyDstLayouts = new VkImageLayout[copy_src->copyDstLayoutCount];
+        memcpy((void*)pCopyDstLayouts, (void*)copy_src->pCopyDstLayouts, sizeof(VkImageLayout) * copy_src->copyDstLayoutCount);
+    }
+
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
+        optimalTilingLayoutUUID[i] = copy_src->optimalTilingLayoutUUID[i];
+    }
+}
+
+safe_VkMemoryToImageCopy::safe_VkMemoryToImageCopy(const VkMemoryToImageCopy* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      pHostPointer(in_struct->pHostPointer),
+      memoryRowLength(in_struct->memoryRowLength),
+      memoryImageHeight(in_struct->memoryImageHeight),
+      imageSubresource(in_struct->imageSubresource),
+      imageOffset(in_struct->imageOffset),
+      imageExtent(in_struct->imageExtent) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMemoryToImageCopy::safe_VkMemoryToImageCopy()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY),
+      pNext(nullptr),
+      pHostPointer(nullptr),
+      memoryRowLength(),
+      memoryImageHeight(),
+      imageSubresource(),
+      imageOffset(),
+      imageExtent() {}
+
+safe_VkMemoryToImageCopy::safe_VkMemoryToImageCopy(const safe_VkMemoryToImageCopy& copy_src) {
+    sType = copy_src.sType;
+    pHostPointer = copy_src.pHostPointer;
+    memoryRowLength = copy_src.memoryRowLength;
+    memoryImageHeight = copy_src.memoryImageHeight;
+    imageSubresource = copy_src.imageSubresource;
+    imageOffset = copy_src.imageOffset;
+    imageExtent = copy_src.imageExtent;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMemoryToImageCopy& safe_VkMemoryToImageCopy::operator=(const safe_VkMemoryToImageCopy& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pHostPointer = copy_src.pHostPointer;
+    memoryRowLength = copy_src.memoryRowLength;
+    memoryImageHeight = copy_src.memoryImageHeight;
+    imageSubresource = copy_src.imageSubresource;
+    imageOffset = copy_src.imageOffset;
+    imageExtent = copy_src.imageExtent;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMemoryToImageCopy::~safe_VkMemoryToImageCopy() { FreePnextChain(pNext); }
+
+void safe_VkMemoryToImageCopy::initialize(const VkMemoryToImageCopy* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pHostPointer = in_struct->pHostPointer;
+    memoryRowLength = in_struct->memoryRowLength;
+    memoryImageHeight = in_struct->memoryImageHeight;
+    imageSubresource = in_struct->imageSubresource;
+    imageOffset = in_struct->imageOffset;
+    imageExtent = in_struct->imageExtent;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMemoryToImageCopy::initialize(const safe_VkMemoryToImageCopy* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pHostPointer = copy_src->pHostPointer;
+    memoryRowLength = copy_src->memoryRowLength;
+    memoryImageHeight = copy_src->memoryImageHeight;
+    imageSubresource = copy_src->imageSubresource;
+    imageOffset = copy_src->imageOffset;
+    imageExtent = copy_src->imageExtent;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkImageToMemoryCopy::safe_VkImageToMemoryCopy(const VkImageToMemoryCopy* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      pHostPointer(in_struct->pHostPointer),
+      memoryRowLength(in_struct->memoryRowLength),
+      memoryImageHeight(in_struct->memoryImageHeight),
+      imageSubresource(in_struct->imageSubresource),
+      imageOffset(in_struct->imageOffset),
+      imageExtent(in_struct->imageExtent) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImageToMemoryCopy::safe_VkImageToMemoryCopy()
+    : sType(VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY),
+      pNext(nullptr),
+      pHostPointer(nullptr),
+      memoryRowLength(),
+      memoryImageHeight(),
+      imageSubresource(),
+      imageOffset(),
+      imageExtent() {}
+
+safe_VkImageToMemoryCopy::safe_VkImageToMemoryCopy(const safe_VkImageToMemoryCopy& copy_src) {
+    sType = copy_src.sType;
+    pHostPointer = copy_src.pHostPointer;
+    memoryRowLength = copy_src.memoryRowLength;
+    memoryImageHeight = copy_src.memoryImageHeight;
+    imageSubresource = copy_src.imageSubresource;
+    imageOffset = copy_src.imageOffset;
+    imageExtent = copy_src.imageExtent;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImageToMemoryCopy& safe_VkImageToMemoryCopy::operator=(const safe_VkImageToMemoryCopy& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pHostPointer = copy_src.pHostPointer;
+    memoryRowLength = copy_src.memoryRowLength;
+    memoryImageHeight = copy_src.memoryImageHeight;
+    imageSubresource = copy_src.imageSubresource;
+    imageOffset = copy_src.imageOffset;
+    imageExtent = copy_src.imageExtent;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImageToMemoryCopy::~safe_VkImageToMemoryCopy() { FreePnextChain(pNext); }
+
+void safe_VkImageToMemoryCopy::initialize(const VkImageToMemoryCopy* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pHostPointer = in_struct->pHostPointer;
+    memoryRowLength = in_struct->memoryRowLength;
+    memoryImageHeight = in_struct->memoryImageHeight;
+    imageSubresource = in_struct->imageSubresource;
+    imageOffset = in_struct->imageOffset;
+    imageExtent = in_struct->imageExtent;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImageToMemoryCopy::initialize(const safe_VkImageToMemoryCopy* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pHostPointer = copy_src->pHostPointer;
+    memoryRowLength = copy_src->memoryRowLength;
+    memoryImageHeight = copy_src->memoryImageHeight;
+    imageSubresource = copy_src->imageSubresource;
+    imageOffset = copy_src->imageOffset;
+    imageExtent = copy_src->imageExtent;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkCopyMemoryToImageInfo::safe_VkCopyMemoryToImageInfo(const VkCopyMemoryToImageInfo* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      dstImage(in_struct->dstImage),
+      dstImageLayout(in_struct->dstImageLayout),
+      regionCount(in_struct->regionCount),
+      pRegions(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (regionCount && in_struct->pRegions) {
+        pRegions = new safe_VkMemoryToImageCopy[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+safe_VkCopyMemoryToImageInfo::safe_VkCopyMemoryToImageInfo()
+    : sType(VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO),
+      pNext(nullptr),
+      flags(),
+      dstImage(),
+      dstImageLayout(),
+      regionCount(),
+      pRegions(nullptr) {}
+
+safe_VkCopyMemoryToImageInfo::safe_VkCopyMemoryToImageInfo(const safe_VkCopyMemoryToImageInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    dstImage = copy_src.dstImage;
+    dstImageLayout = copy_src.dstImageLayout;
+    regionCount = copy_src.regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (regionCount && copy_src.pRegions) {
+        pRegions = new safe_VkMemoryToImageCopy[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+}
+
+safe_VkCopyMemoryToImageInfo& safe_VkCopyMemoryToImageInfo::operator=(const safe_VkCopyMemoryToImageInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    dstImage = copy_src.dstImage;
+    dstImageLayout = copy_src.dstImageLayout;
+    regionCount = copy_src.regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (regionCount && copy_src.pRegions) {
+        pRegions = new safe_VkMemoryToImageCopy[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkCopyMemoryToImageInfo::~safe_VkCopyMemoryToImageInfo() {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+}
+
+void safe_VkCopyMemoryToImageInfo::initialize(const VkCopyMemoryToImageInfo* in_struct,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    dstImage = in_struct->dstImage;
+    dstImageLayout = in_struct->dstImageLayout;
+    regionCount = in_struct->regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (regionCount && in_struct->pRegions) {
+        pRegions = new safe_VkMemoryToImageCopy[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+void safe_VkCopyMemoryToImageInfo::initialize(const safe_VkCopyMemoryToImageInfo* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    dstImage = copy_src->dstImage;
+    dstImageLayout = copy_src->dstImageLayout;
+    regionCount = copy_src->regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (regionCount && copy_src->pRegions) {
+        pRegions = new safe_VkMemoryToImageCopy[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src->pRegions[i]);
+        }
+    }
+}
+
+safe_VkCopyImageToMemoryInfo::safe_VkCopyImageToMemoryInfo(const VkCopyImageToMemoryInfo* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      srcImage(in_struct->srcImage),
+      srcImageLayout(in_struct->srcImageLayout),
+      regionCount(in_struct->regionCount),
+      pRegions(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (regionCount && in_struct->pRegions) {
+        pRegions = new safe_VkImageToMemoryCopy[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+safe_VkCopyImageToMemoryInfo::safe_VkCopyImageToMemoryInfo()
+    : sType(VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO),
+      pNext(nullptr),
+      flags(),
+      srcImage(),
+      srcImageLayout(),
+      regionCount(),
+      pRegions(nullptr) {}
+
+safe_VkCopyImageToMemoryInfo::safe_VkCopyImageToMemoryInfo(const safe_VkCopyImageToMemoryInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    srcImage = copy_src.srcImage;
+    srcImageLayout = copy_src.srcImageLayout;
+    regionCount = copy_src.regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (regionCount && copy_src.pRegions) {
+        pRegions = new safe_VkImageToMemoryCopy[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+}
+
+safe_VkCopyImageToMemoryInfo& safe_VkCopyImageToMemoryInfo::operator=(const safe_VkCopyImageToMemoryInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    srcImage = copy_src.srcImage;
+    srcImageLayout = copy_src.srcImageLayout;
+    regionCount = copy_src.regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (regionCount && copy_src.pRegions) {
+        pRegions = new safe_VkImageToMemoryCopy[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkCopyImageToMemoryInfo::~safe_VkCopyImageToMemoryInfo() {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+}
+
+void safe_VkCopyImageToMemoryInfo::initialize(const VkCopyImageToMemoryInfo* in_struct,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    srcImage = in_struct->srcImage;
+    srcImageLayout = in_struct->srcImageLayout;
+    regionCount = in_struct->regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (regionCount && in_struct->pRegions) {
+        pRegions = new safe_VkImageToMemoryCopy[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+void safe_VkCopyImageToMemoryInfo::initialize(const safe_VkCopyImageToMemoryInfo* copy_src,
+                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    srcImage = copy_src->srcImage;
+    srcImageLayout = copy_src->srcImageLayout;
+    regionCount = copy_src->regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (regionCount && copy_src->pRegions) {
+        pRegions = new safe_VkImageToMemoryCopy[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src->pRegions[i]);
+        }
+    }
+}
+
+safe_VkCopyImageToImageInfo::safe_VkCopyImageToImageInfo(const VkCopyImageToImageInfo* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      srcImage(in_struct->srcImage),
+      srcImageLayout(in_struct->srcImageLayout),
+      dstImage(in_struct->dstImage),
+      dstImageLayout(in_struct->dstImageLayout),
+      regionCount(in_struct->regionCount),
+      pRegions(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (regionCount && in_struct->pRegions) {
+        pRegions = new safe_VkImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+safe_VkCopyImageToImageInfo::safe_VkCopyImageToImageInfo()
+    : sType(VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO),
+      pNext(nullptr),
+      flags(),
+      srcImage(),
+      srcImageLayout(),
+      dstImage(),
+      dstImageLayout(),
+      regionCount(),
+      pRegions(nullptr) {}
+
+safe_VkCopyImageToImageInfo::safe_VkCopyImageToImageInfo(const safe_VkCopyImageToImageInfo& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    srcImage = copy_src.srcImage;
+    srcImageLayout = copy_src.srcImageLayout;
+    dstImage = copy_src.dstImage;
+    dstImageLayout = copy_src.dstImageLayout;
+    regionCount = copy_src.regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (regionCount && copy_src.pRegions) {
+        pRegions = new safe_VkImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+}
+
+safe_VkCopyImageToImageInfo& safe_VkCopyImageToImageInfo::operator=(const safe_VkCopyImageToImageInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    srcImage = copy_src.srcImage;
+    srcImageLayout = copy_src.srcImageLayout;
+    dstImage = copy_src.dstImage;
+    dstImageLayout = copy_src.dstImageLayout;
+    regionCount = copy_src.regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (regionCount && copy_src.pRegions) {
+        pRegions = new safe_VkImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkCopyImageToImageInfo::~safe_VkCopyImageToImageInfo() {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+}
+
+void safe_VkCopyImageToImageInfo::initialize(const VkCopyImageToImageInfo* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    srcImage = in_struct->srcImage;
+    srcImageLayout = in_struct->srcImageLayout;
+    dstImage = in_struct->dstImage;
+    dstImageLayout = in_struct->dstImageLayout;
+    regionCount = in_struct->regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (regionCount && in_struct->pRegions) {
+        pRegions = new safe_VkImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+void safe_VkCopyImageToImageInfo::initialize(const safe_VkCopyImageToImageInfo* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    srcImage = copy_src->srcImage;
+    srcImageLayout = copy_src->srcImageLayout;
+    dstImage = copy_src->dstImage;
+    dstImageLayout = copy_src->dstImageLayout;
+    regionCount = copy_src->regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (regionCount && copy_src->pRegions) {
+        pRegions = new safe_VkImageCopy2[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src->pRegions[i]);
+        }
+    }
+}
+
+safe_VkHostImageLayoutTransitionInfo::safe_VkHostImageLayoutTransitionInfo(const VkHostImageLayoutTransitionInfo* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType),
+      image(in_struct->image),
+      oldLayout(in_struct->oldLayout),
+      newLayout(in_struct->newLayout),
+      subresourceRange(in_struct->subresourceRange) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkHostImageLayoutTransitionInfo::safe_VkHostImageLayoutTransitionInfo()
+    : sType(VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO),
+      pNext(nullptr),
+      image(),
+      oldLayout(),
+      newLayout(),
+      subresourceRange() {}
+
+safe_VkHostImageLayoutTransitionInfo::safe_VkHostImageLayoutTransitionInfo(const safe_VkHostImageLayoutTransitionInfo& copy_src) {
+    sType = copy_src.sType;
+    image = copy_src.image;
+    oldLayout = copy_src.oldLayout;
+    newLayout = copy_src.newLayout;
+    subresourceRange = copy_src.subresourceRange;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkHostImageLayoutTransitionInfo& safe_VkHostImageLayoutTransitionInfo::operator=(
+    const safe_VkHostImageLayoutTransitionInfo& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    image = copy_src.image;
+    oldLayout = copy_src.oldLayout;
+    newLayout = copy_src.newLayout;
+    subresourceRange = copy_src.subresourceRange;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkHostImageLayoutTransitionInfo::~safe_VkHostImageLayoutTransitionInfo() { FreePnextChain(pNext); }
+
+void safe_VkHostImageLayoutTransitionInfo::initialize(const VkHostImageLayoutTransitionInfo* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    image = in_struct->image;
+    oldLayout = in_struct->oldLayout;
+    newLayout = in_struct->newLayout;
+    subresourceRange = in_struct->subresourceRange;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkHostImageLayoutTransitionInfo::initialize(const safe_VkHostImageLayoutTransitionInfo* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    image = copy_src->image;
+    oldLayout = copy_src->oldLayout;
+    newLayout = copy_src->newLayout;
+    subresourceRange = copy_src->subresourceRange;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSubresourceHostMemcpySize::safe_VkSubresourceHostMemcpySize(const VkSubresourceHostMemcpySize* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), size(in_struct->size) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSubresourceHostMemcpySize::safe_VkSubresourceHostMemcpySize()
+    : sType(VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE), pNext(nullptr), size() {}
+
+safe_VkSubresourceHostMemcpySize::safe_VkSubresourceHostMemcpySize(const safe_VkSubresourceHostMemcpySize& copy_src) {
+    sType = copy_src.sType;
+    size = copy_src.size;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSubresourceHostMemcpySize& safe_VkSubresourceHostMemcpySize::operator=(const safe_VkSubresourceHostMemcpySize& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    size = copy_src.size;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSubresourceHostMemcpySize::~safe_VkSubresourceHostMemcpySize() { FreePnextChain(pNext); }
+
+void safe_VkSubresourceHostMemcpySize::initialize(const VkSubresourceHostMemcpySize* in_struct,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    size = in_struct->size;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSubresourceHostMemcpySize::initialize(const safe_VkSubresourceHostMemcpySize* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    size = copy_src->size;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkHostImageCopyDevicePerformanceQuery::safe_VkHostImageCopyDevicePerformanceQuery(
+    const VkHostImageCopyDevicePerformanceQuery* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      optimalDeviceAccess(in_struct->optimalDeviceAccess),
+      identicalMemoryLayout(in_struct->identicalMemoryLayout) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkHostImageCopyDevicePerformanceQuery::safe_VkHostImageCopyDevicePerformanceQuery()
+    : sType(VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY),
+      pNext(nullptr),
+      optimalDeviceAccess(),
+      identicalMemoryLayout() {}
+
+safe_VkHostImageCopyDevicePerformanceQuery::safe_VkHostImageCopyDevicePerformanceQuery(
+    const safe_VkHostImageCopyDevicePerformanceQuery& copy_src) {
+    sType = copy_src.sType;
+    optimalDeviceAccess = copy_src.optimalDeviceAccess;
+    identicalMemoryLayout = copy_src.identicalMemoryLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkHostImageCopyDevicePerformanceQuery& safe_VkHostImageCopyDevicePerformanceQuery::operator=(
+    const safe_VkHostImageCopyDevicePerformanceQuery& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    optimalDeviceAccess = copy_src.optimalDeviceAccess;
+    identicalMemoryLayout = copy_src.identicalMemoryLayout;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkHostImageCopyDevicePerformanceQuery::~safe_VkHostImageCopyDevicePerformanceQuery() { FreePnextChain(pNext); }
+
+void safe_VkHostImageCopyDevicePerformanceQuery::initialize(const VkHostImageCopyDevicePerformanceQuery* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    optimalDeviceAccess = in_struct->optimalDeviceAccess;
+    identicalMemoryLayout = in_struct->identicalMemoryLayout;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkHostImageCopyDevicePerformanceQuery::initialize(const safe_VkHostImageCopyDevicePerformanceQuery* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    optimalDeviceAccess = copy_src->optimalDeviceAccess;
+    identicalMemoryLayout = copy_src->identicalMemoryLayout;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 }  // namespace vku
 
 // NOLINTEND
diff --git a/src/vulkan/vk_safe_struct_ext.cpp b/src/vulkan/vk_safe_struct_ext.cpp
index 6ee2038..08abcf0 100644
--- a/src/vulkan/vk_safe_struct_ext.cpp
+++ b/src/vulkan/vk_safe_struct_ext.cpp
@@ -879,195 +879,6 @@ void safe_VkPhysicalDeviceASTCDecodeFeaturesEXT::initialize(const safe_VkPhysica
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
-safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT::safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
-    const VkPhysicalDevicePipelineRobustnessFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), pipelineRobustness(in_struct->pipelineRobustness) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT::safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT()
-    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT), pNext(nullptr), pipelineRobustness() {}
-
-safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT::safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
-    const safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT& copy_src) {
-    sType = copy_src.sType;
-    pipelineRobustness = copy_src.pipelineRobustness;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT& safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT::operator=(
-    const safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    pipelineRobustness = copy_src.pipelineRobustness;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT::~safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT() { FreePnextChain(pNext); }
-
-void safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT::initialize(const VkPhysicalDevicePipelineRobustnessFeaturesEXT* in_struct,
-                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    pipelineRobustness = in_struct->pipelineRobustness;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT::initialize(
-    const safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    pipelineRobustness = copy_src->pipelineRobustness;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT::safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
-    const VkPhysicalDevicePipelineRobustnessPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType),
-      defaultRobustnessStorageBuffers(in_struct->defaultRobustnessStorageBuffers),
-      defaultRobustnessUniformBuffers(in_struct->defaultRobustnessUniformBuffers),
-      defaultRobustnessVertexInputs(in_struct->defaultRobustnessVertexInputs),
-      defaultRobustnessImages(in_struct->defaultRobustnessImages) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT::safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT()
-    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT),
-      pNext(nullptr),
-      defaultRobustnessStorageBuffers(),
-      defaultRobustnessUniformBuffers(),
-      defaultRobustnessVertexInputs(),
-      defaultRobustnessImages() {}
-
-safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT::safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
-    const safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT& copy_src) {
-    sType = copy_src.sType;
-    defaultRobustnessStorageBuffers = copy_src.defaultRobustnessStorageBuffers;
-    defaultRobustnessUniformBuffers = copy_src.defaultRobustnessUniformBuffers;
-    defaultRobustnessVertexInputs = copy_src.defaultRobustnessVertexInputs;
-    defaultRobustnessImages = copy_src.defaultRobustnessImages;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT& safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT::operator=(
-    const safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    defaultRobustnessStorageBuffers = copy_src.defaultRobustnessStorageBuffers;
-    defaultRobustnessUniformBuffers = copy_src.defaultRobustnessUniformBuffers;
-    defaultRobustnessVertexInputs = copy_src.defaultRobustnessVertexInputs;
-    defaultRobustnessImages = copy_src.defaultRobustnessImages;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT::~safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT() {
-    FreePnextChain(pNext);
-}
-
-void safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT::initialize(
-    const VkPhysicalDevicePipelineRobustnessPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    defaultRobustnessStorageBuffers = in_struct->defaultRobustnessStorageBuffers;
-    defaultRobustnessUniformBuffers = in_struct->defaultRobustnessUniformBuffers;
-    defaultRobustnessVertexInputs = in_struct->defaultRobustnessVertexInputs;
-    defaultRobustnessImages = in_struct->defaultRobustnessImages;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT::initialize(
-    const safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    defaultRobustnessStorageBuffers = copy_src->defaultRobustnessStorageBuffers;
-    defaultRobustnessUniformBuffers = copy_src->defaultRobustnessUniformBuffers;
-    defaultRobustnessVertexInputs = copy_src->defaultRobustnessVertexInputs;
-    defaultRobustnessImages = copy_src->defaultRobustnessImages;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkPipelineRobustnessCreateInfoEXT::safe_VkPipelineRobustnessCreateInfoEXT(const VkPipelineRobustnessCreateInfoEXT* in_struct,
-                                                                               [[maybe_unused]] PNextCopyState* copy_state,
-                                                                               bool copy_pnext)
-    : sType(in_struct->sType),
-      storageBuffers(in_struct->storageBuffers),
-      uniformBuffers(in_struct->uniformBuffers),
-      vertexInputs(in_struct->vertexInputs),
-      images(in_struct->images) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkPipelineRobustnessCreateInfoEXT::safe_VkPipelineRobustnessCreateInfoEXT()
-    : sType(VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT),
-      pNext(nullptr),
-      storageBuffers(),
-      uniformBuffers(),
-      vertexInputs(),
-      images() {}
-
-safe_VkPipelineRobustnessCreateInfoEXT::safe_VkPipelineRobustnessCreateInfoEXT(
-    const safe_VkPipelineRobustnessCreateInfoEXT& copy_src) {
-    sType = copy_src.sType;
-    storageBuffers = copy_src.storageBuffers;
-    uniformBuffers = copy_src.uniformBuffers;
-    vertexInputs = copy_src.vertexInputs;
-    images = copy_src.images;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPipelineRobustnessCreateInfoEXT& safe_VkPipelineRobustnessCreateInfoEXT::operator=(
-    const safe_VkPipelineRobustnessCreateInfoEXT& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    storageBuffers = copy_src.storageBuffers;
-    uniformBuffers = copy_src.uniformBuffers;
-    vertexInputs = copy_src.vertexInputs;
-    images = copy_src.images;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkPipelineRobustnessCreateInfoEXT::~safe_VkPipelineRobustnessCreateInfoEXT() { FreePnextChain(pNext); }
-
-void safe_VkPipelineRobustnessCreateInfoEXT::initialize(const VkPipelineRobustnessCreateInfoEXT* in_struct,
-                                                        [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    storageBuffers = in_struct->storageBuffers;
-    uniformBuffers = in_struct->uniformBuffers;
-    vertexInputs = in_struct->vertexInputs;
-    images = in_struct->images;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPipelineRobustnessCreateInfoEXT::initialize(const safe_VkPipelineRobustnessCreateInfoEXT* copy_src,
-                                                        [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    storageBuffers = copy_src->storageBuffers;
-    uniformBuffers = copy_src->uniformBuffers;
-    vertexInputs = copy_src->vertexInputs;
-    images = copy_src->images;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
 safe_VkConditionalRenderingBeginInfoEXT::safe_VkConditionalRenderingBeginInfoEXT(
     const VkConditionalRenderingBeginInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType), buffer(in_struct->buffer), offset(in_struct->offset), flags(in_struct->flags) {
@@ -5601,872 +5412,6 @@ void safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::initialize(
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
-safe_VkPhysicalDeviceHostImageCopyFeaturesEXT::safe_VkPhysicalDeviceHostImageCopyFeaturesEXT(
-    const VkPhysicalDeviceHostImageCopyFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), hostImageCopy(in_struct->hostImageCopy) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkPhysicalDeviceHostImageCopyFeaturesEXT::safe_VkPhysicalDeviceHostImageCopyFeaturesEXT()
-    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT), pNext(nullptr), hostImageCopy() {}
-
-safe_VkPhysicalDeviceHostImageCopyFeaturesEXT::safe_VkPhysicalDeviceHostImageCopyFeaturesEXT(
-    const safe_VkPhysicalDeviceHostImageCopyFeaturesEXT& copy_src) {
-    sType = copy_src.sType;
-    hostImageCopy = copy_src.hostImageCopy;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPhysicalDeviceHostImageCopyFeaturesEXT& safe_VkPhysicalDeviceHostImageCopyFeaturesEXT::operator=(
-    const safe_VkPhysicalDeviceHostImageCopyFeaturesEXT& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    hostImageCopy = copy_src.hostImageCopy;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkPhysicalDeviceHostImageCopyFeaturesEXT::~safe_VkPhysicalDeviceHostImageCopyFeaturesEXT() { FreePnextChain(pNext); }
-
-void safe_VkPhysicalDeviceHostImageCopyFeaturesEXT::initialize(const VkPhysicalDeviceHostImageCopyFeaturesEXT* in_struct,
-                                                               [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    hostImageCopy = in_struct->hostImageCopy;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPhysicalDeviceHostImageCopyFeaturesEXT::initialize(const safe_VkPhysicalDeviceHostImageCopyFeaturesEXT* copy_src,
-                                                               [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    hostImageCopy = copy_src->hostImageCopy;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkPhysicalDeviceHostImageCopyPropertiesEXT::safe_VkPhysicalDeviceHostImageCopyPropertiesEXT(
-    const VkPhysicalDeviceHostImageCopyPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType),
-      copySrcLayoutCount(in_struct->copySrcLayoutCount),
-      pCopySrcLayouts(nullptr),
-      copyDstLayoutCount(in_struct->copyDstLayoutCount),
-      pCopyDstLayouts(nullptr),
-      identicalMemoryTypeRequirements(in_struct->identicalMemoryTypeRequirements) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-    if (in_struct->pCopySrcLayouts) {
-        pCopySrcLayouts = new VkImageLayout[in_struct->copySrcLayoutCount];
-        memcpy((void*)pCopySrcLayouts, (void*)in_struct->pCopySrcLayouts, sizeof(VkImageLayout) * in_struct->copySrcLayoutCount);
-    }
-
-    if (in_struct->pCopyDstLayouts) {
-        pCopyDstLayouts = new VkImageLayout[in_struct->copyDstLayoutCount];
-        memcpy((void*)pCopyDstLayouts, (void*)in_struct->pCopyDstLayouts, sizeof(VkImageLayout) * in_struct->copyDstLayoutCount);
-    }
-
-    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
-        optimalTilingLayoutUUID[i] = in_struct->optimalTilingLayoutUUID[i];
-    }
-}
-
-safe_VkPhysicalDeviceHostImageCopyPropertiesEXT::safe_VkPhysicalDeviceHostImageCopyPropertiesEXT()
-    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT),
-      pNext(nullptr),
-      copySrcLayoutCount(),
-      pCopySrcLayouts(nullptr),
-      copyDstLayoutCount(),
-      pCopyDstLayouts(nullptr),
-      identicalMemoryTypeRequirements() {}
-
-safe_VkPhysicalDeviceHostImageCopyPropertiesEXT::safe_VkPhysicalDeviceHostImageCopyPropertiesEXT(
-    const safe_VkPhysicalDeviceHostImageCopyPropertiesEXT& copy_src) {
-    sType = copy_src.sType;
-    copySrcLayoutCount = copy_src.copySrcLayoutCount;
-    pCopySrcLayouts = nullptr;
-    copyDstLayoutCount = copy_src.copyDstLayoutCount;
-    pCopyDstLayouts = nullptr;
-    identicalMemoryTypeRequirements = copy_src.identicalMemoryTypeRequirements;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    if (copy_src.pCopySrcLayouts) {
-        pCopySrcLayouts = new VkImageLayout[copy_src.copySrcLayoutCount];
-        memcpy((void*)pCopySrcLayouts, (void*)copy_src.pCopySrcLayouts, sizeof(VkImageLayout) * copy_src.copySrcLayoutCount);
-    }
-
-    if (copy_src.pCopyDstLayouts) {
-        pCopyDstLayouts = new VkImageLayout[copy_src.copyDstLayoutCount];
-        memcpy((void*)pCopyDstLayouts, (void*)copy_src.pCopyDstLayouts, sizeof(VkImageLayout) * copy_src.copyDstLayoutCount);
-    }
-
-    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
-        optimalTilingLayoutUUID[i] = copy_src.optimalTilingLayoutUUID[i];
-    }
-}
-
-safe_VkPhysicalDeviceHostImageCopyPropertiesEXT& safe_VkPhysicalDeviceHostImageCopyPropertiesEXT::operator=(
-    const safe_VkPhysicalDeviceHostImageCopyPropertiesEXT& copy_src) {
-    if (&copy_src == this) return *this;
-
-    if (pCopySrcLayouts) delete[] pCopySrcLayouts;
-    if (pCopyDstLayouts) delete[] pCopyDstLayouts;
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    copySrcLayoutCount = copy_src.copySrcLayoutCount;
-    pCopySrcLayouts = nullptr;
-    copyDstLayoutCount = copy_src.copyDstLayoutCount;
-    pCopyDstLayouts = nullptr;
-    identicalMemoryTypeRequirements = copy_src.identicalMemoryTypeRequirements;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    if (copy_src.pCopySrcLayouts) {
-        pCopySrcLayouts = new VkImageLayout[copy_src.copySrcLayoutCount];
-        memcpy((void*)pCopySrcLayouts, (void*)copy_src.pCopySrcLayouts, sizeof(VkImageLayout) * copy_src.copySrcLayoutCount);
-    }
-
-    if (copy_src.pCopyDstLayouts) {
-        pCopyDstLayouts = new VkImageLayout[copy_src.copyDstLayoutCount];
-        memcpy((void*)pCopyDstLayouts, (void*)copy_src.pCopyDstLayouts, sizeof(VkImageLayout) * copy_src.copyDstLayoutCount);
-    }
-
-    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
-        optimalTilingLayoutUUID[i] = copy_src.optimalTilingLayoutUUID[i];
-    }
-
-    return *this;
-}
-
-safe_VkPhysicalDeviceHostImageCopyPropertiesEXT::~safe_VkPhysicalDeviceHostImageCopyPropertiesEXT() {
-    if (pCopySrcLayouts) delete[] pCopySrcLayouts;
-    if (pCopyDstLayouts) delete[] pCopyDstLayouts;
-    FreePnextChain(pNext);
-}
-
-void safe_VkPhysicalDeviceHostImageCopyPropertiesEXT::initialize(const VkPhysicalDeviceHostImageCopyPropertiesEXT* in_struct,
-                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
-    if (pCopySrcLayouts) delete[] pCopySrcLayouts;
-    if (pCopyDstLayouts) delete[] pCopyDstLayouts;
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    copySrcLayoutCount = in_struct->copySrcLayoutCount;
-    pCopySrcLayouts = nullptr;
-    copyDstLayoutCount = in_struct->copyDstLayoutCount;
-    pCopyDstLayouts = nullptr;
-    identicalMemoryTypeRequirements = in_struct->identicalMemoryTypeRequirements;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-
-    if (in_struct->pCopySrcLayouts) {
-        pCopySrcLayouts = new VkImageLayout[in_struct->copySrcLayoutCount];
-        memcpy((void*)pCopySrcLayouts, (void*)in_struct->pCopySrcLayouts, sizeof(VkImageLayout) * in_struct->copySrcLayoutCount);
-    }
-
-    if (in_struct->pCopyDstLayouts) {
-        pCopyDstLayouts = new VkImageLayout[in_struct->copyDstLayoutCount];
-        memcpy((void*)pCopyDstLayouts, (void*)in_struct->pCopyDstLayouts, sizeof(VkImageLayout) * in_struct->copyDstLayoutCount);
-    }
-
-    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
-        optimalTilingLayoutUUID[i] = in_struct->optimalTilingLayoutUUID[i];
-    }
-}
-
-void safe_VkPhysicalDeviceHostImageCopyPropertiesEXT::initialize(const safe_VkPhysicalDeviceHostImageCopyPropertiesEXT* copy_src,
-                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    copySrcLayoutCount = copy_src->copySrcLayoutCount;
-    pCopySrcLayouts = nullptr;
-    copyDstLayoutCount = copy_src->copyDstLayoutCount;
-    pCopyDstLayouts = nullptr;
-    identicalMemoryTypeRequirements = copy_src->identicalMemoryTypeRequirements;
-    pNext = SafePnextCopy(copy_src->pNext);
-
-    if (copy_src->pCopySrcLayouts) {
-        pCopySrcLayouts = new VkImageLayout[copy_src->copySrcLayoutCount];
-        memcpy((void*)pCopySrcLayouts, (void*)copy_src->pCopySrcLayouts, sizeof(VkImageLayout) * copy_src->copySrcLayoutCount);
-    }
-
-    if (copy_src->pCopyDstLayouts) {
-        pCopyDstLayouts = new VkImageLayout[copy_src->copyDstLayoutCount];
-        memcpy((void*)pCopyDstLayouts, (void*)copy_src->pCopyDstLayouts, sizeof(VkImageLayout) * copy_src->copyDstLayoutCount);
-    }
-
-    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
-        optimalTilingLayoutUUID[i] = copy_src->optimalTilingLayoutUUID[i];
-    }
-}
-
-safe_VkMemoryToImageCopyEXT::safe_VkMemoryToImageCopyEXT(const VkMemoryToImageCopyEXT* in_struct,
-                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType),
-      pHostPointer(in_struct->pHostPointer),
-      memoryRowLength(in_struct->memoryRowLength),
-      memoryImageHeight(in_struct->memoryImageHeight),
-      imageSubresource(in_struct->imageSubresource),
-      imageOffset(in_struct->imageOffset),
-      imageExtent(in_struct->imageExtent) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkMemoryToImageCopyEXT::safe_VkMemoryToImageCopyEXT()
-    : sType(VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT),
-      pNext(nullptr),
-      pHostPointer(nullptr),
-      memoryRowLength(),
-      memoryImageHeight(),
-      imageSubresource(),
-      imageOffset(),
-      imageExtent() {}
-
-safe_VkMemoryToImageCopyEXT::safe_VkMemoryToImageCopyEXT(const safe_VkMemoryToImageCopyEXT& copy_src) {
-    sType = copy_src.sType;
-    pHostPointer = copy_src.pHostPointer;
-    memoryRowLength = copy_src.memoryRowLength;
-    memoryImageHeight = copy_src.memoryImageHeight;
-    imageSubresource = copy_src.imageSubresource;
-    imageOffset = copy_src.imageOffset;
-    imageExtent = copy_src.imageExtent;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkMemoryToImageCopyEXT& safe_VkMemoryToImageCopyEXT::operator=(const safe_VkMemoryToImageCopyEXT& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    pHostPointer = copy_src.pHostPointer;
-    memoryRowLength = copy_src.memoryRowLength;
-    memoryImageHeight = copy_src.memoryImageHeight;
-    imageSubresource = copy_src.imageSubresource;
-    imageOffset = copy_src.imageOffset;
-    imageExtent = copy_src.imageExtent;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkMemoryToImageCopyEXT::~safe_VkMemoryToImageCopyEXT() { FreePnextChain(pNext); }
-
-void safe_VkMemoryToImageCopyEXT::initialize(const VkMemoryToImageCopyEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    pHostPointer = in_struct->pHostPointer;
-    memoryRowLength = in_struct->memoryRowLength;
-    memoryImageHeight = in_struct->memoryImageHeight;
-    imageSubresource = in_struct->imageSubresource;
-    imageOffset = in_struct->imageOffset;
-    imageExtent = in_struct->imageExtent;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkMemoryToImageCopyEXT::initialize(const safe_VkMemoryToImageCopyEXT* copy_src,
-                                             [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    pHostPointer = copy_src->pHostPointer;
-    memoryRowLength = copy_src->memoryRowLength;
-    memoryImageHeight = copy_src->memoryImageHeight;
-    imageSubresource = copy_src->imageSubresource;
-    imageOffset = copy_src->imageOffset;
-    imageExtent = copy_src->imageExtent;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkImageToMemoryCopyEXT::safe_VkImageToMemoryCopyEXT(const VkImageToMemoryCopyEXT* in_struct,
-                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType),
-      pHostPointer(in_struct->pHostPointer),
-      memoryRowLength(in_struct->memoryRowLength),
-      memoryImageHeight(in_struct->memoryImageHeight),
-      imageSubresource(in_struct->imageSubresource),
-      imageOffset(in_struct->imageOffset),
-      imageExtent(in_struct->imageExtent) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkImageToMemoryCopyEXT::safe_VkImageToMemoryCopyEXT()
-    : sType(VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT),
-      pNext(nullptr),
-      pHostPointer(nullptr),
-      memoryRowLength(),
-      memoryImageHeight(),
-      imageSubresource(),
-      imageOffset(),
-      imageExtent() {}
-
-safe_VkImageToMemoryCopyEXT::safe_VkImageToMemoryCopyEXT(const safe_VkImageToMemoryCopyEXT& copy_src) {
-    sType = copy_src.sType;
-    pHostPointer = copy_src.pHostPointer;
-    memoryRowLength = copy_src.memoryRowLength;
-    memoryImageHeight = copy_src.memoryImageHeight;
-    imageSubresource = copy_src.imageSubresource;
-    imageOffset = copy_src.imageOffset;
-    imageExtent = copy_src.imageExtent;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkImageToMemoryCopyEXT& safe_VkImageToMemoryCopyEXT::operator=(const safe_VkImageToMemoryCopyEXT& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    pHostPointer = copy_src.pHostPointer;
-    memoryRowLength = copy_src.memoryRowLength;
-    memoryImageHeight = copy_src.memoryImageHeight;
-    imageSubresource = copy_src.imageSubresource;
-    imageOffset = copy_src.imageOffset;
-    imageExtent = copy_src.imageExtent;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkImageToMemoryCopyEXT::~safe_VkImageToMemoryCopyEXT() { FreePnextChain(pNext); }
-
-void safe_VkImageToMemoryCopyEXT::initialize(const VkImageToMemoryCopyEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    pHostPointer = in_struct->pHostPointer;
-    memoryRowLength = in_struct->memoryRowLength;
-    memoryImageHeight = in_struct->memoryImageHeight;
-    imageSubresource = in_struct->imageSubresource;
-    imageOffset = in_struct->imageOffset;
-    imageExtent = in_struct->imageExtent;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkImageToMemoryCopyEXT::initialize(const safe_VkImageToMemoryCopyEXT* copy_src,
-                                             [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    pHostPointer = copy_src->pHostPointer;
-    memoryRowLength = copy_src->memoryRowLength;
-    memoryImageHeight = copy_src->memoryImageHeight;
-    imageSubresource = copy_src->imageSubresource;
-    imageOffset = copy_src->imageOffset;
-    imageExtent = copy_src->imageExtent;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkCopyMemoryToImageInfoEXT::safe_VkCopyMemoryToImageInfoEXT(const VkCopyMemoryToImageInfoEXT* in_struct,
-                                                                 [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType),
-      flags(in_struct->flags),
-      dstImage(in_struct->dstImage),
-      dstImageLayout(in_struct->dstImageLayout),
-      regionCount(in_struct->regionCount),
-      pRegions(nullptr) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-    if (regionCount && in_struct->pRegions) {
-        pRegions = new safe_VkMemoryToImageCopyEXT[regionCount];
-        for (uint32_t i = 0; i < regionCount; ++i) {
-            pRegions[i].initialize(&in_struct->pRegions[i]);
-        }
-    }
-}
-
-safe_VkCopyMemoryToImageInfoEXT::safe_VkCopyMemoryToImageInfoEXT()
-    : sType(VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT),
-      pNext(nullptr),
-      flags(),
-      dstImage(),
-      dstImageLayout(),
-      regionCount(),
-      pRegions(nullptr) {}
-
-safe_VkCopyMemoryToImageInfoEXT::safe_VkCopyMemoryToImageInfoEXT(const safe_VkCopyMemoryToImageInfoEXT& copy_src) {
-    sType = copy_src.sType;
-    flags = copy_src.flags;
-    dstImage = copy_src.dstImage;
-    dstImageLayout = copy_src.dstImageLayout;
-    regionCount = copy_src.regionCount;
-    pRegions = nullptr;
-    pNext = SafePnextCopy(copy_src.pNext);
-    if (regionCount && copy_src.pRegions) {
-        pRegions = new safe_VkMemoryToImageCopyEXT[regionCount];
-        for (uint32_t i = 0; i < regionCount; ++i) {
-            pRegions[i].initialize(&copy_src.pRegions[i]);
-        }
-    }
-}
-
-safe_VkCopyMemoryToImageInfoEXT& safe_VkCopyMemoryToImageInfoEXT::operator=(const safe_VkCopyMemoryToImageInfoEXT& copy_src) {
-    if (&copy_src == this) return *this;
-
-    if (pRegions) delete[] pRegions;
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    flags = copy_src.flags;
-    dstImage = copy_src.dstImage;
-    dstImageLayout = copy_src.dstImageLayout;
-    regionCount = copy_src.regionCount;
-    pRegions = nullptr;
-    pNext = SafePnextCopy(copy_src.pNext);
-    if (regionCount && copy_src.pRegions) {
-        pRegions = new safe_VkMemoryToImageCopyEXT[regionCount];
-        for (uint32_t i = 0; i < regionCount; ++i) {
-            pRegions[i].initialize(&copy_src.pRegions[i]);
-        }
-    }
-
-    return *this;
-}
-
-safe_VkCopyMemoryToImageInfoEXT::~safe_VkCopyMemoryToImageInfoEXT() {
-    if (pRegions) delete[] pRegions;
-    FreePnextChain(pNext);
-}
-
-void safe_VkCopyMemoryToImageInfoEXT::initialize(const VkCopyMemoryToImageInfoEXT* in_struct,
-                                                 [[maybe_unused]] PNextCopyState* copy_state) {
-    if (pRegions) delete[] pRegions;
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    flags = in_struct->flags;
-    dstImage = in_struct->dstImage;
-    dstImageLayout = in_struct->dstImageLayout;
-    regionCount = in_struct->regionCount;
-    pRegions = nullptr;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    if (regionCount && in_struct->pRegions) {
-        pRegions = new safe_VkMemoryToImageCopyEXT[regionCount];
-        for (uint32_t i = 0; i < regionCount; ++i) {
-            pRegions[i].initialize(&in_struct->pRegions[i]);
-        }
-    }
-}
-
-void safe_VkCopyMemoryToImageInfoEXT::initialize(const safe_VkCopyMemoryToImageInfoEXT* copy_src,
-                                                 [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    flags = copy_src->flags;
-    dstImage = copy_src->dstImage;
-    dstImageLayout = copy_src->dstImageLayout;
-    regionCount = copy_src->regionCount;
-    pRegions = nullptr;
-    pNext = SafePnextCopy(copy_src->pNext);
-    if (regionCount && copy_src->pRegions) {
-        pRegions = new safe_VkMemoryToImageCopyEXT[regionCount];
-        for (uint32_t i = 0; i < regionCount; ++i) {
-            pRegions[i].initialize(&copy_src->pRegions[i]);
-        }
-    }
-}
-
-safe_VkCopyImageToMemoryInfoEXT::safe_VkCopyImageToMemoryInfoEXT(const VkCopyImageToMemoryInfoEXT* in_struct,
-                                                                 [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType),
-      flags(in_struct->flags),
-      srcImage(in_struct->srcImage),
-      srcImageLayout(in_struct->srcImageLayout),
-      regionCount(in_struct->regionCount),
-      pRegions(nullptr) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-    if (regionCount && in_struct->pRegions) {
-        pRegions = new safe_VkImageToMemoryCopyEXT[regionCount];
-        for (uint32_t i = 0; i < regionCount; ++i) {
-            pRegions[i].initialize(&in_struct->pRegions[i]);
-        }
-    }
-}
-
-safe_VkCopyImageToMemoryInfoEXT::safe_VkCopyImageToMemoryInfoEXT()
-    : sType(VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT),
-      pNext(nullptr),
-      flags(),
-      srcImage(),
-      srcImageLayout(),
-      regionCount(),
-      pRegions(nullptr) {}
-
-safe_VkCopyImageToMemoryInfoEXT::safe_VkCopyImageToMemoryInfoEXT(const safe_VkCopyImageToMemoryInfoEXT& copy_src) {
-    sType = copy_src.sType;
-    flags = copy_src.flags;
-    srcImage = copy_src.srcImage;
-    srcImageLayout = copy_src.srcImageLayout;
-    regionCount = copy_src.regionCount;
-    pRegions = nullptr;
-    pNext = SafePnextCopy(copy_src.pNext);
-    if (regionCount && copy_src.pRegions) {
-        pRegions = new safe_VkImageToMemoryCopyEXT[regionCount];
-        for (uint32_t i = 0; i < regionCount; ++i) {
-            pRegions[i].initialize(&copy_src.pRegions[i]);
-        }
-    }
-}
-
-safe_VkCopyImageToMemoryInfoEXT& safe_VkCopyImageToMemoryInfoEXT::operator=(const safe_VkCopyImageToMemoryInfoEXT& copy_src) {
-    if (&copy_src == this) return *this;
-
-    if (pRegions) delete[] pRegions;
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    flags = copy_src.flags;
-    srcImage = copy_src.srcImage;
-    srcImageLayout = copy_src.srcImageLayout;
-    regionCount = copy_src.regionCount;
-    pRegions = nullptr;
-    pNext = SafePnextCopy(copy_src.pNext);
-    if (regionCount && copy_src.pRegions) {
-        pRegions = new safe_VkImageToMemoryCopyEXT[regionCount];
-        for (uint32_t i = 0; i < regionCount; ++i) {
-            pRegions[i].initialize(&copy_src.pRegions[i]);
-        }
-    }
-
-    return *this;
-}
-
-safe_VkCopyImageToMemoryInfoEXT::~safe_VkCopyImageToMemoryInfoEXT() {
-    if (pRegions) delete[] pRegions;
-    FreePnextChain(pNext);
-}
-
-void safe_VkCopyImageToMemoryInfoEXT::initialize(const VkCopyImageToMemoryInfoEXT* in_struct,
-                                                 [[maybe_unused]] PNextCopyState* copy_state) {
-    if (pRegions) delete[] pRegions;
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    flags = in_struct->flags;
-    srcImage = in_struct->srcImage;
-    srcImageLayout = in_struct->srcImageLayout;
-    regionCount = in_struct->regionCount;
-    pRegions = nullptr;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    if (regionCount && in_struct->pRegions) {
-        pRegions = new safe_VkImageToMemoryCopyEXT[regionCount];
-        for (uint32_t i = 0; i < regionCount; ++i) {
-            pRegions[i].initialize(&in_struct->pRegions[i]);
-        }
-    }
-}
-
-void safe_VkCopyImageToMemoryInfoEXT::initialize(const safe_VkCopyImageToMemoryInfoEXT* copy_src,
-                                                 [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    flags = copy_src->flags;
-    srcImage = copy_src->srcImage;
-    srcImageLayout = copy_src->srcImageLayout;
-    regionCount = copy_src->regionCount;
-    pRegions = nullptr;
-    pNext = SafePnextCopy(copy_src->pNext);
-    if (regionCount && copy_src->pRegions) {
-        pRegions = new safe_VkImageToMemoryCopyEXT[regionCount];
-        for (uint32_t i = 0; i < regionCount; ++i) {
-            pRegions[i].initialize(&copy_src->pRegions[i]);
-        }
-    }
-}
-
-safe_VkCopyImageToImageInfoEXT::safe_VkCopyImageToImageInfoEXT(const VkCopyImageToImageInfoEXT* in_struct,
-                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType),
-      flags(in_struct->flags),
-      srcImage(in_struct->srcImage),
-      srcImageLayout(in_struct->srcImageLayout),
-      dstImage(in_struct->dstImage),
-      dstImageLayout(in_struct->dstImageLayout),
-      regionCount(in_struct->regionCount),
-      pRegions(nullptr) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-    if (regionCount && in_struct->pRegions) {
-        pRegions = new safe_VkImageCopy2[regionCount];
-        for (uint32_t i = 0; i < regionCount; ++i) {
-            pRegions[i].initialize(&in_struct->pRegions[i]);
-        }
-    }
-}
-
-safe_VkCopyImageToImageInfoEXT::safe_VkCopyImageToImageInfoEXT()
-    : sType(VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT),
-      pNext(nullptr),
-      flags(),
-      srcImage(),
-      srcImageLayout(),
-      dstImage(),
-      dstImageLayout(),
-      regionCount(),
-      pRegions(nullptr) {}
-
-safe_VkCopyImageToImageInfoEXT::safe_VkCopyImageToImageInfoEXT(const safe_VkCopyImageToImageInfoEXT& copy_src) {
-    sType = copy_src.sType;
-    flags = copy_src.flags;
-    srcImage = copy_src.srcImage;
-    srcImageLayout = copy_src.srcImageLayout;
-    dstImage = copy_src.dstImage;
-    dstImageLayout = copy_src.dstImageLayout;
-    regionCount = copy_src.regionCount;
-    pRegions = nullptr;
-    pNext = SafePnextCopy(copy_src.pNext);
-    if (regionCount && copy_src.pRegions) {
-        pRegions = new safe_VkImageCopy2[regionCount];
-        for (uint32_t i = 0; i < regionCount; ++i) {
-            pRegions[i].initialize(&copy_src.pRegions[i]);
-        }
-    }
-}
-
-safe_VkCopyImageToImageInfoEXT& safe_VkCopyImageToImageInfoEXT::operator=(const safe_VkCopyImageToImageInfoEXT& copy_src) {
-    if (&copy_src == this) return *this;
-
-    if (pRegions) delete[] pRegions;
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    flags = copy_src.flags;
-    srcImage = copy_src.srcImage;
-    srcImageLayout = copy_src.srcImageLayout;
-    dstImage = copy_src.dstImage;
-    dstImageLayout = copy_src.dstImageLayout;
-    regionCount = copy_src.regionCount;
-    pRegions = nullptr;
-    pNext = SafePnextCopy(copy_src.pNext);
-    if (regionCount && copy_src.pRegions) {
-        pRegions = new safe_VkImageCopy2[regionCount];
-        for (uint32_t i = 0; i < regionCount; ++i) {
-            pRegions[i].initialize(&copy_src.pRegions[i]);
-        }
-    }
-
-    return *this;
-}
-
-safe_VkCopyImageToImageInfoEXT::~safe_VkCopyImageToImageInfoEXT() {
-    if (pRegions) delete[] pRegions;
-    FreePnextChain(pNext);
-}
-
-void safe_VkCopyImageToImageInfoEXT::initialize(const VkCopyImageToImageInfoEXT* in_struct,
-                                                [[maybe_unused]] PNextCopyState* copy_state) {
-    if (pRegions) delete[] pRegions;
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    flags = in_struct->flags;
-    srcImage = in_struct->srcImage;
-    srcImageLayout = in_struct->srcImageLayout;
-    dstImage = in_struct->dstImage;
-    dstImageLayout = in_struct->dstImageLayout;
-    regionCount = in_struct->regionCount;
-    pRegions = nullptr;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    if (regionCount && in_struct->pRegions) {
-        pRegions = new safe_VkImageCopy2[regionCount];
-        for (uint32_t i = 0; i < regionCount; ++i) {
-            pRegions[i].initialize(&in_struct->pRegions[i]);
-        }
-    }
-}
-
-void safe_VkCopyImageToImageInfoEXT::initialize(const safe_VkCopyImageToImageInfoEXT* copy_src,
-                                                [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    flags = copy_src->flags;
-    srcImage = copy_src->srcImage;
-    srcImageLayout = copy_src->srcImageLayout;
-    dstImage = copy_src->dstImage;
-    dstImageLayout = copy_src->dstImageLayout;
-    regionCount = copy_src->regionCount;
-    pRegions = nullptr;
-    pNext = SafePnextCopy(copy_src->pNext);
-    if (regionCount && copy_src->pRegions) {
-        pRegions = new safe_VkImageCopy2[regionCount];
-        for (uint32_t i = 0; i < regionCount; ++i) {
-            pRegions[i].initialize(&copy_src->pRegions[i]);
-        }
-    }
-}
-
-safe_VkHostImageLayoutTransitionInfoEXT::safe_VkHostImageLayoutTransitionInfoEXT(
-    const VkHostImageLayoutTransitionInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType),
-      image(in_struct->image),
-      oldLayout(in_struct->oldLayout),
-      newLayout(in_struct->newLayout),
-      subresourceRange(in_struct->subresourceRange) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkHostImageLayoutTransitionInfoEXT::safe_VkHostImageLayoutTransitionInfoEXT()
-    : sType(VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT),
-      pNext(nullptr),
-      image(),
-      oldLayout(),
-      newLayout(),
-      subresourceRange() {}
-
-safe_VkHostImageLayoutTransitionInfoEXT::safe_VkHostImageLayoutTransitionInfoEXT(
-    const safe_VkHostImageLayoutTransitionInfoEXT& copy_src) {
-    sType = copy_src.sType;
-    image = copy_src.image;
-    oldLayout = copy_src.oldLayout;
-    newLayout = copy_src.newLayout;
-    subresourceRange = copy_src.subresourceRange;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkHostImageLayoutTransitionInfoEXT& safe_VkHostImageLayoutTransitionInfoEXT::operator=(
-    const safe_VkHostImageLayoutTransitionInfoEXT& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    image = copy_src.image;
-    oldLayout = copy_src.oldLayout;
-    newLayout = copy_src.newLayout;
-    subresourceRange = copy_src.subresourceRange;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkHostImageLayoutTransitionInfoEXT::~safe_VkHostImageLayoutTransitionInfoEXT() { FreePnextChain(pNext); }
-
-void safe_VkHostImageLayoutTransitionInfoEXT::initialize(const VkHostImageLayoutTransitionInfoEXT* in_struct,
-                                                         [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    image = in_struct->image;
-    oldLayout = in_struct->oldLayout;
-    newLayout = in_struct->newLayout;
-    subresourceRange = in_struct->subresourceRange;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkHostImageLayoutTransitionInfoEXT::initialize(const safe_VkHostImageLayoutTransitionInfoEXT* copy_src,
-                                                         [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    image = copy_src->image;
-    oldLayout = copy_src->oldLayout;
-    newLayout = copy_src->newLayout;
-    subresourceRange = copy_src->subresourceRange;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkSubresourceHostMemcpySizeEXT::safe_VkSubresourceHostMemcpySizeEXT(const VkSubresourceHostMemcpySizeEXT* in_struct,
-                                                                         [[maybe_unused]] PNextCopyState* copy_state,
-                                                                         bool copy_pnext)
-    : sType(in_struct->sType), size(in_struct->size) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkSubresourceHostMemcpySizeEXT::safe_VkSubresourceHostMemcpySizeEXT()
-    : sType(VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT), pNext(nullptr), size() {}
-
-safe_VkSubresourceHostMemcpySizeEXT::safe_VkSubresourceHostMemcpySizeEXT(const safe_VkSubresourceHostMemcpySizeEXT& copy_src) {
-    sType = copy_src.sType;
-    size = copy_src.size;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkSubresourceHostMemcpySizeEXT& safe_VkSubresourceHostMemcpySizeEXT::operator=(
-    const safe_VkSubresourceHostMemcpySizeEXT& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    size = copy_src.size;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkSubresourceHostMemcpySizeEXT::~safe_VkSubresourceHostMemcpySizeEXT() { FreePnextChain(pNext); }
-
-void safe_VkSubresourceHostMemcpySizeEXT::initialize(const VkSubresourceHostMemcpySizeEXT* in_struct,
-                                                     [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    size = in_struct->size;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkSubresourceHostMemcpySizeEXT::initialize(const safe_VkSubresourceHostMemcpySizeEXT* copy_src,
-                                                     [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    size = copy_src->size;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkHostImageCopyDevicePerformanceQueryEXT::safe_VkHostImageCopyDevicePerformanceQueryEXT(
-    const VkHostImageCopyDevicePerformanceQueryEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType),
-      optimalDeviceAccess(in_struct->optimalDeviceAccess),
-      identicalMemoryLayout(in_struct->identicalMemoryLayout) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkHostImageCopyDevicePerformanceQueryEXT::safe_VkHostImageCopyDevicePerformanceQueryEXT()
-    : sType(VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT),
-      pNext(nullptr),
-      optimalDeviceAccess(),
-      identicalMemoryLayout() {}
-
-safe_VkHostImageCopyDevicePerformanceQueryEXT::safe_VkHostImageCopyDevicePerformanceQueryEXT(
-    const safe_VkHostImageCopyDevicePerformanceQueryEXT& copy_src) {
-    sType = copy_src.sType;
-    optimalDeviceAccess = copy_src.optimalDeviceAccess;
-    identicalMemoryLayout = copy_src.identicalMemoryLayout;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkHostImageCopyDevicePerformanceQueryEXT& safe_VkHostImageCopyDevicePerformanceQueryEXT::operator=(
-    const safe_VkHostImageCopyDevicePerformanceQueryEXT& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    optimalDeviceAccess = copy_src.optimalDeviceAccess;
-    identicalMemoryLayout = copy_src.identicalMemoryLayout;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkHostImageCopyDevicePerformanceQueryEXT::~safe_VkHostImageCopyDevicePerformanceQueryEXT() { FreePnextChain(pNext); }
-
-void safe_VkHostImageCopyDevicePerformanceQueryEXT::initialize(const VkHostImageCopyDevicePerformanceQueryEXT* in_struct,
-                                                               [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    optimalDeviceAccess = in_struct->optimalDeviceAccess;
-    identicalMemoryLayout = in_struct->identicalMemoryLayout;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkHostImageCopyDevicePerformanceQueryEXT::initialize(const safe_VkHostImageCopyDevicePerformanceQueryEXT* copy_src,
-                                                               [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    optimalDeviceAccess = copy_src->optimalDeviceAccess;
-    identicalMemoryLayout = copy_src->identicalMemoryLayout;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
 safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT::safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT(
     const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType),
@@ -14552,57 +13497,6 @@ void safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT::initialize(const safe_VkPh
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
-safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT::safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
-    const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
-    bool copy_pnext)
-    : sType(in_struct->sType), pipelineProtectedAccess(in_struct->pipelineProtectedAccess) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT::safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT()
-    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT), pNext(nullptr), pipelineProtectedAccess() {}
-
-safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT::safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
-    const safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT& copy_src) {
-    sType = copy_src.sType;
-    pipelineProtectedAccess = copy_src.pipelineProtectedAccess;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT& safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT::operator=(
-    const safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    pipelineProtectedAccess = copy_src.pipelineProtectedAccess;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT::~safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT() {
-    FreePnextChain(pNext);
-}
-
-void safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT::initialize(
-    const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    pipelineProtectedAccess = in_struct->pipelineProtectedAccess;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT::initialize(
-    const safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    pipelineProtectedAccess = copy_src->pipelineProtectedAccess;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
 safe_VkPhysicalDeviceShaderObjectFeaturesEXT::safe_VkPhysicalDeviceShaderObjectFeaturesEXT(
     const VkPhysicalDeviceShaderObjectFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType), shaderObject(in_struct->shaderObject) {
diff --git a/src/vulkan/vk_safe_struct_khr.cpp b/src/vulkan/vk_safe_struct_khr.cpp
index 735e5d8..bde9965 100644
--- a/src/vulkan/vk_safe_struct_khr.cpp
+++ b/src/vulkan/vk_safe_struct_khr.cpp
@@ -6384,54 +6384,6 @@ void safe_VkSemaphoreGetFdInfoKHR::initialize(const safe_VkSemaphoreGetFdInfoKHR
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
-safe_VkPhysicalDevicePushDescriptorPropertiesKHR::safe_VkPhysicalDevicePushDescriptorPropertiesKHR(
-    const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), maxPushDescriptors(in_struct->maxPushDescriptors) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkPhysicalDevicePushDescriptorPropertiesKHR::safe_VkPhysicalDevicePushDescriptorPropertiesKHR()
-    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR), pNext(nullptr), maxPushDescriptors() {}
-
-safe_VkPhysicalDevicePushDescriptorPropertiesKHR::safe_VkPhysicalDevicePushDescriptorPropertiesKHR(
-    const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& copy_src) {
-    sType = copy_src.sType;
-    maxPushDescriptors = copy_src.maxPushDescriptors;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPhysicalDevicePushDescriptorPropertiesKHR& safe_VkPhysicalDevicePushDescriptorPropertiesKHR::operator=(
-    const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    maxPushDescriptors = copy_src.maxPushDescriptors;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkPhysicalDevicePushDescriptorPropertiesKHR::~safe_VkPhysicalDevicePushDescriptorPropertiesKHR() { FreePnextChain(pNext); }
-
-void safe_VkPhysicalDevicePushDescriptorPropertiesKHR::initialize(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct,
-                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    maxPushDescriptors = in_struct->maxPushDescriptors;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPhysicalDevicePushDescriptorPropertiesKHR::initialize(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR* copy_src,
-                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    maxPushDescriptors = copy_src->maxPushDescriptors;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
 safe_VkPresentRegionKHR::safe_VkPresentRegionKHR(const VkPresentRegionKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state)
     : rectangleCount(in_struct->rectangleCount), pRectangles(nullptr) {
     if (in_struct->pRectangles) {
@@ -8570,171 +8522,6 @@ void safe_VkVideoDecodeH265DpbSlotInfoKHR::initialize(const safe_VkVideoDecodeH2
     }
 }
 
-safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::safe_VkDeviceQueueGlobalPriorityCreateInfoKHR(
-    const VkDeviceQueueGlobalPriorityCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), globalPriority(in_struct->globalPriority) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::safe_VkDeviceQueueGlobalPriorityCreateInfoKHR()
-    : sType(VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR), pNext(nullptr), globalPriority() {}
-
-safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::safe_VkDeviceQueueGlobalPriorityCreateInfoKHR(
-    const safe_VkDeviceQueueGlobalPriorityCreateInfoKHR& copy_src) {
-    sType = copy_src.sType;
-    globalPriority = copy_src.globalPriority;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkDeviceQueueGlobalPriorityCreateInfoKHR& safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::operator=(
-    const safe_VkDeviceQueueGlobalPriorityCreateInfoKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    globalPriority = copy_src.globalPriority;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::~safe_VkDeviceQueueGlobalPriorityCreateInfoKHR() { FreePnextChain(pNext); }
-
-void safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::initialize(const VkDeviceQueueGlobalPriorityCreateInfoKHR* in_struct,
-                                                               [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    globalPriority = in_struct->globalPriority;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkDeviceQueueGlobalPriorityCreateInfoKHR::initialize(const safe_VkDeviceQueueGlobalPriorityCreateInfoKHR* copy_src,
-                                                               [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    globalPriority = copy_src->globalPriority;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
-    const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), globalPriorityQuery(in_struct->globalPriorityQuery) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR()
-    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR), pNext(nullptr), globalPriorityQuery() {}
-
-safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
-    const safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& copy_src) {
-    sType = copy_src.sType;
-    globalPriorityQuery = copy_src.globalPriorityQuery;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::operator=(
-    const safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    globalPriorityQuery = copy_src.globalPriorityQuery;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::~safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR() {
-    FreePnextChain(pNext);
-}
-
-void safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::initialize(
-    const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    globalPriorityQuery = in_struct->globalPriorityQuery;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::initialize(
-    const safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    globalPriorityQuery = copy_src->globalPriorityQuery;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkQueueFamilyGlobalPriorityPropertiesKHR::safe_VkQueueFamilyGlobalPriorityPropertiesKHR(
-    const VkQueueFamilyGlobalPriorityPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), priorityCount(in_struct->priorityCount) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-    for (uint32_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE_KHR; ++i) {
-        priorities[i] = in_struct->priorities[i];
-    }
-}
-
-safe_VkQueueFamilyGlobalPriorityPropertiesKHR::safe_VkQueueFamilyGlobalPriorityPropertiesKHR()
-    : sType(VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR), pNext(nullptr), priorityCount() {}
-
-safe_VkQueueFamilyGlobalPriorityPropertiesKHR::safe_VkQueueFamilyGlobalPriorityPropertiesKHR(
-    const safe_VkQueueFamilyGlobalPriorityPropertiesKHR& copy_src) {
-    sType = copy_src.sType;
-    priorityCount = copy_src.priorityCount;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    for (uint32_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE_KHR; ++i) {
-        priorities[i] = copy_src.priorities[i];
-    }
-}
-
-safe_VkQueueFamilyGlobalPriorityPropertiesKHR& safe_VkQueueFamilyGlobalPriorityPropertiesKHR::operator=(
-    const safe_VkQueueFamilyGlobalPriorityPropertiesKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    priorityCount = copy_src.priorityCount;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    for (uint32_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE_KHR; ++i) {
-        priorities[i] = copy_src.priorities[i];
-    }
-
-    return *this;
-}
-
-safe_VkQueueFamilyGlobalPriorityPropertiesKHR::~safe_VkQueueFamilyGlobalPriorityPropertiesKHR() { FreePnextChain(pNext); }
-
-void safe_VkQueueFamilyGlobalPriorityPropertiesKHR::initialize(const VkQueueFamilyGlobalPriorityPropertiesKHR* in_struct,
-                                                               [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    priorityCount = in_struct->priorityCount;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-
-    for (uint32_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE_KHR; ++i) {
-        priorities[i] = in_struct->priorities[i];
-    }
-}
-
-void safe_VkQueueFamilyGlobalPriorityPropertiesKHR::initialize(const safe_VkQueueFamilyGlobalPriorityPropertiesKHR* copy_src,
-                                                               [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    priorityCount = copy_src->priorityCount;
-    pNext = SafePnextCopy(copy_src->pNext);
-
-    for (uint32_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE_KHR; ++i) {
-        priorities[i] = copy_src->priorities[i];
-    }
-}
-
 safe_VkFragmentShadingRateAttachmentInfoKHR::safe_VkFragmentShadingRateAttachmentInfoKHR(
     const VkFragmentShadingRateAttachmentInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType),
@@ -9207,297 +8994,6 @@ void safe_VkRenderingFragmentShadingRateAttachmentInfoKHR::initialize(
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
-safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR(
-    const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
-    bool copy_pnext)
-    : sType(in_struct->sType), dynamicRenderingLocalRead(in_struct->dynamicRenderingLocalRead) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR()
-    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR),
-      pNext(nullptr),
-      dynamicRenderingLocalRead() {}
-
-safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR(
-    const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& copy_src) {
-    sType = copy_src.sType;
-    dynamicRenderingLocalRead = copy_src.dynamicRenderingLocalRead;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::operator=(
-    const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    dynamicRenderingLocalRead = copy_src.dynamicRenderingLocalRead;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::~safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR() {
-    FreePnextChain(pNext);
-}
-
-void safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::initialize(
-    const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    dynamicRenderingLocalRead = in_struct->dynamicRenderingLocalRead;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR::initialize(
-    const safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    dynamicRenderingLocalRead = copy_src->dynamicRenderingLocalRead;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkRenderingAttachmentLocationInfoKHR::safe_VkRenderingAttachmentLocationInfoKHR(
-    const VkRenderingAttachmentLocationInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), colorAttachmentCount(in_struct->colorAttachmentCount), pColorAttachmentLocations(nullptr) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-    if (in_struct->pColorAttachmentLocations) {
-        pColorAttachmentLocations = new uint32_t[in_struct->colorAttachmentCount];
-        memcpy((void*)pColorAttachmentLocations, (void*)in_struct->pColorAttachmentLocations,
-               sizeof(uint32_t) * in_struct->colorAttachmentCount);
-    }
-}
-
-safe_VkRenderingAttachmentLocationInfoKHR::safe_VkRenderingAttachmentLocationInfoKHR()
-    : sType(VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR),
-      pNext(nullptr),
-      colorAttachmentCount(),
-      pColorAttachmentLocations(nullptr) {}
-
-safe_VkRenderingAttachmentLocationInfoKHR::safe_VkRenderingAttachmentLocationInfoKHR(
-    const safe_VkRenderingAttachmentLocationInfoKHR& copy_src) {
-    sType = copy_src.sType;
-    colorAttachmentCount = copy_src.colorAttachmentCount;
-    pColorAttachmentLocations = nullptr;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    if (copy_src.pColorAttachmentLocations) {
-        pColorAttachmentLocations = new uint32_t[copy_src.colorAttachmentCount];
-        memcpy((void*)pColorAttachmentLocations, (void*)copy_src.pColorAttachmentLocations,
-               sizeof(uint32_t) * copy_src.colorAttachmentCount);
-    }
-}
-
-safe_VkRenderingAttachmentLocationInfoKHR& safe_VkRenderingAttachmentLocationInfoKHR::operator=(
-    const safe_VkRenderingAttachmentLocationInfoKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    if (pColorAttachmentLocations) delete[] pColorAttachmentLocations;
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    colorAttachmentCount = copy_src.colorAttachmentCount;
-    pColorAttachmentLocations = nullptr;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    if (copy_src.pColorAttachmentLocations) {
-        pColorAttachmentLocations = new uint32_t[copy_src.colorAttachmentCount];
-        memcpy((void*)pColorAttachmentLocations, (void*)copy_src.pColorAttachmentLocations,
-               sizeof(uint32_t) * copy_src.colorAttachmentCount);
-    }
-
-    return *this;
-}
-
-safe_VkRenderingAttachmentLocationInfoKHR::~safe_VkRenderingAttachmentLocationInfoKHR() {
-    if (pColorAttachmentLocations) delete[] pColorAttachmentLocations;
-    FreePnextChain(pNext);
-}
-
-void safe_VkRenderingAttachmentLocationInfoKHR::initialize(const VkRenderingAttachmentLocationInfoKHR* in_struct,
-                                                           [[maybe_unused]] PNextCopyState* copy_state) {
-    if (pColorAttachmentLocations) delete[] pColorAttachmentLocations;
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    colorAttachmentCount = in_struct->colorAttachmentCount;
-    pColorAttachmentLocations = nullptr;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-
-    if (in_struct->pColorAttachmentLocations) {
-        pColorAttachmentLocations = new uint32_t[in_struct->colorAttachmentCount];
-        memcpy((void*)pColorAttachmentLocations, (void*)in_struct->pColorAttachmentLocations,
-               sizeof(uint32_t) * in_struct->colorAttachmentCount);
-    }
-}
-
-void safe_VkRenderingAttachmentLocationInfoKHR::initialize(const safe_VkRenderingAttachmentLocationInfoKHR* copy_src,
-                                                           [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    colorAttachmentCount = copy_src->colorAttachmentCount;
-    pColorAttachmentLocations = nullptr;
-    pNext = SafePnextCopy(copy_src->pNext);
-
-    if (copy_src->pColorAttachmentLocations) {
-        pColorAttachmentLocations = new uint32_t[copy_src->colorAttachmentCount];
-        memcpy((void*)pColorAttachmentLocations, (void*)copy_src->pColorAttachmentLocations,
-               sizeof(uint32_t) * copy_src->colorAttachmentCount);
-    }
-}
-
-safe_VkRenderingInputAttachmentIndexInfoKHR::safe_VkRenderingInputAttachmentIndexInfoKHR(
-    const VkRenderingInputAttachmentIndexInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType),
-      colorAttachmentCount(in_struct->colorAttachmentCount),
-      pColorAttachmentInputIndices(nullptr),
-      pDepthInputAttachmentIndex(nullptr),
-      pStencilInputAttachmentIndex(nullptr) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-    if (in_struct->pColorAttachmentInputIndices) {
-        pColorAttachmentInputIndices = new uint32_t[in_struct->colorAttachmentCount];
-        memcpy((void*)pColorAttachmentInputIndices, (void*)in_struct->pColorAttachmentInputIndices,
-               sizeof(uint32_t) * in_struct->colorAttachmentCount);
-    }
-
-    if (in_struct->pDepthInputAttachmentIndex) {
-        pDepthInputAttachmentIndex = new uint32_t(*in_struct->pDepthInputAttachmentIndex);
-    }
-
-    if (in_struct->pStencilInputAttachmentIndex) {
-        pStencilInputAttachmentIndex = new uint32_t(*in_struct->pStencilInputAttachmentIndex);
-    }
-}
-
-safe_VkRenderingInputAttachmentIndexInfoKHR::safe_VkRenderingInputAttachmentIndexInfoKHR()
-    : sType(VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR),
-      pNext(nullptr),
-      colorAttachmentCount(),
-      pColorAttachmentInputIndices(nullptr),
-      pDepthInputAttachmentIndex(nullptr),
-      pStencilInputAttachmentIndex(nullptr) {}
-
-safe_VkRenderingInputAttachmentIndexInfoKHR::safe_VkRenderingInputAttachmentIndexInfoKHR(
-    const safe_VkRenderingInputAttachmentIndexInfoKHR& copy_src) {
-    sType = copy_src.sType;
-    colorAttachmentCount = copy_src.colorAttachmentCount;
-    pColorAttachmentInputIndices = nullptr;
-    pDepthInputAttachmentIndex = nullptr;
-    pStencilInputAttachmentIndex = nullptr;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    if (copy_src.pColorAttachmentInputIndices) {
-        pColorAttachmentInputIndices = new uint32_t[copy_src.colorAttachmentCount];
-        memcpy((void*)pColorAttachmentInputIndices, (void*)copy_src.pColorAttachmentInputIndices,
-               sizeof(uint32_t) * copy_src.colorAttachmentCount);
-    }
-
-    if (copy_src.pDepthInputAttachmentIndex) {
-        pDepthInputAttachmentIndex = new uint32_t(*copy_src.pDepthInputAttachmentIndex);
-    }
-
-    if (copy_src.pStencilInputAttachmentIndex) {
-        pStencilInputAttachmentIndex = new uint32_t(*copy_src.pStencilInputAttachmentIndex);
-    }
-}
-
-safe_VkRenderingInputAttachmentIndexInfoKHR& safe_VkRenderingInputAttachmentIndexInfoKHR::operator=(
-    const safe_VkRenderingInputAttachmentIndexInfoKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    if (pColorAttachmentInputIndices) delete[] pColorAttachmentInputIndices;
-    if (pDepthInputAttachmentIndex) delete pDepthInputAttachmentIndex;
-    if (pStencilInputAttachmentIndex) delete pStencilInputAttachmentIndex;
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    colorAttachmentCount = copy_src.colorAttachmentCount;
-    pColorAttachmentInputIndices = nullptr;
-    pDepthInputAttachmentIndex = nullptr;
-    pStencilInputAttachmentIndex = nullptr;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    if (copy_src.pColorAttachmentInputIndices) {
-        pColorAttachmentInputIndices = new uint32_t[copy_src.colorAttachmentCount];
-        memcpy((void*)pColorAttachmentInputIndices, (void*)copy_src.pColorAttachmentInputIndices,
-               sizeof(uint32_t) * copy_src.colorAttachmentCount);
-    }
-
-    if (copy_src.pDepthInputAttachmentIndex) {
-        pDepthInputAttachmentIndex = new uint32_t(*copy_src.pDepthInputAttachmentIndex);
-    }
-
-    if (copy_src.pStencilInputAttachmentIndex) {
-        pStencilInputAttachmentIndex = new uint32_t(*copy_src.pStencilInputAttachmentIndex);
-    }
-
-    return *this;
-}
-
-safe_VkRenderingInputAttachmentIndexInfoKHR::~safe_VkRenderingInputAttachmentIndexInfoKHR() {
-    if (pColorAttachmentInputIndices) delete[] pColorAttachmentInputIndices;
-    if (pDepthInputAttachmentIndex) delete pDepthInputAttachmentIndex;
-    if (pStencilInputAttachmentIndex) delete pStencilInputAttachmentIndex;
-    FreePnextChain(pNext);
-}
-
-void safe_VkRenderingInputAttachmentIndexInfoKHR::initialize(const VkRenderingInputAttachmentIndexInfoKHR* in_struct,
-                                                             [[maybe_unused]] PNextCopyState* copy_state) {
-    if (pColorAttachmentInputIndices) delete[] pColorAttachmentInputIndices;
-    if (pDepthInputAttachmentIndex) delete pDepthInputAttachmentIndex;
-    if (pStencilInputAttachmentIndex) delete pStencilInputAttachmentIndex;
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    colorAttachmentCount = in_struct->colorAttachmentCount;
-    pColorAttachmentInputIndices = nullptr;
-    pDepthInputAttachmentIndex = nullptr;
-    pStencilInputAttachmentIndex = nullptr;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-
-    if (in_struct->pColorAttachmentInputIndices) {
-        pColorAttachmentInputIndices = new uint32_t[in_struct->colorAttachmentCount];
-        memcpy((void*)pColorAttachmentInputIndices, (void*)in_struct->pColorAttachmentInputIndices,
-               sizeof(uint32_t) * in_struct->colorAttachmentCount);
-    }
-
-    if (in_struct->pDepthInputAttachmentIndex) {
-        pDepthInputAttachmentIndex = new uint32_t(*in_struct->pDepthInputAttachmentIndex);
-    }
-
-    if (in_struct->pStencilInputAttachmentIndex) {
-        pStencilInputAttachmentIndex = new uint32_t(*in_struct->pStencilInputAttachmentIndex);
-    }
-}
-
-void safe_VkRenderingInputAttachmentIndexInfoKHR::initialize(const safe_VkRenderingInputAttachmentIndexInfoKHR* copy_src,
-                                                             [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    colorAttachmentCount = copy_src->colorAttachmentCount;
-    pColorAttachmentInputIndices = nullptr;
-    pDepthInputAttachmentIndex = nullptr;
-    pStencilInputAttachmentIndex = nullptr;
-    pNext = SafePnextCopy(copy_src->pNext);
-
-    if (copy_src->pColorAttachmentInputIndices) {
-        pColorAttachmentInputIndices = new uint32_t[copy_src->colorAttachmentCount];
-        memcpy((void*)pColorAttachmentInputIndices, (void*)copy_src->pColorAttachmentInputIndices,
-               sizeof(uint32_t) * copy_src->colorAttachmentCount);
-    }
-
-    if (copy_src->pDepthInputAttachmentIndex) {
-        pDepthInputAttachmentIndex = new uint32_t(*copy_src->pDepthInputAttachmentIndex);
-    }
-
-    if (copy_src->pStencilInputAttachmentIndex) {
-        pStencilInputAttachmentIndex = new uint32_t(*copy_src->pStencilInputAttachmentIndex);
-    }
-}
-
 safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR::safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR(
     const VkPhysicalDeviceShaderQuadControlFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType), shaderQuadControl(in_struct->shaderQuadControl) {
@@ -10113,114 +9609,6 @@ void safe_VkPipelineExecutableInternalRepresentationKHR::initialize(
     }
 }
 
-safe_VkMemoryMapInfoKHR::safe_VkMemoryMapInfoKHR(const VkMemoryMapInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
-                                                 bool copy_pnext)
-    : sType(in_struct->sType),
-      flags(in_struct->flags),
-      memory(in_struct->memory),
-      offset(in_struct->offset),
-      size(in_struct->size) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkMemoryMapInfoKHR::safe_VkMemoryMapInfoKHR()
-    : sType(VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR), pNext(nullptr), flags(), memory(), offset(), size() {}
-
-safe_VkMemoryMapInfoKHR::safe_VkMemoryMapInfoKHR(const safe_VkMemoryMapInfoKHR& copy_src) {
-    sType = copy_src.sType;
-    flags = copy_src.flags;
-    memory = copy_src.memory;
-    offset = copy_src.offset;
-    size = copy_src.size;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkMemoryMapInfoKHR& safe_VkMemoryMapInfoKHR::operator=(const safe_VkMemoryMapInfoKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    flags = copy_src.flags;
-    memory = copy_src.memory;
-    offset = copy_src.offset;
-    size = copy_src.size;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkMemoryMapInfoKHR::~safe_VkMemoryMapInfoKHR() { FreePnextChain(pNext); }
-
-void safe_VkMemoryMapInfoKHR::initialize(const VkMemoryMapInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    flags = in_struct->flags;
-    memory = in_struct->memory;
-    offset = in_struct->offset;
-    size = in_struct->size;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkMemoryMapInfoKHR::initialize(const safe_VkMemoryMapInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    flags = copy_src->flags;
-    memory = copy_src->memory;
-    offset = copy_src->offset;
-    size = copy_src->size;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkMemoryUnmapInfoKHR::safe_VkMemoryUnmapInfoKHR(const VkMemoryUnmapInfoKHR* in_struct,
-                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), flags(in_struct->flags), memory(in_struct->memory) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkMemoryUnmapInfoKHR::safe_VkMemoryUnmapInfoKHR()
-    : sType(VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR), pNext(nullptr), flags(), memory() {}
-
-safe_VkMemoryUnmapInfoKHR::safe_VkMemoryUnmapInfoKHR(const safe_VkMemoryUnmapInfoKHR& copy_src) {
-    sType = copy_src.sType;
-    flags = copy_src.flags;
-    memory = copy_src.memory;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkMemoryUnmapInfoKHR& safe_VkMemoryUnmapInfoKHR::operator=(const safe_VkMemoryUnmapInfoKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    flags = copy_src.flags;
-    memory = copy_src.memory;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkMemoryUnmapInfoKHR::~safe_VkMemoryUnmapInfoKHR() { FreePnextChain(pNext); }
-
-void safe_VkMemoryUnmapInfoKHR::initialize(const VkMemoryUnmapInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    flags = in_struct->flags;
-    memory = in_struct->memory;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkMemoryUnmapInfoKHR::initialize(const safe_VkMemoryUnmapInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    flags = copy_src->flags;
-    memory = copy_src->memory;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
 safe_VkPipelineLibraryCreateInfoKHR::safe_VkPipelineLibraryCreateInfoKHR(const VkPipelineLibraryCreateInfoKHR* in_struct,
                                                                          [[maybe_unused]] PNextCopyState* copy_state,
                                                                          bool copy_pnext)
@@ -11507,65 +10895,6 @@ void safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::initialize(
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
-safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR(
-    const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType),
-      shaderSubgroupRotate(in_struct->shaderSubgroupRotate),
-      shaderSubgroupRotateClustered(in_struct->shaderSubgroupRotateClustered) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR()
-    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR),
-      pNext(nullptr),
-      shaderSubgroupRotate(),
-      shaderSubgroupRotateClustered() {}
-
-safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR(
-    const safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR& copy_src) {
-    sType = copy_src.sType;
-    shaderSubgroupRotate = copy_src.shaderSubgroupRotate;
-    shaderSubgroupRotateClustered = copy_src.shaderSubgroupRotateClustered;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR& safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::operator=(
-    const safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    shaderSubgroupRotate = copy_src.shaderSubgroupRotate;
-    shaderSubgroupRotateClustered = copy_src.shaderSubgroupRotateClustered;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::~safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR() {
-    FreePnextChain(pNext);
-}
-
-void safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::initialize(
-    const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    shaderSubgroupRotate = in_struct->shaderSubgroupRotate;
-    shaderSubgroupRotateClustered = in_struct->shaderSubgroupRotateClustered;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR::initialize(
-    const safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    shaderSubgroupRotate = copy_src->shaderSubgroupRotate;
-    shaderSubgroupRotateClustered = copy_src->shaderSubgroupRotateClustered;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
 safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(
     const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
     bool copy_pnext)
@@ -11619,499 +10948,6 @@ void safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::initialize(
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
-safe_VkPhysicalDeviceMaintenance5FeaturesKHR::safe_VkPhysicalDeviceMaintenance5FeaturesKHR(
-    const VkPhysicalDeviceMaintenance5FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), maintenance5(in_struct->maintenance5) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkPhysicalDeviceMaintenance5FeaturesKHR::safe_VkPhysicalDeviceMaintenance5FeaturesKHR()
-    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR), pNext(nullptr), maintenance5() {}
-
-safe_VkPhysicalDeviceMaintenance5FeaturesKHR::safe_VkPhysicalDeviceMaintenance5FeaturesKHR(
-    const safe_VkPhysicalDeviceMaintenance5FeaturesKHR& copy_src) {
-    sType = copy_src.sType;
-    maintenance5 = copy_src.maintenance5;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPhysicalDeviceMaintenance5FeaturesKHR& safe_VkPhysicalDeviceMaintenance5FeaturesKHR::operator=(
-    const safe_VkPhysicalDeviceMaintenance5FeaturesKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    maintenance5 = copy_src.maintenance5;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkPhysicalDeviceMaintenance5FeaturesKHR::~safe_VkPhysicalDeviceMaintenance5FeaturesKHR() { FreePnextChain(pNext); }
-
-void safe_VkPhysicalDeviceMaintenance5FeaturesKHR::initialize(const VkPhysicalDeviceMaintenance5FeaturesKHR* in_struct,
-                                                              [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    maintenance5 = in_struct->maintenance5;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPhysicalDeviceMaintenance5FeaturesKHR::initialize(const safe_VkPhysicalDeviceMaintenance5FeaturesKHR* copy_src,
-                                                              [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    maintenance5 = copy_src->maintenance5;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkPhysicalDeviceMaintenance5PropertiesKHR::safe_VkPhysicalDeviceMaintenance5PropertiesKHR(
-    const VkPhysicalDeviceMaintenance5PropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType),
-      earlyFragmentMultisampleCoverageAfterSampleCounting(in_struct->earlyFragmentMultisampleCoverageAfterSampleCounting),
-      earlyFragmentSampleMaskTestBeforeSampleCounting(in_struct->earlyFragmentSampleMaskTestBeforeSampleCounting),
-      depthStencilSwizzleOneSupport(in_struct->depthStencilSwizzleOneSupport),
-      polygonModePointSize(in_struct->polygonModePointSize),
-      nonStrictSinglePixelWideLinesUseParallelogram(in_struct->nonStrictSinglePixelWideLinesUseParallelogram),
-      nonStrictWideLinesUseParallelogram(in_struct->nonStrictWideLinesUseParallelogram) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkPhysicalDeviceMaintenance5PropertiesKHR::safe_VkPhysicalDeviceMaintenance5PropertiesKHR()
-    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR),
-      pNext(nullptr),
-      earlyFragmentMultisampleCoverageAfterSampleCounting(),
-      earlyFragmentSampleMaskTestBeforeSampleCounting(),
-      depthStencilSwizzleOneSupport(),
-      polygonModePointSize(),
-      nonStrictSinglePixelWideLinesUseParallelogram(),
-      nonStrictWideLinesUseParallelogram() {}
-
-safe_VkPhysicalDeviceMaintenance5PropertiesKHR::safe_VkPhysicalDeviceMaintenance5PropertiesKHR(
-    const safe_VkPhysicalDeviceMaintenance5PropertiesKHR& copy_src) {
-    sType = copy_src.sType;
-    earlyFragmentMultisampleCoverageAfterSampleCounting = copy_src.earlyFragmentMultisampleCoverageAfterSampleCounting;
-    earlyFragmentSampleMaskTestBeforeSampleCounting = copy_src.earlyFragmentSampleMaskTestBeforeSampleCounting;
-    depthStencilSwizzleOneSupport = copy_src.depthStencilSwizzleOneSupport;
-    polygonModePointSize = copy_src.polygonModePointSize;
-    nonStrictSinglePixelWideLinesUseParallelogram = copy_src.nonStrictSinglePixelWideLinesUseParallelogram;
-    nonStrictWideLinesUseParallelogram = copy_src.nonStrictWideLinesUseParallelogram;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPhysicalDeviceMaintenance5PropertiesKHR& safe_VkPhysicalDeviceMaintenance5PropertiesKHR::operator=(
-    const safe_VkPhysicalDeviceMaintenance5PropertiesKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    earlyFragmentMultisampleCoverageAfterSampleCounting = copy_src.earlyFragmentMultisampleCoverageAfterSampleCounting;
-    earlyFragmentSampleMaskTestBeforeSampleCounting = copy_src.earlyFragmentSampleMaskTestBeforeSampleCounting;
-    depthStencilSwizzleOneSupport = copy_src.depthStencilSwizzleOneSupport;
-    polygonModePointSize = copy_src.polygonModePointSize;
-    nonStrictSinglePixelWideLinesUseParallelogram = copy_src.nonStrictSinglePixelWideLinesUseParallelogram;
-    nonStrictWideLinesUseParallelogram = copy_src.nonStrictWideLinesUseParallelogram;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkPhysicalDeviceMaintenance5PropertiesKHR::~safe_VkPhysicalDeviceMaintenance5PropertiesKHR() { FreePnextChain(pNext); }
-
-void safe_VkPhysicalDeviceMaintenance5PropertiesKHR::initialize(const VkPhysicalDeviceMaintenance5PropertiesKHR* in_struct,
-                                                                [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    earlyFragmentMultisampleCoverageAfterSampleCounting = in_struct->earlyFragmentMultisampleCoverageAfterSampleCounting;
-    earlyFragmentSampleMaskTestBeforeSampleCounting = in_struct->earlyFragmentSampleMaskTestBeforeSampleCounting;
-    depthStencilSwizzleOneSupport = in_struct->depthStencilSwizzleOneSupport;
-    polygonModePointSize = in_struct->polygonModePointSize;
-    nonStrictSinglePixelWideLinesUseParallelogram = in_struct->nonStrictSinglePixelWideLinesUseParallelogram;
-    nonStrictWideLinesUseParallelogram = in_struct->nonStrictWideLinesUseParallelogram;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPhysicalDeviceMaintenance5PropertiesKHR::initialize(const safe_VkPhysicalDeviceMaintenance5PropertiesKHR* copy_src,
-                                                                [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    earlyFragmentMultisampleCoverageAfterSampleCounting = copy_src->earlyFragmentMultisampleCoverageAfterSampleCounting;
-    earlyFragmentSampleMaskTestBeforeSampleCounting = copy_src->earlyFragmentSampleMaskTestBeforeSampleCounting;
-    depthStencilSwizzleOneSupport = copy_src->depthStencilSwizzleOneSupport;
-    polygonModePointSize = copy_src->polygonModePointSize;
-    nonStrictSinglePixelWideLinesUseParallelogram = copy_src->nonStrictSinglePixelWideLinesUseParallelogram;
-    nonStrictWideLinesUseParallelogram = copy_src->nonStrictWideLinesUseParallelogram;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkRenderingAreaInfoKHR::safe_VkRenderingAreaInfoKHR(const VkRenderingAreaInfoKHR* in_struct,
-                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType),
-      viewMask(in_struct->viewMask),
-      colorAttachmentCount(in_struct->colorAttachmentCount),
-      pColorAttachmentFormats(nullptr),
-      depthAttachmentFormat(in_struct->depthAttachmentFormat),
-      stencilAttachmentFormat(in_struct->stencilAttachmentFormat) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-    if (in_struct->pColorAttachmentFormats) {
-        pColorAttachmentFormats = new VkFormat[in_struct->colorAttachmentCount];
-        memcpy((void*)pColorAttachmentFormats, (void*)in_struct->pColorAttachmentFormats,
-               sizeof(VkFormat) * in_struct->colorAttachmentCount);
-    }
-}
-
-safe_VkRenderingAreaInfoKHR::safe_VkRenderingAreaInfoKHR()
-    : sType(VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR),
-      pNext(nullptr),
-      viewMask(),
-      colorAttachmentCount(),
-      pColorAttachmentFormats(nullptr),
-      depthAttachmentFormat(),
-      stencilAttachmentFormat() {}
-
-safe_VkRenderingAreaInfoKHR::safe_VkRenderingAreaInfoKHR(const safe_VkRenderingAreaInfoKHR& copy_src) {
-    sType = copy_src.sType;
-    viewMask = copy_src.viewMask;
-    colorAttachmentCount = copy_src.colorAttachmentCount;
-    pColorAttachmentFormats = nullptr;
-    depthAttachmentFormat = copy_src.depthAttachmentFormat;
-    stencilAttachmentFormat = copy_src.stencilAttachmentFormat;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    if (copy_src.pColorAttachmentFormats) {
-        pColorAttachmentFormats = new VkFormat[copy_src.colorAttachmentCount];
-        memcpy((void*)pColorAttachmentFormats, (void*)copy_src.pColorAttachmentFormats,
-               sizeof(VkFormat) * copy_src.colorAttachmentCount);
-    }
-}
-
-safe_VkRenderingAreaInfoKHR& safe_VkRenderingAreaInfoKHR::operator=(const safe_VkRenderingAreaInfoKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    if (pColorAttachmentFormats) delete[] pColorAttachmentFormats;
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    viewMask = copy_src.viewMask;
-    colorAttachmentCount = copy_src.colorAttachmentCount;
-    pColorAttachmentFormats = nullptr;
-    depthAttachmentFormat = copy_src.depthAttachmentFormat;
-    stencilAttachmentFormat = copy_src.stencilAttachmentFormat;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    if (copy_src.pColorAttachmentFormats) {
-        pColorAttachmentFormats = new VkFormat[copy_src.colorAttachmentCount];
-        memcpy((void*)pColorAttachmentFormats, (void*)copy_src.pColorAttachmentFormats,
-               sizeof(VkFormat) * copy_src.colorAttachmentCount);
-    }
-
-    return *this;
-}
-
-safe_VkRenderingAreaInfoKHR::~safe_VkRenderingAreaInfoKHR() {
-    if (pColorAttachmentFormats) delete[] pColorAttachmentFormats;
-    FreePnextChain(pNext);
-}
-
-void safe_VkRenderingAreaInfoKHR::initialize(const VkRenderingAreaInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
-    if (pColorAttachmentFormats) delete[] pColorAttachmentFormats;
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    viewMask = in_struct->viewMask;
-    colorAttachmentCount = in_struct->colorAttachmentCount;
-    pColorAttachmentFormats = nullptr;
-    depthAttachmentFormat = in_struct->depthAttachmentFormat;
-    stencilAttachmentFormat = in_struct->stencilAttachmentFormat;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-
-    if (in_struct->pColorAttachmentFormats) {
-        pColorAttachmentFormats = new VkFormat[in_struct->colorAttachmentCount];
-        memcpy((void*)pColorAttachmentFormats, (void*)in_struct->pColorAttachmentFormats,
-               sizeof(VkFormat) * in_struct->colorAttachmentCount);
-    }
-}
-
-void safe_VkRenderingAreaInfoKHR::initialize(const safe_VkRenderingAreaInfoKHR* copy_src,
-                                             [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    viewMask = copy_src->viewMask;
-    colorAttachmentCount = copy_src->colorAttachmentCount;
-    pColorAttachmentFormats = nullptr;
-    depthAttachmentFormat = copy_src->depthAttachmentFormat;
-    stencilAttachmentFormat = copy_src->stencilAttachmentFormat;
-    pNext = SafePnextCopy(copy_src->pNext);
-
-    if (copy_src->pColorAttachmentFormats) {
-        pColorAttachmentFormats = new VkFormat[copy_src->colorAttachmentCount];
-        memcpy((void*)pColorAttachmentFormats, (void*)copy_src->pColorAttachmentFormats,
-               sizeof(VkFormat) * copy_src->colorAttachmentCount);
-    }
-}
-
-safe_VkImageSubresource2KHR::safe_VkImageSubresource2KHR(const VkImageSubresource2KHR* in_struct,
-                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), imageSubresource(in_struct->imageSubresource) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkImageSubresource2KHR::safe_VkImageSubresource2KHR()
-    : sType(VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR), pNext(nullptr), imageSubresource() {}
-
-safe_VkImageSubresource2KHR::safe_VkImageSubresource2KHR(const safe_VkImageSubresource2KHR& copy_src) {
-    sType = copy_src.sType;
-    imageSubresource = copy_src.imageSubresource;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkImageSubresource2KHR& safe_VkImageSubresource2KHR::operator=(const safe_VkImageSubresource2KHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    imageSubresource = copy_src.imageSubresource;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkImageSubresource2KHR::~safe_VkImageSubresource2KHR() { FreePnextChain(pNext); }
-
-void safe_VkImageSubresource2KHR::initialize(const VkImageSubresource2KHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    imageSubresource = in_struct->imageSubresource;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkImageSubresource2KHR::initialize(const safe_VkImageSubresource2KHR* copy_src,
-                                             [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    imageSubresource = copy_src->imageSubresource;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkDeviceImageSubresourceInfoKHR::safe_VkDeviceImageSubresourceInfoKHR(const VkDeviceImageSubresourceInfoKHR* in_struct,
-                                                                           [[maybe_unused]] PNextCopyState* copy_state,
-                                                                           bool copy_pnext)
-    : sType(in_struct->sType), pCreateInfo(nullptr), pSubresource(nullptr) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-    if (in_struct->pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(in_struct->pCreateInfo);
-    if (in_struct->pSubresource) pSubresource = new safe_VkImageSubresource2KHR(in_struct->pSubresource);
-}
-
-safe_VkDeviceImageSubresourceInfoKHR::safe_VkDeviceImageSubresourceInfoKHR()
-    : sType(VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR), pNext(nullptr), pCreateInfo(nullptr), pSubresource(nullptr) {}
-
-safe_VkDeviceImageSubresourceInfoKHR::safe_VkDeviceImageSubresourceInfoKHR(const safe_VkDeviceImageSubresourceInfoKHR& copy_src) {
-    sType = copy_src.sType;
-    pCreateInfo = nullptr;
-    pSubresource = nullptr;
-    pNext = SafePnextCopy(copy_src.pNext);
-    if (copy_src.pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(*copy_src.pCreateInfo);
-    if (copy_src.pSubresource) pSubresource = new safe_VkImageSubresource2KHR(*copy_src.pSubresource);
-}
-
-safe_VkDeviceImageSubresourceInfoKHR& safe_VkDeviceImageSubresourceInfoKHR::operator=(
-    const safe_VkDeviceImageSubresourceInfoKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    if (pCreateInfo) delete pCreateInfo;
-    if (pSubresource) delete pSubresource;
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    pCreateInfo = nullptr;
-    pSubresource = nullptr;
-    pNext = SafePnextCopy(copy_src.pNext);
-    if (copy_src.pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(*copy_src.pCreateInfo);
-    if (copy_src.pSubresource) pSubresource = new safe_VkImageSubresource2KHR(*copy_src.pSubresource);
-
-    return *this;
-}
-
-safe_VkDeviceImageSubresourceInfoKHR::~safe_VkDeviceImageSubresourceInfoKHR() {
-    if (pCreateInfo) delete pCreateInfo;
-    if (pSubresource) delete pSubresource;
-    FreePnextChain(pNext);
-}
-
-void safe_VkDeviceImageSubresourceInfoKHR::initialize(const VkDeviceImageSubresourceInfoKHR* in_struct,
-                                                      [[maybe_unused]] PNextCopyState* copy_state) {
-    if (pCreateInfo) delete pCreateInfo;
-    if (pSubresource) delete pSubresource;
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    pCreateInfo = nullptr;
-    pSubresource = nullptr;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    if (in_struct->pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(in_struct->pCreateInfo);
-    if (in_struct->pSubresource) pSubresource = new safe_VkImageSubresource2KHR(in_struct->pSubresource);
-}
-
-void safe_VkDeviceImageSubresourceInfoKHR::initialize(const safe_VkDeviceImageSubresourceInfoKHR* copy_src,
-                                                      [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    pCreateInfo = nullptr;
-    pSubresource = nullptr;
-    pNext = SafePnextCopy(copy_src->pNext);
-    if (copy_src->pCreateInfo) pCreateInfo = new safe_VkImageCreateInfo(*copy_src->pCreateInfo);
-    if (copy_src->pSubresource) pSubresource = new safe_VkImageSubresource2KHR(*copy_src->pSubresource);
-}
-
-safe_VkSubresourceLayout2KHR::safe_VkSubresourceLayout2KHR(const VkSubresourceLayout2KHR* in_struct,
-                                                           [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), subresourceLayout(in_struct->subresourceLayout) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkSubresourceLayout2KHR::safe_VkSubresourceLayout2KHR()
-    : sType(VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR), pNext(nullptr), subresourceLayout() {}
-
-safe_VkSubresourceLayout2KHR::safe_VkSubresourceLayout2KHR(const safe_VkSubresourceLayout2KHR& copy_src) {
-    sType = copy_src.sType;
-    subresourceLayout = copy_src.subresourceLayout;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkSubresourceLayout2KHR& safe_VkSubresourceLayout2KHR::operator=(const safe_VkSubresourceLayout2KHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    subresourceLayout = copy_src.subresourceLayout;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkSubresourceLayout2KHR::~safe_VkSubresourceLayout2KHR() { FreePnextChain(pNext); }
-
-void safe_VkSubresourceLayout2KHR::initialize(const VkSubresourceLayout2KHR* in_struct,
-                                              [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    subresourceLayout = in_struct->subresourceLayout;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkSubresourceLayout2KHR::initialize(const safe_VkSubresourceLayout2KHR* copy_src,
-                                              [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    subresourceLayout = copy_src->subresourceLayout;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkPipelineCreateFlags2CreateInfoKHR::safe_VkPipelineCreateFlags2CreateInfoKHR(
-    const VkPipelineCreateFlags2CreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), flags(in_struct->flags) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkPipelineCreateFlags2CreateInfoKHR::safe_VkPipelineCreateFlags2CreateInfoKHR()
-    : sType(VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR), pNext(nullptr), flags() {}
-
-safe_VkPipelineCreateFlags2CreateInfoKHR::safe_VkPipelineCreateFlags2CreateInfoKHR(
-    const safe_VkPipelineCreateFlags2CreateInfoKHR& copy_src) {
-    sType = copy_src.sType;
-    flags = copy_src.flags;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPipelineCreateFlags2CreateInfoKHR& safe_VkPipelineCreateFlags2CreateInfoKHR::operator=(
-    const safe_VkPipelineCreateFlags2CreateInfoKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    flags = copy_src.flags;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkPipelineCreateFlags2CreateInfoKHR::~safe_VkPipelineCreateFlags2CreateInfoKHR() { FreePnextChain(pNext); }
-
-void safe_VkPipelineCreateFlags2CreateInfoKHR::initialize(const VkPipelineCreateFlags2CreateInfoKHR* in_struct,
-                                                          [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    flags = in_struct->flags;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPipelineCreateFlags2CreateInfoKHR::initialize(const safe_VkPipelineCreateFlags2CreateInfoKHR* copy_src,
-                                                          [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    flags = copy_src->flags;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkBufferUsageFlags2CreateInfoKHR::safe_VkBufferUsageFlags2CreateInfoKHR(const VkBufferUsageFlags2CreateInfoKHR* in_struct,
-                                                                             [[maybe_unused]] PNextCopyState* copy_state,
-                                                                             bool copy_pnext)
-    : sType(in_struct->sType), usage(in_struct->usage) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkBufferUsageFlags2CreateInfoKHR::safe_VkBufferUsageFlags2CreateInfoKHR()
-    : sType(VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR), pNext(nullptr), usage() {}
-
-safe_VkBufferUsageFlags2CreateInfoKHR::safe_VkBufferUsageFlags2CreateInfoKHR(
-    const safe_VkBufferUsageFlags2CreateInfoKHR& copy_src) {
-    sType = copy_src.sType;
-    usage = copy_src.usage;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkBufferUsageFlags2CreateInfoKHR& safe_VkBufferUsageFlags2CreateInfoKHR::operator=(
-    const safe_VkBufferUsageFlags2CreateInfoKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    usage = copy_src.usage;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkBufferUsageFlags2CreateInfoKHR::~safe_VkBufferUsageFlags2CreateInfoKHR() { FreePnextChain(pNext); }
-
-void safe_VkBufferUsageFlags2CreateInfoKHR::initialize(const VkBufferUsageFlags2CreateInfoKHR* in_struct,
-                                                       [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    usage = in_struct->usage;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkBufferUsageFlags2CreateInfoKHR::initialize(const safe_VkBufferUsageFlags2CreateInfoKHR* copy_src,
-                                                       [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    usage = copy_src->usage;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
 safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
     const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
     bool copy_pnext)
@@ -14857,513 +13693,6 @@ void safe_VkVideoInlineQueryInfoKHR::initialize(const safe_VkVideoInlineQueryInf
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
-safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR(
-    const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
-    bool copy_pnext)
-    : sType(in_struct->sType),
-      maxVertexAttribDivisor(in_struct->maxVertexAttribDivisor),
-      supportsNonZeroFirstInstance(in_struct->supportsNonZeroFirstInstance) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR()
-    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR),
-      pNext(nullptr),
-      maxVertexAttribDivisor(),
-      supportsNonZeroFirstInstance() {}
-
-safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR(
-    const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& copy_src) {
-    sType = copy_src.sType;
-    maxVertexAttribDivisor = copy_src.maxVertexAttribDivisor;
-    supportsNonZeroFirstInstance = copy_src.supportsNonZeroFirstInstance;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::operator=(
-    const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    maxVertexAttribDivisor = copy_src.maxVertexAttribDivisor;
-    supportsNonZeroFirstInstance = copy_src.supportsNonZeroFirstInstance;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::~safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR() {
-    FreePnextChain(pNext);
-}
-
-void safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::initialize(
-    const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    maxVertexAttribDivisor = in_struct->maxVertexAttribDivisor;
-    supportsNonZeroFirstInstance = in_struct->supportsNonZeroFirstInstance;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR::initialize(
-    const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    maxVertexAttribDivisor = copy_src->maxVertexAttribDivisor;
-    supportsNonZeroFirstInstance = copy_src->supportsNonZeroFirstInstance;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::safe_VkPipelineVertexInputDivisorStateCreateInfoKHR(
-    const VkPipelineVertexInputDivisorStateCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), vertexBindingDivisorCount(in_struct->vertexBindingDivisorCount), pVertexBindingDivisors(nullptr) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-    if (in_struct->pVertexBindingDivisors) {
-        pVertexBindingDivisors = new VkVertexInputBindingDivisorDescriptionKHR[in_struct->vertexBindingDivisorCount];
-        memcpy((void*)pVertexBindingDivisors, (void*)in_struct->pVertexBindingDivisors,
-               sizeof(VkVertexInputBindingDivisorDescriptionKHR) * in_struct->vertexBindingDivisorCount);
-    }
-}
-
-safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::safe_VkPipelineVertexInputDivisorStateCreateInfoKHR()
-    : sType(VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR),
-      pNext(nullptr),
-      vertexBindingDivisorCount(),
-      pVertexBindingDivisors(nullptr) {}
-
-safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::safe_VkPipelineVertexInputDivisorStateCreateInfoKHR(
-    const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR& copy_src) {
-    sType = copy_src.sType;
-    vertexBindingDivisorCount = copy_src.vertexBindingDivisorCount;
-    pVertexBindingDivisors = nullptr;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    if (copy_src.pVertexBindingDivisors) {
-        pVertexBindingDivisors = new VkVertexInputBindingDivisorDescriptionKHR[copy_src.vertexBindingDivisorCount];
-        memcpy((void*)pVertexBindingDivisors, (void*)copy_src.pVertexBindingDivisors,
-               sizeof(VkVertexInputBindingDivisorDescriptionKHR) * copy_src.vertexBindingDivisorCount);
-    }
-}
-
-safe_VkPipelineVertexInputDivisorStateCreateInfoKHR& safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::operator=(
-    const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    if (pVertexBindingDivisors) delete[] pVertexBindingDivisors;
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    vertexBindingDivisorCount = copy_src.vertexBindingDivisorCount;
-    pVertexBindingDivisors = nullptr;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    if (copy_src.pVertexBindingDivisors) {
-        pVertexBindingDivisors = new VkVertexInputBindingDivisorDescriptionKHR[copy_src.vertexBindingDivisorCount];
-        memcpy((void*)pVertexBindingDivisors, (void*)copy_src.pVertexBindingDivisors,
-               sizeof(VkVertexInputBindingDivisorDescriptionKHR) * copy_src.vertexBindingDivisorCount);
-    }
-
-    return *this;
-}
-
-safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::~safe_VkPipelineVertexInputDivisorStateCreateInfoKHR() {
-    if (pVertexBindingDivisors) delete[] pVertexBindingDivisors;
-    FreePnextChain(pNext);
-}
-
-void safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::initialize(
-    const VkPipelineVertexInputDivisorStateCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
-    if (pVertexBindingDivisors) delete[] pVertexBindingDivisors;
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    vertexBindingDivisorCount = in_struct->vertexBindingDivisorCount;
-    pVertexBindingDivisors = nullptr;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-
-    if (in_struct->pVertexBindingDivisors) {
-        pVertexBindingDivisors = new VkVertexInputBindingDivisorDescriptionKHR[in_struct->vertexBindingDivisorCount];
-        memcpy((void*)pVertexBindingDivisors, (void*)in_struct->pVertexBindingDivisors,
-               sizeof(VkVertexInputBindingDivisorDescriptionKHR) * in_struct->vertexBindingDivisorCount);
-    }
-}
-
-void safe_VkPipelineVertexInputDivisorStateCreateInfoKHR::initialize(
-    const safe_VkPipelineVertexInputDivisorStateCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    vertexBindingDivisorCount = copy_src->vertexBindingDivisorCount;
-    pVertexBindingDivisors = nullptr;
-    pNext = SafePnextCopy(copy_src->pNext);
-
-    if (copy_src->pVertexBindingDivisors) {
-        pVertexBindingDivisors = new VkVertexInputBindingDivisorDescriptionKHR[copy_src->vertexBindingDivisorCount];
-        memcpy((void*)pVertexBindingDivisors, (void*)copy_src->pVertexBindingDivisors,
-               sizeof(VkVertexInputBindingDivisorDescriptionKHR) * copy_src->vertexBindingDivisorCount);
-    }
-}
-
-safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR(
-    const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
-    bool copy_pnext)
-    : sType(in_struct->sType),
-      vertexAttributeInstanceRateDivisor(in_struct->vertexAttributeInstanceRateDivisor),
-      vertexAttributeInstanceRateZeroDivisor(in_struct->vertexAttributeInstanceRateZeroDivisor) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR()
-    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR),
-      pNext(nullptr),
-      vertexAttributeInstanceRateDivisor(),
-      vertexAttributeInstanceRateZeroDivisor() {}
-
-safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR(
-    const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& copy_src) {
-    sType = copy_src.sType;
-    vertexAttributeInstanceRateDivisor = copy_src.vertexAttributeInstanceRateDivisor;
-    vertexAttributeInstanceRateZeroDivisor = copy_src.vertexAttributeInstanceRateZeroDivisor;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::operator=(
-    const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    vertexAttributeInstanceRateDivisor = copy_src.vertexAttributeInstanceRateDivisor;
-    vertexAttributeInstanceRateZeroDivisor = copy_src.vertexAttributeInstanceRateZeroDivisor;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::~safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR() {
-    FreePnextChain(pNext);
-}
-
-void safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::initialize(
-    const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    vertexAttributeInstanceRateDivisor = in_struct->vertexAttributeInstanceRateDivisor;
-    vertexAttributeInstanceRateZeroDivisor = in_struct->vertexAttributeInstanceRateZeroDivisor;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR::initialize(
-    const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    vertexAttributeInstanceRateDivisor = copy_src->vertexAttributeInstanceRateDivisor;
-    vertexAttributeInstanceRateZeroDivisor = copy_src->vertexAttributeInstanceRateZeroDivisor;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR(
-    const VkPhysicalDeviceShaderFloatControls2FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), shaderFloatControls2(in_struct->shaderFloatControls2) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR()
-    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR), pNext(nullptr), shaderFloatControls2() {}
-
-safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR(
-    const safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR& copy_src) {
-    sType = copy_src.sType;
-    shaderFloatControls2 = copy_src.shaderFloatControls2;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR& safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::operator=(
-    const safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    shaderFloatControls2 = copy_src.shaderFloatControls2;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::~safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR() {
-    FreePnextChain(pNext);
-}
-
-void safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::initialize(
-    const VkPhysicalDeviceShaderFloatControls2FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    shaderFloatControls2 = in_struct->shaderFloatControls2;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR::initialize(
-    const safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    shaderFloatControls2 = copy_src->shaderFloatControls2;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR(
-    const VkPhysicalDeviceIndexTypeUint8FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), indexTypeUint8(in_struct->indexTypeUint8) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR()
-    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR), pNext(nullptr), indexTypeUint8() {}
-
-safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR(
-    const safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR& copy_src) {
-    sType = copy_src.sType;
-    indexTypeUint8 = copy_src.indexTypeUint8;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR& safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::operator=(
-    const safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    indexTypeUint8 = copy_src.indexTypeUint8;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::~safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR() { FreePnextChain(pNext); }
-
-void safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::initialize(const VkPhysicalDeviceIndexTypeUint8FeaturesKHR* in_struct,
-                                                                [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    indexTypeUint8 = in_struct->indexTypeUint8;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR::initialize(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR* copy_src,
-                                                                [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    indexTypeUint8 = copy_src->indexTypeUint8;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::safe_VkPhysicalDeviceLineRasterizationFeaturesKHR(
-    const VkPhysicalDeviceLineRasterizationFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType),
-      rectangularLines(in_struct->rectangularLines),
-      bresenhamLines(in_struct->bresenhamLines),
-      smoothLines(in_struct->smoothLines),
-      stippledRectangularLines(in_struct->stippledRectangularLines),
-      stippledBresenhamLines(in_struct->stippledBresenhamLines),
-      stippledSmoothLines(in_struct->stippledSmoothLines) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::safe_VkPhysicalDeviceLineRasterizationFeaturesKHR()
-    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR),
-      pNext(nullptr),
-      rectangularLines(),
-      bresenhamLines(),
-      smoothLines(),
-      stippledRectangularLines(),
-      stippledBresenhamLines(),
-      stippledSmoothLines() {}
-
-safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::safe_VkPhysicalDeviceLineRasterizationFeaturesKHR(
-    const safe_VkPhysicalDeviceLineRasterizationFeaturesKHR& copy_src) {
-    sType = copy_src.sType;
-    rectangularLines = copy_src.rectangularLines;
-    bresenhamLines = copy_src.bresenhamLines;
-    smoothLines = copy_src.smoothLines;
-    stippledRectangularLines = copy_src.stippledRectangularLines;
-    stippledBresenhamLines = copy_src.stippledBresenhamLines;
-    stippledSmoothLines = copy_src.stippledSmoothLines;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPhysicalDeviceLineRasterizationFeaturesKHR& safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::operator=(
-    const safe_VkPhysicalDeviceLineRasterizationFeaturesKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    rectangularLines = copy_src.rectangularLines;
-    bresenhamLines = copy_src.bresenhamLines;
-    smoothLines = copy_src.smoothLines;
-    stippledRectangularLines = copy_src.stippledRectangularLines;
-    stippledBresenhamLines = copy_src.stippledBresenhamLines;
-    stippledSmoothLines = copy_src.stippledSmoothLines;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::~safe_VkPhysicalDeviceLineRasterizationFeaturesKHR() { FreePnextChain(pNext); }
-
-void safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::initialize(const VkPhysicalDeviceLineRasterizationFeaturesKHR* in_struct,
-                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    rectangularLines = in_struct->rectangularLines;
-    bresenhamLines = in_struct->bresenhamLines;
-    smoothLines = in_struct->smoothLines;
-    stippledRectangularLines = in_struct->stippledRectangularLines;
-    stippledBresenhamLines = in_struct->stippledBresenhamLines;
-    stippledSmoothLines = in_struct->stippledSmoothLines;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPhysicalDeviceLineRasterizationFeaturesKHR::initialize(
-    const safe_VkPhysicalDeviceLineRasterizationFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    rectangularLines = copy_src->rectangularLines;
-    bresenhamLines = copy_src->bresenhamLines;
-    smoothLines = copy_src->smoothLines;
-    stippledRectangularLines = copy_src->stippledRectangularLines;
-    stippledBresenhamLines = copy_src->stippledBresenhamLines;
-    stippledSmoothLines = copy_src->stippledSmoothLines;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::safe_VkPhysicalDeviceLineRasterizationPropertiesKHR(
-    const VkPhysicalDeviceLineRasterizationPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), lineSubPixelPrecisionBits(in_struct->lineSubPixelPrecisionBits) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::safe_VkPhysicalDeviceLineRasterizationPropertiesKHR()
-    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR), pNext(nullptr), lineSubPixelPrecisionBits() {}
-
-safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::safe_VkPhysicalDeviceLineRasterizationPropertiesKHR(
-    const safe_VkPhysicalDeviceLineRasterizationPropertiesKHR& copy_src) {
-    sType = copy_src.sType;
-    lineSubPixelPrecisionBits = copy_src.lineSubPixelPrecisionBits;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPhysicalDeviceLineRasterizationPropertiesKHR& safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::operator=(
-    const safe_VkPhysicalDeviceLineRasterizationPropertiesKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    lineSubPixelPrecisionBits = copy_src.lineSubPixelPrecisionBits;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::~safe_VkPhysicalDeviceLineRasterizationPropertiesKHR() {
-    FreePnextChain(pNext);
-}
-
-void safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::initialize(
-    const VkPhysicalDeviceLineRasterizationPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    lineSubPixelPrecisionBits = in_struct->lineSubPixelPrecisionBits;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPhysicalDeviceLineRasterizationPropertiesKHR::initialize(
-    const safe_VkPhysicalDeviceLineRasterizationPropertiesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    lineSubPixelPrecisionBits = copy_src->lineSubPixelPrecisionBits;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkPipelineRasterizationLineStateCreateInfoKHR::safe_VkPipelineRasterizationLineStateCreateInfoKHR(
-    const VkPipelineRasterizationLineStateCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType),
-      lineRasterizationMode(in_struct->lineRasterizationMode),
-      stippledLineEnable(in_struct->stippledLineEnable),
-      lineStippleFactor(in_struct->lineStippleFactor),
-      lineStipplePattern(in_struct->lineStipplePattern) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkPipelineRasterizationLineStateCreateInfoKHR::safe_VkPipelineRasterizationLineStateCreateInfoKHR()
-    : sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR),
-      pNext(nullptr),
-      lineRasterizationMode(),
-      stippledLineEnable(),
-      lineStippleFactor(),
-      lineStipplePattern() {}
-
-safe_VkPipelineRasterizationLineStateCreateInfoKHR::safe_VkPipelineRasterizationLineStateCreateInfoKHR(
-    const safe_VkPipelineRasterizationLineStateCreateInfoKHR& copy_src) {
-    sType = copy_src.sType;
-    lineRasterizationMode = copy_src.lineRasterizationMode;
-    stippledLineEnable = copy_src.stippledLineEnable;
-    lineStippleFactor = copy_src.lineStippleFactor;
-    lineStipplePattern = copy_src.lineStipplePattern;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPipelineRasterizationLineStateCreateInfoKHR& safe_VkPipelineRasterizationLineStateCreateInfoKHR::operator=(
-    const safe_VkPipelineRasterizationLineStateCreateInfoKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    lineRasterizationMode = copy_src.lineRasterizationMode;
-    stippledLineEnable = copy_src.stippledLineEnable;
-    lineStippleFactor = copy_src.lineStippleFactor;
-    lineStipplePattern = copy_src.lineStipplePattern;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkPipelineRasterizationLineStateCreateInfoKHR::~safe_VkPipelineRasterizationLineStateCreateInfoKHR() { FreePnextChain(pNext); }
-
-void safe_VkPipelineRasterizationLineStateCreateInfoKHR::initialize(const VkPipelineRasterizationLineStateCreateInfoKHR* in_struct,
-                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    lineRasterizationMode = in_struct->lineRasterizationMode;
-    stippledLineEnable = in_struct->stippledLineEnable;
-    lineStippleFactor = in_struct->lineStippleFactor;
-    lineStipplePattern = in_struct->lineStipplePattern;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPipelineRasterizationLineStateCreateInfoKHR::initialize(
-    const safe_VkPipelineRasterizationLineStateCreateInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    lineRasterizationMode = copy_src->lineRasterizationMode;
-    stippledLineEnable = copy_src->stippledLineEnable;
-    lineStippleFactor = copy_src->lineStippleFactor;
-    lineStipplePattern = copy_src->lineStipplePattern;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
 safe_VkCalibratedTimestampInfoKHR::safe_VkCalibratedTimestampInfoKHR(const VkCalibratedTimestampInfoKHR* in_struct,
                                                                      [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType), timeDomain(in_struct->timeDomain) {
@@ -15410,641 +13739,6 @@ void safe_VkCalibratedTimestampInfoKHR::initialize(const safe_VkCalibratedTimest
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
-safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR(
-    const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), shaderExpectAssume(in_struct->shaderExpectAssume) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR()
-    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR), pNext(nullptr), shaderExpectAssume() {}
-
-safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR(
-    const safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR& copy_src) {
-    sType = copy_src.sType;
-    shaderExpectAssume = copy_src.shaderExpectAssume;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR& safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::operator=(
-    const safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    shaderExpectAssume = copy_src.shaderExpectAssume;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::~safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR() { FreePnextChain(pNext); }
-
-void safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::initialize(const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* in_struct,
-                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    shaderExpectAssume = in_struct->shaderExpectAssume;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR::initialize(
-    const safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    shaderExpectAssume = copy_src->shaderExpectAssume;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkPhysicalDeviceMaintenance6FeaturesKHR::safe_VkPhysicalDeviceMaintenance6FeaturesKHR(
-    const VkPhysicalDeviceMaintenance6FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), maintenance6(in_struct->maintenance6) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkPhysicalDeviceMaintenance6FeaturesKHR::safe_VkPhysicalDeviceMaintenance6FeaturesKHR()
-    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR), pNext(nullptr), maintenance6() {}
-
-safe_VkPhysicalDeviceMaintenance6FeaturesKHR::safe_VkPhysicalDeviceMaintenance6FeaturesKHR(
-    const safe_VkPhysicalDeviceMaintenance6FeaturesKHR& copy_src) {
-    sType = copy_src.sType;
-    maintenance6 = copy_src.maintenance6;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPhysicalDeviceMaintenance6FeaturesKHR& safe_VkPhysicalDeviceMaintenance6FeaturesKHR::operator=(
-    const safe_VkPhysicalDeviceMaintenance6FeaturesKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    maintenance6 = copy_src.maintenance6;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkPhysicalDeviceMaintenance6FeaturesKHR::~safe_VkPhysicalDeviceMaintenance6FeaturesKHR() { FreePnextChain(pNext); }
-
-void safe_VkPhysicalDeviceMaintenance6FeaturesKHR::initialize(const VkPhysicalDeviceMaintenance6FeaturesKHR* in_struct,
-                                                              [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    maintenance6 = in_struct->maintenance6;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPhysicalDeviceMaintenance6FeaturesKHR::initialize(const safe_VkPhysicalDeviceMaintenance6FeaturesKHR* copy_src,
-                                                              [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    maintenance6 = copy_src->maintenance6;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkPhysicalDeviceMaintenance6PropertiesKHR::safe_VkPhysicalDeviceMaintenance6PropertiesKHR(
-    const VkPhysicalDeviceMaintenance6PropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType),
-      blockTexelViewCompatibleMultipleLayers(in_struct->blockTexelViewCompatibleMultipleLayers),
-      maxCombinedImageSamplerDescriptorCount(in_struct->maxCombinedImageSamplerDescriptorCount),
-      fragmentShadingRateClampCombinerInputs(in_struct->fragmentShadingRateClampCombinerInputs) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkPhysicalDeviceMaintenance6PropertiesKHR::safe_VkPhysicalDeviceMaintenance6PropertiesKHR()
-    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR),
-      pNext(nullptr),
-      blockTexelViewCompatibleMultipleLayers(),
-      maxCombinedImageSamplerDescriptorCount(),
-      fragmentShadingRateClampCombinerInputs() {}
-
-safe_VkPhysicalDeviceMaintenance6PropertiesKHR::safe_VkPhysicalDeviceMaintenance6PropertiesKHR(
-    const safe_VkPhysicalDeviceMaintenance6PropertiesKHR& copy_src) {
-    sType = copy_src.sType;
-    blockTexelViewCompatibleMultipleLayers = copy_src.blockTexelViewCompatibleMultipleLayers;
-    maxCombinedImageSamplerDescriptorCount = copy_src.maxCombinedImageSamplerDescriptorCount;
-    fragmentShadingRateClampCombinerInputs = copy_src.fragmentShadingRateClampCombinerInputs;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPhysicalDeviceMaintenance6PropertiesKHR& safe_VkPhysicalDeviceMaintenance6PropertiesKHR::operator=(
-    const safe_VkPhysicalDeviceMaintenance6PropertiesKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    blockTexelViewCompatibleMultipleLayers = copy_src.blockTexelViewCompatibleMultipleLayers;
-    maxCombinedImageSamplerDescriptorCount = copy_src.maxCombinedImageSamplerDescriptorCount;
-    fragmentShadingRateClampCombinerInputs = copy_src.fragmentShadingRateClampCombinerInputs;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkPhysicalDeviceMaintenance6PropertiesKHR::~safe_VkPhysicalDeviceMaintenance6PropertiesKHR() { FreePnextChain(pNext); }
-
-void safe_VkPhysicalDeviceMaintenance6PropertiesKHR::initialize(const VkPhysicalDeviceMaintenance6PropertiesKHR* in_struct,
-                                                                [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    blockTexelViewCompatibleMultipleLayers = in_struct->blockTexelViewCompatibleMultipleLayers;
-    maxCombinedImageSamplerDescriptorCount = in_struct->maxCombinedImageSamplerDescriptorCount;
-    fragmentShadingRateClampCombinerInputs = in_struct->fragmentShadingRateClampCombinerInputs;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPhysicalDeviceMaintenance6PropertiesKHR::initialize(const safe_VkPhysicalDeviceMaintenance6PropertiesKHR* copy_src,
-                                                                [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    blockTexelViewCompatibleMultipleLayers = copy_src->blockTexelViewCompatibleMultipleLayers;
-    maxCombinedImageSamplerDescriptorCount = copy_src->maxCombinedImageSamplerDescriptorCount;
-    fragmentShadingRateClampCombinerInputs = copy_src->fragmentShadingRateClampCombinerInputs;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkBindMemoryStatusKHR::safe_VkBindMemoryStatusKHR(const VkBindMemoryStatusKHR* in_struct,
-                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), pResult(nullptr) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-    if (in_struct->pResult) {
-        pResult = new VkResult(*in_struct->pResult);
-    }
-}
-
-safe_VkBindMemoryStatusKHR::safe_VkBindMemoryStatusKHR()
-    : sType(VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR), pNext(nullptr), pResult(nullptr) {}
-
-safe_VkBindMemoryStatusKHR::safe_VkBindMemoryStatusKHR(const safe_VkBindMemoryStatusKHR& copy_src) {
-    sType = copy_src.sType;
-    pResult = nullptr;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    if (copy_src.pResult) {
-        pResult = new VkResult(*copy_src.pResult);
-    }
-}
-
-safe_VkBindMemoryStatusKHR& safe_VkBindMemoryStatusKHR::operator=(const safe_VkBindMemoryStatusKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    if (pResult) delete pResult;
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    pResult = nullptr;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    if (copy_src.pResult) {
-        pResult = new VkResult(*copy_src.pResult);
-    }
-
-    return *this;
-}
-
-safe_VkBindMemoryStatusKHR::~safe_VkBindMemoryStatusKHR() {
-    if (pResult) delete pResult;
-    FreePnextChain(pNext);
-}
-
-void safe_VkBindMemoryStatusKHR::initialize(const VkBindMemoryStatusKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
-    if (pResult) delete pResult;
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    pResult = nullptr;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-
-    if (in_struct->pResult) {
-        pResult = new VkResult(*in_struct->pResult);
-    }
-}
-
-void safe_VkBindMemoryStatusKHR::initialize(const safe_VkBindMemoryStatusKHR* copy_src,
-                                            [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    pResult = nullptr;
-    pNext = SafePnextCopy(copy_src->pNext);
-
-    if (copy_src->pResult) {
-        pResult = new VkResult(*copy_src->pResult);
-    }
-}
-
-safe_VkBindDescriptorSetsInfoKHR::safe_VkBindDescriptorSetsInfoKHR(const VkBindDescriptorSetsInfoKHR* in_struct,
-                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType),
-      stageFlags(in_struct->stageFlags),
-      layout(in_struct->layout),
-      firstSet(in_struct->firstSet),
-      descriptorSetCount(in_struct->descriptorSetCount),
-      pDescriptorSets(nullptr),
-      dynamicOffsetCount(in_struct->dynamicOffsetCount),
-      pDynamicOffsets(nullptr) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-    if (descriptorSetCount && in_struct->pDescriptorSets) {
-        pDescriptorSets = new VkDescriptorSet[descriptorSetCount];
-        for (uint32_t i = 0; i < descriptorSetCount; ++i) {
-            pDescriptorSets[i] = in_struct->pDescriptorSets[i];
-        }
-    }
-
-    if (in_struct->pDynamicOffsets) {
-        pDynamicOffsets = new uint32_t[in_struct->dynamicOffsetCount];
-        memcpy((void*)pDynamicOffsets, (void*)in_struct->pDynamicOffsets, sizeof(uint32_t) * in_struct->dynamicOffsetCount);
-    }
-}
-
-safe_VkBindDescriptorSetsInfoKHR::safe_VkBindDescriptorSetsInfoKHR()
-    : sType(VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR),
-      pNext(nullptr),
-      stageFlags(),
-      layout(),
-      firstSet(),
-      descriptorSetCount(),
-      pDescriptorSets(nullptr),
-      dynamicOffsetCount(),
-      pDynamicOffsets(nullptr) {}
-
-safe_VkBindDescriptorSetsInfoKHR::safe_VkBindDescriptorSetsInfoKHR(const safe_VkBindDescriptorSetsInfoKHR& copy_src) {
-    sType = copy_src.sType;
-    stageFlags = copy_src.stageFlags;
-    layout = copy_src.layout;
-    firstSet = copy_src.firstSet;
-    descriptorSetCount = copy_src.descriptorSetCount;
-    pDescriptorSets = nullptr;
-    dynamicOffsetCount = copy_src.dynamicOffsetCount;
-    pDynamicOffsets = nullptr;
-    pNext = SafePnextCopy(copy_src.pNext);
-    if (descriptorSetCount && copy_src.pDescriptorSets) {
-        pDescriptorSets = new VkDescriptorSet[descriptorSetCount];
-        for (uint32_t i = 0; i < descriptorSetCount; ++i) {
-            pDescriptorSets[i] = copy_src.pDescriptorSets[i];
-        }
-    }
-
-    if (copy_src.pDynamicOffsets) {
-        pDynamicOffsets = new uint32_t[copy_src.dynamicOffsetCount];
-        memcpy((void*)pDynamicOffsets, (void*)copy_src.pDynamicOffsets, sizeof(uint32_t) * copy_src.dynamicOffsetCount);
-    }
-}
-
-safe_VkBindDescriptorSetsInfoKHR& safe_VkBindDescriptorSetsInfoKHR::operator=(const safe_VkBindDescriptorSetsInfoKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    if (pDescriptorSets) delete[] pDescriptorSets;
-    if (pDynamicOffsets) delete[] pDynamicOffsets;
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    stageFlags = copy_src.stageFlags;
-    layout = copy_src.layout;
-    firstSet = copy_src.firstSet;
-    descriptorSetCount = copy_src.descriptorSetCount;
-    pDescriptorSets = nullptr;
-    dynamicOffsetCount = copy_src.dynamicOffsetCount;
-    pDynamicOffsets = nullptr;
-    pNext = SafePnextCopy(copy_src.pNext);
-    if (descriptorSetCount && copy_src.pDescriptorSets) {
-        pDescriptorSets = new VkDescriptorSet[descriptorSetCount];
-        for (uint32_t i = 0; i < descriptorSetCount; ++i) {
-            pDescriptorSets[i] = copy_src.pDescriptorSets[i];
-        }
-    }
-
-    if (copy_src.pDynamicOffsets) {
-        pDynamicOffsets = new uint32_t[copy_src.dynamicOffsetCount];
-        memcpy((void*)pDynamicOffsets, (void*)copy_src.pDynamicOffsets, sizeof(uint32_t) * copy_src.dynamicOffsetCount);
-    }
-
-    return *this;
-}
-
-safe_VkBindDescriptorSetsInfoKHR::~safe_VkBindDescriptorSetsInfoKHR() {
-    if (pDescriptorSets) delete[] pDescriptorSets;
-    if (pDynamicOffsets) delete[] pDynamicOffsets;
-    FreePnextChain(pNext);
-}
-
-void safe_VkBindDescriptorSetsInfoKHR::initialize(const VkBindDescriptorSetsInfoKHR* in_struct,
-                                                  [[maybe_unused]] PNextCopyState* copy_state) {
-    if (pDescriptorSets) delete[] pDescriptorSets;
-    if (pDynamicOffsets) delete[] pDynamicOffsets;
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    stageFlags = in_struct->stageFlags;
-    layout = in_struct->layout;
-    firstSet = in_struct->firstSet;
-    descriptorSetCount = in_struct->descriptorSetCount;
-    pDescriptorSets = nullptr;
-    dynamicOffsetCount = in_struct->dynamicOffsetCount;
-    pDynamicOffsets = nullptr;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    if (descriptorSetCount && in_struct->pDescriptorSets) {
-        pDescriptorSets = new VkDescriptorSet[descriptorSetCount];
-        for (uint32_t i = 0; i < descriptorSetCount; ++i) {
-            pDescriptorSets[i] = in_struct->pDescriptorSets[i];
-        }
-    }
-
-    if (in_struct->pDynamicOffsets) {
-        pDynamicOffsets = new uint32_t[in_struct->dynamicOffsetCount];
-        memcpy((void*)pDynamicOffsets, (void*)in_struct->pDynamicOffsets, sizeof(uint32_t) * in_struct->dynamicOffsetCount);
-    }
-}
-
-void safe_VkBindDescriptorSetsInfoKHR::initialize(const safe_VkBindDescriptorSetsInfoKHR* copy_src,
-                                                  [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    stageFlags = copy_src->stageFlags;
-    layout = copy_src->layout;
-    firstSet = copy_src->firstSet;
-    descriptorSetCount = copy_src->descriptorSetCount;
-    pDescriptorSets = nullptr;
-    dynamicOffsetCount = copy_src->dynamicOffsetCount;
-    pDynamicOffsets = nullptr;
-    pNext = SafePnextCopy(copy_src->pNext);
-    if (descriptorSetCount && copy_src->pDescriptorSets) {
-        pDescriptorSets = new VkDescriptorSet[descriptorSetCount];
-        for (uint32_t i = 0; i < descriptorSetCount; ++i) {
-            pDescriptorSets[i] = copy_src->pDescriptorSets[i];
-        }
-    }
-
-    if (copy_src->pDynamicOffsets) {
-        pDynamicOffsets = new uint32_t[copy_src->dynamicOffsetCount];
-        memcpy((void*)pDynamicOffsets, (void*)copy_src->pDynamicOffsets, sizeof(uint32_t) * copy_src->dynamicOffsetCount);
-    }
-}
-
-safe_VkPushConstantsInfoKHR::safe_VkPushConstantsInfoKHR(const VkPushConstantsInfoKHR* in_struct,
-                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType),
-      layout(in_struct->layout),
-      stageFlags(in_struct->stageFlags),
-      offset(in_struct->offset),
-      size(in_struct->size),
-      pValues(in_struct->pValues) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkPushConstantsInfoKHR::safe_VkPushConstantsInfoKHR()
-    : sType(VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR),
-      pNext(nullptr),
-      layout(),
-      stageFlags(),
-      offset(),
-      size(),
-      pValues(nullptr) {}
-
-safe_VkPushConstantsInfoKHR::safe_VkPushConstantsInfoKHR(const safe_VkPushConstantsInfoKHR& copy_src) {
-    sType = copy_src.sType;
-    layout = copy_src.layout;
-    stageFlags = copy_src.stageFlags;
-    offset = copy_src.offset;
-    size = copy_src.size;
-    pValues = copy_src.pValues;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPushConstantsInfoKHR& safe_VkPushConstantsInfoKHR::operator=(const safe_VkPushConstantsInfoKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    layout = copy_src.layout;
-    stageFlags = copy_src.stageFlags;
-    offset = copy_src.offset;
-    size = copy_src.size;
-    pValues = copy_src.pValues;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkPushConstantsInfoKHR::~safe_VkPushConstantsInfoKHR() { FreePnextChain(pNext); }
-
-void safe_VkPushConstantsInfoKHR::initialize(const VkPushConstantsInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    layout = in_struct->layout;
-    stageFlags = in_struct->stageFlags;
-    offset = in_struct->offset;
-    size = in_struct->size;
-    pValues = in_struct->pValues;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPushConstantsInfoKHR::initialize(const safe_VkPushConstantsInfoKHR* copy_src,
-                                             [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    layout = copy_src->layout;
-    stageFlags = copy_src->stageFlags;
-    offset = copy_src->offset;
-    size = copy_src->size;
-    pValues = copy_src->pValues;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkPushDescriptorSetInfoKHR::safe_VkPushDescriptorSetInfoKHR(const VkPushDescriptorSetInfoKHR* in_struct,
-                                                                 [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType),
-      stageFlags(in_struct->stageFlags),
-      layout(in_struct->layout),
-      set(in_struct->set),
-      descriptorWriteCount(in_struct->descriptorWriteCount),
-      pDescriptorWrites(nullptr) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-    if (descriptorWriteCount && in_struct->pDescriptorWrites) {
-        pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount];
-        for (uint32_t i = 0; i < descriptorWriteCount; ++i) {
-            pDescriptorWrites[i].initialize(&in_struct->pDescriptorWrites[i]);
-        }
-    }
-}
-
-safe_VkPushDescriptorSetInfoKHR::safe_VkPushDescriptorSetInfoKHR()
-    : sType(VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR),
-      pNext(nullptr),
-      stageFlags(),
-      layout(),
-      set(),
-      descriptorWriteCount(),
-      pDescriptorWrites(nullptr) {}
-
-safe_VkPushDescriptorSetInfoKHR::safe_VkPushDescriptorSetInfoKHR(const safe_VkPushDescriptorSetInfoKHR& copy_src) {
-    sType = copy_src.sType;
-    stageFlags = copy_src.stageFlags;
-    layout = copy_src.layout;
-    set = copy_src.set;
-    descriptorWriteCount = copy_src.descriptorWriteCount;
-    pDescriptorWrites = nullptr;
-    pNext = SafePnextCopy(copy_src.pNext);
-    if (descriptorWriteCount && copy_src.pDescriptorWrites) {
-        pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount];
-        for (uint32_t i = 0; i < descriptorWriteCount; ++i) {
-            pDescriptorWrites[i].initialize(&copy_src.pDescriptorWrites[i]);
-        }
-    }
-}
-
-safe_VkPushDescriptorSetInfoKHR& safe_VkPushDescriptorSetInfoKHR::operator=(const safe_VkPushDescriptorSetInfoKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    if (pDescriptorWrites) delete[] pDescriptorWrites;
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    stageFlags = copy_src.stageFlags;
-    layout = copy_src.layout;
-    set = copy_src.set;
-    descriptorWriteCount = copy_src.descriptorWriteCount;
-    pDescriptorWrites = nullptr;
-    pNext = SafePnextCopy(copy_src.pNext);
-    if (descriptorWriteCount && copy_src.pDescriptorWrites) {
-        pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount];
-        for (uint32_t i = 0; i < descriptorWriteCount; ++i) {
-            pDescriptorWrites[i].initialize(&copy_src.pDescriptorWrites[i]);
-        }
-    }
-
-    return *this;
-}
-
-safe_VkPushDescriptorSetInfoKHR::~safe_VkPushDescriptorSetInfoKHR() {
-    if (pDescriptorWrites) delete[] pDescriptorWrites;
-    FreePnextChain(pNext);
-}
-
-void safe_VkPushDescriptorSetInfoKHR::initialize(const VkPushDescriptorSetInfoKHR* in_struct,
-                                                 [[maybe_unused]] PNextCopyState* copy_state) {
-    if (pDescriptorWrites) delete[] pDescriptorWrites;
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    stageFlags = in_struct->stageFlags;
-    layout = in_struct->layout;
-    set = in_struct->set;
-    descriptorWriteCount = in_struct->descriptorWriteCount;
-    pDescriptorWrites = nullptr;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    if (descriptorWriteCount && in_struct->pDescriptorWrites) {
-        pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount];
-        for (uint32_t i = 0; i < descriptorWriteCount; ++i) {
-            pDescriptorWrites[i].initialize(&in_struct->pDescriptorWrites[i]);
-        }
-    }
-}
-
-void safe_VkPushDescriptorSetInfoKHR::initialize(const safe_VkPushDescriptorSetInfoKHR* copy_src,
-                                                 [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    stageFlags = copy_src->stageFlags;
-    layout = copy_src->layout;
-    set = copy_src->set;
-    descriptorWriteCount = copy_src->descriptorWriteCount;
-    pDescriptorWrites = nullptr;
-    pNext = SafePnextCopy(copy_src->pNext);
-    if (descriptorWriteCount && copy_src->pDescriptorWrites) {
-        pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount];
-        for (uint32_t i = 0; i < descriptorWriteCount; ++i) {
-            pDescriptorWrites[i].initialize(&copy_src->pDescriptorWrites[i]);
-        }
-    }
-}
-
-safe_VkPushDescriptorSetWithTemplateInfoKHR::safe_VkPushDescriptorSetWithTemplateInfoKHR(
-    const VkPushDescriptorSetWithTemplateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType),
-      descriptorUpdateTemplate(in_struct->descriptorUpdateTemplate),
-      layout(in_struct->layout),
-      set(in_struct->set),
-      pData(nullptr) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkPushDescriptorSetWithTemplateInfoKHR::safe_VkPushDescriptorSetWithTemplateInfoKHR()
-    : sType(VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR),
-      pNext(nullptr),
-      descriptorUpdateTemplate(),
-      layout(),
-      set(),
-      pData(nullptr) {}
-
-safe_VkPushDescriptorSetWithTemplateInfoKHR::safe_VkPushDescriptorSetWithTemplateInfoKHR(
-    const safe_VkPushDescriptorSetWithTemplateInfoKHR& copy_src) {
-    sType = copy_src.sType;
-    descriptorUpdateTemplate = copy_src.descriptorUpdateTemplate;
-    layout = copy_src.layout;
-    set = copy_src.set;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPushDescriptorSetWithTemplateInfoKHR& safe_VkPushDescriptorSetWithTemplateInfoKHR::operator=(
-    const safe_VkPushDescriptorSetWithTemplateInfoKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    if (pData != nullptr) {
-        auto temp = reinterpret_cast<const std::byte*>(pData);
-        delete[] temp;
-    }
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    descriptorUpdateTemplate = copy_src.descriptorUpdateTemplate;
-    layout = copy_src.layout;
-    set = copy_src.set;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkPushDescriptorSetWithTemplateInfoKHR::~safe_VkPushDescriptorSetWithTemplateInfoKHR() {
-    if (pData != nullptr) {
-        auto temp = reinterpret_cast<const std::byte*>(pData);
-        delete[] temp;
-    }
-    FreePnextChain(pNext);
-}
-
-void safe_VkPushDescriptorSetWithTemplateInfoKHR::initialize(const VkPushDescriptorSetWithTemplateInfoKHR* in_struct,
-                                                             [[maybe_unused]] PNextCopyState* copy_state) {
-    if (pData != nullptr) {
-        auto temp = reinterpret_cast<const std::byte*>(pData);
-        delete[] temp;
-    }
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    descriptorUpdateTemplate = in_struct->descriptorUpdateTemplate;
-    layout = in_struct->layout;
-    set = in_struct->set;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPushDescriptorSetWithTemplateInfoKHR::initialize(const safe_VkPushDescriptorSetWithTemplateInfoKHR* copy_src,
-                                                             [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    descriptorUpdateTemplate = copy_src->descriptorUpdateTemplate;
-    layout = copy_src->layout;
-    set = copy_src->set;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
 safe_VkVideoEncodeQuantizationMapCapabilitiesKHR::safe_VkVideoEncodeQuantizationMapCapabilitiesKHR(
     const VkVideoEncodeQuantizationMapCapabilitiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType), maxQuantizationMapExtent(in_struct->maxQuantizationMapExtent) {
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index 1f1f6fe..660a5f0 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -387,6 +387,108 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
                 safe_pNext = new safe_VkPhysicalDeviceMaintenance4Properties(reinterpret_cast<const VkPhysicalDeviceMaintenance4Properties *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceVulkan14Features(reinterpret_cast<const VkPhysicalDeviceVulkan14Features *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES:
+                safe_pNext = new safe_VkPhysicalDeviceVulkan14Properties(reinterpret_cast<const VkPhysicalDeviceVulkan14Properties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO:
+                safe_pNext = new safe_VkDeviceQueueGlobalPriorityCreateInfo(reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceGlobalPriorityQueryFeatures(reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES:
+                safe_pNext = new safe_VkQueueFamilyGlobalPriorityProperties(reinterpret_cast<const VkQueueFamilyGlobalPriorityProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceShaderSubgroupRotateFeatures(reinterpret_cast<const VkPhysicalDeviceShaderSubgroupRotateFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceShaderFloatControls2Features(reinterpret_cast<const VkPhysicalDeviceShaderFloatControls2Features *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceShaderExpectAssumeFeatures(reinterpret_cast<const VkPhysicalDeviceShaderExpectAssumeFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceLineRasterizationFeatures(reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES:
+                safe_pNext = new safe_VkPhysicalDeviceLineRasterizationProperties(reinterpret_cast<const VkPhysicalDeviceLineRasterizationProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO:
+                safe_pNext = new safe_VkPipelineRasterizationLineStateCreateInfo(reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES:
+                safe_pNext = new safe_VkPhysicalDeviceVertexAttributeDivisorProperties(reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO:
+                safe_pNext = new safe_VkPipelineVertexInputDivisorStateCreateInfo(reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceVertexAttributeDivisorFeatures(reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceIndexTypeUint8Features(reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8Features *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceMaintenance5Features(reinterpret_cast<const VkPhysicalDeviceMaintenance5Features *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES:
+                safe_pNext = new safe_VkPhysicalDeviceMaintenance5Properties(reinterpret_cast<const VkPhysicalDeviceMaintenance5Properties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO:
+                safe_pNext = new safe_VkPipelineCreateFlags2CreateInfo(reinterpret_cast<const VkPipelineCreateFlags2CreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO:
+                safe_pNext = new safe_VkBufferUsageFlags2CreateInfo(reinterpret_cast<const VkBufferUsageFlags2CreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES:
+                safe_pNext = new safe_VkPhysicalDevicePushDescriptorProperties(reinterpret_cast<const VkPhysicalDevicePushDescriptorProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures(reinterpret_cast<const VkPhysicalDeviceDynamicRenderingLocalReadFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO:
+                safe_pNext = new safe_VkRenderingAttachmentLocationInfo(reinterpret_cast<const VkRenderingAttachmentLocationInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO:
+                safe_pNext = new safe_VkRenderingInputAttachmentIndexInfo(reinterpret_cast<const VkRenderingInputAttachmentIndexInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceMaintenance6Features(reinterpret_cast<const VkPhysicalDeviceMaintenance6Features *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES:
+                safe_pNext = new safe_VkPhysicalDeviceMaintenance6Properties(reinterpret_cast<const VkPhysicalDeviceMaintenance6Properties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS:
+                safe_pNext = new safe_VkBindMemoryStatus(reinterpret_cast<const VkBindMemoryStatus *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES:
+                safe_pNext = new safe_VkPhysicalDevicePipelineProtectedAccessFeatures(reinterpret_cast<const VkPhysicalDevicePipelineProtectedAccessFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES:
+                safe_pNext = new safe_VkPhysicalDevicePipelineRobustnessFeatures(reinterpret_cast<const VkPhysicalDevicePipelineRobustnessFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES:
+                safe_pNext = new safe_VkPhysicalDevicePipelineRobustnessProperties(reinterpret_cast<const VkPhysicalDevicePipelineRobustnessProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO:
+                safe_pNext = new safe_VkPipelineRobustnessCreateInfo(reinterpret_cast<const VkPipelineRobustnessCreateInfo *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES:
+                safe_pNext = new safe_VkPhysicalDeviceHostImageCopyFeatures(reinterpret_cast<const VkPhysicalDeviceHostImageCopyFeatures *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES:
+                safe_pNext = new safe_VkPhysicalDeviceHostImageCopyProperties(reinterpret_cast<const VkPhysicalDeviceHostImageCopyProperties *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE:
+                safe_pNext = new safe_VkSubresourceHostMemcpySize(reinterpret_cast<const VkSubresourceHostMemcpySize *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY:
+                safe_pNext = new safe_VkHostImageCopyDevicePerformanceQuery(reinterpret_cast<const VkHostImageCopyDevicePerformanceQuery *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
                 safe_pNext = new safe_VkImageSwapchainCreateInfoKHR(reinterpret_cast<const VkImageSwapchainCreateInfoKHR *>(pNext), copy_state, false);
                 break;
@@ -538,9 +640,6 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
                 safe_pNext = new safe_VkD3D12FenceSubmitInfoKHR(reinterpret_cast<const VkD3D12FenceSubmitInfoKHR *>(pNext), copy_state, false);
                 break;
 #endif  // VK_USE_PLATFORM_WIN32_KHR
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
-                safe_pNext = new safe_VkPhysicalDevicePushDescriptorPropertiesKHR(reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR *>(pNext), copy_state, false);
-                break;
             case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
                 safe_pNext = new safe_VkPresentRegionsKHR(reinterpret_cast<const VkPresentRegionsKHR *>(pNext), copy_state, false);
                 break;
@@ -593,15 +692,6 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR:
                 safe_pNext = new safe_VkVideoDecodeH265DpbSlotInfoKHR(reinterpret_cast<const VkVideoDecodeH265DpbSlotInfoKHR *>(pNext), copy_state, false);
                 break;
-            case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR:
-                safe_pNext = new safe_VkDeviceQueueGlobalPriorityCreateInfoKHR(reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoKHR *>(pNext), copy_state, false);
-                break;
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
-                safe_pNext = new safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *>(pNext), copy_state, false);
-                break;
-            case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR:
-                safe_pNext = new safe_VkQueueFamilyGlobalPriorityPropertiesKHR(reinterpret_cast<const VkQueueFamilyGlobalPriorityPropertiesKHR *>(pNext), copy_state, false);
-                break;
             case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
                 safe_pNext = new safe_VkFragmentShadingRateAttachmentInfoKHR(reinterpret_cast<const VkFragmentShadingRateAttachmentInfoKHR *>(pNext), copy_state, false);
                 break;
@@ -617,15 +707,6 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
                 safe_pNext = new safe_VkRenderingFragmentShadingRateAttachmentInfoKHR(reinterpret_cast<const VkRenderingFragmentShadingRateAttachmentInfoKHR *>(pNext), copy_state, false);
                 break;
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR:
-                safe_pNext = new safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR *>(pNext), copy_state, false);
-                break;
-            case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR:
-                safe_pNext = new safe_VkRenderingAttachmentLocationInfoKHR(reinterpret_cast<const VkRenderingAttachmentLocationInfoKHR *>(pNext), copy_state, false);
-                break;
-            case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR:
-                safe_pNext = new safe_VkRenderingInputAttachmentIndexInfoKHR(reinterpret_cast<const VkRenderingInputAttachmentIndexInfoKHR *>(pNext), copy_state, false);
-                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR:
                 safe_pNext = new safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceShaderQuadControlFeaturesKHR *>(pNext), copy_state, false);
                 break;
@@ -677,24 +758,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
                 safe_pNext = new safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *>(pNext), copy_state, false);
                 break;
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR:
-                safe_pNext = new safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR *>(pNext), copy_state, false);
-                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR:
                 safe_pNext = new safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *>(pNext), copy_state, false);
                 break;
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR:
-                safe_pNext = new safe_VkPhysicalDeviceMaintenance5FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceMaintenance5FeaturesKHR *>(pNext), copy_state, false);
-                break;
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR:
-                safe_pNext = new safe_VkPhysicalDeviceMaintenance5PropertiesKHR(reinterpret_cast<const VkPhysicalDeviceMaintenance5PropertiesKHR *>(pNext), copy_state, false);
-                break;
-            case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR:
-                safe_pNext = new safe_VkPipelineCreateFlags2CreateInfoKHR(reinterpret_cast<const VkPipelineCreateFlags2CreateInfoKHR *>(pNext), copy_state, false);
-                break;
-            case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR:
-                safe_pNext = new safe_VkBufferUsageFlags2CreateInfoKHR(reinterpret_cast<const VkBufferUsageFlags2CreateInfoKHR *>(pNext), copy_state, false);
-                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
                 safe_pNext = new safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *>(pNext), copy_state, false);
                 break;
@@ -776,42 +842,6 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR:
                 safe_pNext = new safe_VkVideoInlineQueryInfoKHR(reinterpret_cast<const VkVideoInlineQueryInfoKHR *>(pNext), copy_state, false);
                 break;
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR:
-                safe_pNext = new safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR(reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR *>(pNext), copy_state, false);
-                break;
-            case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR:
-                safe_pNext = new safe_VkPipelineVertexInputDivisorStateCreateInfoKHR(reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoKHR *>(pNext), copy_state, false);
-                break;
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR:
-                safe_pNext = new safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR *>(pNext), copy_state, false);
-                break;
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR:
-                safe_pNext = new safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceShaderFloatControls2FeaturesKHR *>(pNext), copy_state, false);
-                break;
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR:
-                safe_pNext = new safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8FeaturesKHR *>(pNext), copy_state, false);
-                break;
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR:
-                safe_pNext = new safe_VkPhysicalDeviceLineRasterizationFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesKHR *>(pNext), copy_state, false);
-                break;
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR:
-                safe_pNext = new safe_VkPhysicalDeviceLineRasterizationPropertiesKHR(reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesKHR *>(pNext), copy_state, false);
-                break;
-            case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR:
-                safe_pNext = new safe_VkPipelineRasterizationLineStateCreateInfoKHR(reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoKHR *>(pNext), copy_state, false);
-                break;
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR:
-                safe_pNext = new safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceShaderExpectAssumeFeaturesKHR *>(pNext), copy_state, false);
-                break;
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR:
-                safe_pNext = new safe_VkPhysicalDeviceMaintenance6FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceMaintenance6FeaturesKHR *>(pNext), copy_state, false);
-                break;
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR:
-                safe_pNext = new safe_VkPhysicalDeviceMaintenance6PropertiesKHR(reinterpret_cast<const VkPhysicalDeviceMaintenance6PropertiesKHR *>(pNext), copy_state, false);
-                break;
-            case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR:
-                safe_pNext = new safe_VkBindMemoryStatusKHR(reinterpret_cast<const VkBindMemoryStatusKHR *>(pNext), copy_state, false);
-                break;
             case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR:
                 safe_pNext = new safe_VkVideoEncodeQuantizationMapCapabilitiesKHR(reinterpret_cast<const VkVideoEncodeQuantizationMapCapabilitiesKHR *>(pNext), copy_state, false);
                 break;
@@ -916,15 +946,6 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
                 safe_pNext = new safe_VkPhysicalDeviceASTCDecodeFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT *>(pNext), copy_state, false);
                 break;
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT:
-                safe_pNext = new safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT(reinterpret_cast<const VkPhysicalDevicePipelineRobustnessFeaturesEXT *>(pNext), copy_state, false);
-                break;
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT:
-                safe_pNext = new safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT(reinterpret_cast<const VkPhysicalDevicePipelineRobustnessPropertiesEXT *>(pNext), copy_state, false);
-                break;
-            case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
-                safe_pNext = new safe_VkPipelineRobustnessCreateInfoEXT(reinterpret_cast<const VkPipelineRobustnessCreateInfoEXT *>(pNext), copy_state, false);
-                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
                 safe_pNext = new safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT *>(pNext), copy_state, false);
                 break;
@@ -1236,18 +1257,6 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
                 safe_pNext = new safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *>(pNext), copy_state, false);
                 break;
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT:
-                safe_pNext = new safe_VkPhysicalDeviceHostImageCopyFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceHostImageCopyFeaturesEXT *>(pNext), copy_state, false);
-                break;
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT:
-                safe_pNext = new safe_VkPhysicalDeviceHostImageCopyPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceHostImageCopyPropertiesEXT *>(pNext), copy_state, false);
-                break;
-            case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT:
-                safe_pNext = new safe_VkSubresourceHostMemcpySizeEXT(reinterpret_cast<const VkSubresourceHostMemcpySizeEXT *>(pNext), copy_state, false);
-                break;
-            case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT:
-                safe_pNext = new safe_VkHostImageCopyDevicePerformanceQueryEXT(reinterpret_cast<const VkHostImageCopyDevicePerformanceQueryEXT *>(pNext), copy_state, false);
-                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT:
                 safe_pNext = new safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *>(pNext), copy_state, false);
                 break;
@@ -1758,9 +1767,6 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
                 safe_pNext = new safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceLegacyDitheringFeaturesEXT *>(pNext), copy_state, false);
                 break;
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT:
-                safe_pNext = new safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(reinterpret_cast<const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *>(pNext), copy_state, false);
-                break;
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID:
                 safe_pNext = new safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID(reinterpret_cast<const VkPhysicalDeviceExternalFormatResolveFeaturesANDROID *>(pNext), copy_state, false);
@@ -2360,6 +2366,108 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
             delete reinterpret_cast<safe_VkPhysicalDeviceMaintenance4Properties *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES:
+            delete reinterpret_cast<safe_VkPhysicalDeviceVulkan14Features *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES:
+            delete reinterpret_cast<safe_VkPhysicalDeviceVulkan14Properties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO:
+            delete reinterpret_cast<safe_VkDeviceQueueGlobalPriorityCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES:
+            delete reinterpret_cast<safe_VkPhysicalDeviceGlobalPriorityQueryFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES:
+            delete reinterpret_cast<safe_VkQueueFamilyGlobalPriorityProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES:
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderSubgroupRotateFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES:
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderFloatControls2Features *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES:
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderExpectAssumeFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES:
+            delete reinterpret_cast<safe_VkPhysicalDeviceLineRasterizationFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES:
+            delete reinterpret_cast<safe_VkPhysicalDeviceLineRasterizationProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO:
+            delete reinterpret_cast<safe_VkPipelineRasterizationLineStateCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES:
+            delete reinterpret_cast<safe_VkPhysicalDeviceVertexAttributeDivisorProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO:
+            delete reinterpret_cast<safe_VkPipelineVertexInputDivisorStateCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES:
+            delete reinterpret_cast<safe_VkPhysicalDeviceVertexAttributeDivisorFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES:
+            delete reinterpret_cast<safe_VkPhysicalDeviceIndexTypeUint8Features *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES:
+            delete reinterpret_cast<safe_VkPhysicalDeviceMaintenance5Features *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES:
+            delete reinterpret_cast<safe_VkPhysicalDeviceMaintenance5Properties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO:
+            delete reinterpret_cast<safe_VkPipelineCreateFlags2CreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO:
+            delete reinterpret_cast<safe_VkBufferUsageFlags2CreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES:
+            delete reinterpret_cast<safe_VkPhysicalDevicePushDescriptorProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES:
+            delete reinterpret_cast<safe_VkPhysicalDeviceDynamicRenderingLocalReadFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO:
+            delete reinterpret_cast<safe_VkRenderingAttachmentLocationInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO:
+            delete reinterpret_cast<safe_VkRenderingInputAttachmentIndexInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES:
+            delete reinterpret_cast<safe_VkPhysicalDeviceMaintenance6Features *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES:
+            delete reinterpret_cast<safe_VkPhysicalDeviceMaintenance6Properties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS:
+            delete reinterpret_cast<safe_VkBindMemoryStatus *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES:
+            delete reinterpret_cast<safe_VkPhysicalDevicePipelineProtectedAccessFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES:
+            delete reinterpret_cast<safe_VkPhysicalDevicePipelineRobustnessFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES:
+            delete reinterpret_cast<safe_VkPhysicalDevicePipelineRobustnessProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO:
+            delete reinterpret_cast<safe_VkPipelineRobustnessCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES:
+            delete reinterpret_cast<safe_VkPhysicalDeviceHostImageCopyFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES:
+            delete reinterpret_cast<safe_VkPhysicalDeviceHostImageCopyProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE:
+            delete reinterpret_cast<safe_VkSubresourceHostMemcpySize *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY:
+            delete reinterpret_cast<safe_VkHostImageCopyDevicePerformanceQuery *>(header);
+            break;
         case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
             delete reinterpret_cast<safe_VkImageSwapchainCreateInfoKHR *>(header);
             break;
@@ -2511,9 +2619,6 @@ void FreePnextChain(const void *pNext) {
             delete reinterpret_cast<safe_VkD3D12FenceSubmitInfoKHR *>(header);
             break;
 #endif  // VK_USE_PLATFORM_WIN32_KHR
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
-            delete reinterpret_cast<safe_VkPhysicalDevicePushDescriptorPropertiesKHR *>(header);
-            break;
         case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
             delete reinterpret_cast<safe_VkPresentRegionsKHR *>(header);
             break;
@@ -2566,15 +2671,6 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR:
             delete reinterpret_cast<safe_VkVideoDecodeH265DpbSlotInfoKHR *>(header);
             break;
-        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR:
-            delete reinterpret_cast<safe_VkDeviceQueueGlobalPriorityCreateInfoKHR *>(header);
-            break;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR:
-            delete reinterpret_cast<safe_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR *>(header);
-            break;
-        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR:
-            delete reinterpret_cast<safe_VkQueueFamilyGlobalPriorityPropertiesKHR *>(header);
-            break;
         case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
             delete reinterpret_cast<safe_VkFragmentShadingRateAttachmentInfoKHR *>(header);
             break;
@@ -2590,15 +2686,6 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
             delete reinterpret_cast<safe_VkRenderingFragmentShadingRateAttachmentInfoKHR *>(header);
             break;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR:
-            delete reinterpret_cast<safe_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR *>(header);
-            break;
-        case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR:
-            delete reinterpret_cast<safe_VkRenderingAttachmentLocationInfoKHR *>(header);
-            break;
-        case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR:
-            delete reinterpret_cast<safe_VkRenderingInputAttachmentIndexInfoKHR *>(header);
-            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR:
             delete reinterpret_cast<safe_VkPhysicalDeviceShaderQuadControlFeaturesKHR *>(header);
             break;
@@ -2650,24 +2737,9 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
             delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *>(header);
             break;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR:
-            delete reinterpret_cast<safe_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR *>(header);
-            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR:
             delete reinterpret_cast<safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *>(header);
             break;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR:
-            delete reinterpret_cast<safe_VkPhysicalDeviceMaintenance5FeaturesKHR *>(header);
-            break;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR:
-            delete reinterpret_cast<safe_VkPhysicalDeviceMaintenance5PropertiesKHR *>(header);
-            break;
-        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR:
-            delete reinterpret_cast<safe_VkPipelineCreateFlags2CreateInfoKHR *>(header);
-            break;
-        case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR:
-            delete reinterpret_cast<safe_VkBufferUsageFlags2CreateInfoKHR *>(header);
-            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
             delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *>(header);
             break;
@@ -2749,42 +2821,6 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR:
             delete reinterpret_cast<safe_VkVideoInlineQueryInfoKHR *>(header);
             break;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR:
-            delete reinterpret_cast<safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR *>(header);
-            break;
-        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR:
-            delete reinterpret_cast<safe_VkPipelineVertexInputDivisorStateCreateInfoKHR *>(header);
-            break;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR:
-            delete reinterpret_cast<safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR *>(header);
-            break;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR:
-            delete reinterpret_cast<safe_VkPhysicalDeviceShaderFloatControls2FeaturesKHR *>(header);
-            break;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR:
-            delete reinterpret_cast<safe_VkPhysicalDeviceIndexTypeUint8FeaturesKHR *>(header);
-            break;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR:
-            delete reinterpret_cast<safe_VkPhysicalDeviceLineRasterizationFeaturesKHR *>(header);
-            break;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR:
-            delete reinterpret_cast<safe_VkPhysicalDeviceLineRasterizationPropertiesKHR *>(header);
-            break;
-        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR:
-            delete reinterpret_cast<safe_VkPipelineRasterizationLineStateCreateInfoKHR *>(header);
-            break;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR:
-            delete reinterpret_cast<safe_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR *>(header);
-            break;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR:
-            delete reinterpret_cast<safe_VkPhysicalDeviceMaintenance6FeaturesKHR *>(header);
-            break;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR:
-            delete reinterpret_cast<safe_VkPhysicalDeviceMaintenance6PropertiesKHR *>(header);
-            break;
-        case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR:
-            delete reinterpret_cast<safe_VkBindMemoryStatusKHR *>(header);
-            break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR:
             delete reinterpret_cast<safe_VkVideoEncodeQuantizationMapCapabilitiesKHR *>(header);
             break;
@@ -2889,15 +2925,6 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
             delete reinterpret_cast<safe_VkPhysicalDeviceASTCDecodeFeaturesEXT *>(header);
             break;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT:
-            delete reinterpret_cast<safe_VkPhysicalDevicePipelineRobustnessFeaturesEXT *>(header);
-            break;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT:
-            delete reinterpret_cast<safe_VkPhysicalDevicePipelineRobustnessPropertiesEXT *>(header);
-            break;
-        case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT:
-            delete reinterpret_cast<safe_VkPipelineRobustnessCreateInfoEXT *>(header);
-            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
             delete reinterpret_cast<safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT *>(header);
             break;
@@ -3209,18 +3236,6 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
             delete reinterpret_cast<safe_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *>(header);
             break;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT:
-            delete reinterpret_cast<safe_VkPhysicalDeviceHostImageCopyFeaturesEXT *>(header);
-            break;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT:
-            delete reinterpret_cast<safe_VkPhysicalDeviceHostImageCopyPropertiesEXT *>(header);
-            break;
-        case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT:
-            delete reinterpret_cast<safe_VkSubresourceHostMemcpySizeEXT *>(header);
-            break;
-        case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT:
-            delete reinterpret_cast<safe_VkHostImageCopyDevicePerformanceQueryEXT *>(header);
-            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT:
             delete reinterpret_cast<safe_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *>(header);
             break;
@@ -3731,9 +3746,6 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
             delete reinterpret_cast<safe_VkPhysicalDeviceLegacyDitheringFeaturesEXT *>(header);
             break;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT:
-            delete reinterpret_cast<safe_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT *>(header);
-            break;
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID:
             delete reinterpret_cast<safe_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID *>(header);

From 160e946f5d4b3a657f47b7fc4b0bd3cc8d0d6afd Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 9 Dec 2024 15:35:11 +0000
Subject: [PATCH 067/106] build(deps): Bump jidicula/clang-format-action from
 4.13.0 to 4.14.0

Bumps [jidicula/clang-format-action](https://github.com/jidicula/clang-format-action) from 4.13.0 to 4.14.0.
- [Release notes](https://github.com/jidicula/clang-format-action/releases)
- [Commits](https://github.com/jidicula/clang-format-action/compare/v4.13.0...v4.14.0)

---
updated-dependencies:
- dependency-name: jidicula/clang-format-action
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 .github/workflows/format.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/format.yml b/.github/workflows/format.yml
index 1540cc0..0837768 100644
--- a/.github/workflows/format.yml
+++ b/.github/workflows/format.yml
@@ -28,7 +28,7 @@ jobs:
     steps:
     - uses: actions/checkout@v4
     - name: Run clang-format
-      uses: jidicula/clang-format-action@v4.13.0
+      uses: jidicula/clang-format-action@v4.14.0
       with:
         clang-format-version: '14'
         check-path: ${{ matrix.path }}

From 0ab12c1668642874f77bad0e4f4006cbd2f7eaee Mon Sep 17 00:00:00 2001
From: Christophe <christophe@lunarg.com>
Date: Mon, 16 Dec 2024 14:45:43 +0100
Subject: [PATCH 068/106] layer: Add error code to C++ overrides

---
 include/vulkan/layer/vk_layer_settings.hpp |  48 +++---
 src/layer/vk_layer_settings_helper.cpp     | 172 +++++++++++++++------
 2 files changed, 147 insertions(+), 73 deletions(-)

diff --git a/include/vulkan/layer/vk_layer_settings.hpp b/include/vulkan/layer/vk_layer_settings.hpp
index 89ef270..28c8464 100644
--- a/include/vulkan/layer/vk_layer_settings.hpp
+++ b/include/vulkan/layer/vk_layer_settings.hpp
@@ -13,49 +13,53 @@
 #include <vector>
 #include <string>
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, bool &settingValue);
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, bool &settingValue);
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<bool> &settingValues);
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<bool> &settingValues);
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int32_t &settingValue);
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int32_t &settingValue);
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<int32_t> &settingValues);
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                                  std::vector<int32_t> &settingValues);
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int64_t &settingValue);
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int64_t &settingValue);
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<int64_t> &settingValues);
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                                  std::vector<int64_t> &settingValues);
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint32_t &settingValue);
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint32_t &settingValue);
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<uint32_t> &settingValues);
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                                  std::vector<uint32_t> &settingValues);
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint64_t &settingValue);
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint64_t &settingValue);
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<uint64_t> &settingValues);
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                                  std::vector<uint64_t> &settingValues);
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, float &settingValue);
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, float &settingValue);
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<float> &settingValues);
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<float> &settingValues);
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, double &settingValue);
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, double &settingValue);
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<double> &settingValues);
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<double> &settingValues);
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::string &settingValue);
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::string &settingValue);
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
-                              std::vector<std::string> &settingValues);
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                                  std::vector<std::string> &settingValues);
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, VkuFrameset &settingValue);
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, VkuFrameset &settingValue);
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
-                              std::vector<VkuFrameset> &settingValues);
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                                  std::vector<VkuFrameset> &settingValues);
 
 // Required by vk_safe_struct
 typedef std::pair<uint32_t, uint32_t> VkuCustomSTypeInfo;
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
-                              std::vector<VkuCustomSTypeInfo> &settingValues);
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                                  std::vector<VkuCustomSTypeInfo> &settingValues);
 
 // Return the list of Unknown setting in all VkLayerSettingsCreateInfoEXT
 VkResult vkuGetUnknownSettings(const VkLayerSettingsCreateInfoEXT *pFirstCreateInfo, uint32_t settingsCount, const char **pSettings,
diff --git a/src/layer/vk_layer_settings_helper.cpp b/src/layer/vk_layer_settings_helper.cpp
index 0736679..dd9a6f6 100644
--- a/src/layer/vk_layer_settings_helper.cpp
+++ b/src/layer/vk_layer_settings_helper.cpp
@@ -23,139 +23,201 @@ static std::string Merge(const std::vector<std::string> &strings) {
     return result;
 }
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, bool &settingValue) {
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, bool &settingValue) {
     uint32_t value_count = 1;
     VkBool32 pValues;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, &pValues);
+    VkResult result =
+        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, &pValues);
     settingValue = pValues == VK_TRUE;
+    return result;
 }
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<bool> &settingValues) {
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<bool> &settingValues) {
     uint32_t value_count = 0;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, nullptr);
+    VkResult result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, nullptr);
+    if (result != VK_SUCCESS) {
+        return result;
+    }
+
     if (value_count > 0) {
         std::vector<VkBool32> values(value_count);
-        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]);
+        result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_BOOL32, &value_count, &values[0]);
         for (std::size_t i = 0, n = values.size(); i < n; ++i) {
             settingValues.push_back(values[i] == VK_TRUE);
         }
     }
+    return result;
 }
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int32_t &settingValue) {
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int32_t &settingValue) {
     uint32_t value_count = 1;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT32, &value_count, &settingValue);
+    return vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT32, &value_count, &settingValue);
 }
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<int32_t> &settingValues) {
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                                  std::vector<int32_t> &settingValues) {
     uint32_t value_count = 1;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT32, &value_count, nullptr);
+    VkResult result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT32, &value_count, nullptr);
+    if (result != VK_SUCCESS) {
+        return result;
+    }
+
     if (value_count > 0) {
         settingValues.resize(static_cast<std::size_t>(value_count));
-        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT32, &value_count, &settingValues[0]);
+        result =
+            vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT32, &value_count, &settingValues[0]);
     }
+    return result;
 }
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int64_t &settingValue) {
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, int64_t &settingValue) {
     uint32_t value_count = 1;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT64, &value_count, &settingValue);
+    return vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT64, &value_count, &settingValue);
 }
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<int64_t> &settingValues) {
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                                  std::vector<int64_t> &settingValues) {
     uint32_t value_count = 1;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT64, &value_count, nullptr);
+    VkResult result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT64, &value_count, nullptr);
+    if (result != VK_SUCCESS) {
+        return result;
+    }
+
     if (value_count > 0) {
         settingValues.resize(static_cast<std::size_t>(value_count));
-        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT64, &value_count, &settingValues[0]);
+        result =
+            vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_INT64, &value_count, &settingValues[0]);
     }
+    return result;
 }
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint32_t &settingValue) {
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint32_t &settingValue) {
     uint32_t value_count = 1;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValue);
+    return vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValue);
 }
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<uint32_t> &settingValues) {
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                                  std::vector<uint32_t> &settingValues) {
     uint32_t value_count = 1;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr);
+    VkResult result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr);
+    if (result != VK_SUCCESS) {
+        return result;
+    }
+
     if (value_count > 0) {
         settingValues.resize(static_cast<std::size_t>(value_count));
-        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValues[0]);
+        result =
+            vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValues[0]);
     }
+    return result;
 }
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint64_t &settingValue) {
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, uint64_t &settingValue) {
     uint32_t value_count = 1;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT64, &value_count, &settingValue);
+    return vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT64, &value_count, &settingValue);
 }
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<uint64_t> &settingValues) {
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                                  std::vector<uint64_t> &settingValues) {
     uint32_t value_count = 1;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT64, &value_count, nullptr);
+    VkResult result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT64, &value_count, nullptr);
+    if (result != VK_SUCCESS) {
+        return result;
+    }
+
     if (value_count > 0) {
         settingValues.resize(static_cast<std::size_t>(value_count));
-        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT64, &value_count, &settingValues[0]);
+        result =
+            vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT64, &value_count, &settingValues[0]);
     }
+    return result;
 }
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, float &settingValue) {
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, float &settingValue) {
     uint32_t value_count = 1;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, &settingValue);
+    return vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, &settingValue);
 }
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<float> &settingValues) {
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<float> &settingValues) {
     uint32_t value_count = 1;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, nullptr);
+    VkResult result =
+        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, nullptr);
+    if (result != VK_SUCCESS) {
+        return result;
+    }
+
     if (value_count > 0) {
         settingValues.resize(static_cast<std::size_t>(value_count));
-        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count, &settingValues[0]);
+        result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT32, &value_count,
+                                          &settingValues[0]);
     }
+    return result;
 }
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, double &settingValue) {
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, double &settingValue) {
     uint32_t value_count = 1;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, &settingValue);
+    return vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, &settingValue);
 }
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::vector<double> &settingValues) {
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                                  std::vector<double> &settingValues) {
     uint32_t value_count = 1;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, nullptr);
+    VkResult result =
+        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, nullptr);
+    if (result != VK_SUCCESS) {
+        return result;
+    }
+
     if (value_count > 0) {
         settingValues.resize(static_cast<std::size_t>(value_count));
-        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count, &settingValues[0]);
+        result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_FLOAT64, &value_count,
+                                          &settingValues[0]);
     }
+    return result;
 }
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::string &settingValue) {
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, std::string &settingValue) {
     std::vector<std::string> values;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, values);
+    VkResult result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, values);
     settingValue = Merge(values);
+    return result;
 }
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
-                              std::vector<std::string> &settingValues) {
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                                  std::vector<std::string> &settingValues) {
     uint32_t value_count = 0;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, nullptr);
+    VkResult result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, nullptr);
+    if (result != VK_SUCCESS) {
+        return result;
+    }
+
     if (value_count > 0) {
         std::vector<const char *> values(value_count);
-        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]);
+        result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]);
         settingValues.assign(values.begin(), values.end());
     }
+    return result;
 }
 
-void vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, VkuFrameset &settingValue) {
+VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, VkuFrameset &settingValue) {
     uint32_t value_count = sizeof(VkuFrameset) / sizeof(VkuFrameset::count);
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValue);
+    return vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValue);
 }
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
-                              std::vector<VkuFrameset> &settingValues) {
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                                  std::vector<VkuFrameset> &settingValues) {
     uint32_t value_count = 0;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr);
+    VkResult result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, nullptr);
+    if (result != VK_SUCCESS) {
+        return result;
+    }
+
     if (value_count > 0) {
         settingValues.resize(static_cast<std::size_t>(value_count) / (sizeof(VkuFrameset) / sizeof(VkuFrameset::count)));
-        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValues[0]);
+        result =
+            vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_UINT32, &value_count, &settingValues[0]);
     }
+    return result;
 }
 
 static uint32_t TokenToUint(const std::string &token) {
@@ -188,21 +250,29 @@ static void SetCustomStypeInfo(std::vector<const char *> raw_id_list, std::vecto
     }
 }
 
-void vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
-                              std::vector<VkuCustomSTypeInfo> &settingValues) {
+VkResult vkuGetLayerSettingValues(VkuLayerSettingSet layerSettingSet, const char *pSettingName,
+                                  std::vector<VkuCustomSTypeInfo> &settingValues) {
     uint32_t value_count = 0;
-    vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, nullptr);
+    VkResult result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, nullptr);
+    if (result != VK_SUCCESS) {
+        return result;
+    }
+
     if (value_count > 0) {
         std::vector<const char *> values(value_count);
-        vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]);
+        result = vkuGetLayerSettingValues(layerSettingSet, pSettingName, VKU_LAYER_SETTING_TYPE_STRING, &value_count, &values[0]);
         SetCustomStypeInfo(values, settingValues);
     }
+    return result;
 }
 
 VkResult vkuGetUnknownSettings(const VkLayerSettingsCreateInfoEXT *pFirstCreateInfo, uint32_t settingsCount, const char **pSettings,
                                std::vector<const char *> &unknownSettings) {
     uint32_t unknown_setting_count = 0;
     VkResult result = vkuGetUnknownSettings(pFirstCreateInfo, settingsCount, pSettings, &unknown_setting_count, nullptr);
+    if (result != VK_SUCCESS) {
+        return result;
+    }
 
     if (unknown_setting_count > 0) {
         unknownSettings.resize(unknown_setting_count);

From 645eed28839c76931beb99e3fe05ae879fe8dc41 Mon Sep 17 00:00:00 2001
From: Takuto Ikuta <tikuta@google.com>
Date: Thu, 12 Dec 2024 18:01:31 +0900
Subject: [PATCH 069/106] build: Add missing include headers

---
 include/vulkan/layer/vk_layer_settings.hpp         |  4 +++-
 .../vulkan/utility/vk_concurrent_unordered_map.hpp |  2 ++
 src/layer/vk_layer_settings.cpp                    | 14 ++++++++------
 src/vulkan/vk_safe_struct_core.cpp                 |  1 +
 src/vulkan/vk_safe_struct_khr.cpp                  |  1 +
 src/vulkan/vk_safe_struct_vendor.cpp               |  1 +
 6 files changed, 16 insertions(+), 7 deletions(-)

diff --git a/include/vulkan/layer/vk_layer_settings.hpp b/include/vulkan/layer/vk_layer_settings.hpp
index 28c8464..fbee6da 100644
--- a/include/vulkan/layer/vk_layer_settings.hpp
+++ b/include/vulkan/layer/vk_layer_settings.hpp
@@ -10,8 +10,10 @@
 #pragma once
 
 #include "vk_layer_settings.h"
-#include <vector>
+
 #include <string>
+#include <utility>
+#include <vector>
 
 VkResult vkuGetLayerSettingValue(VkuLayerSettingSet layerSettingSet, const char *pSettingName, bool &settingValue);
 
diff --git a/include/vulkan/utility/vk_concurrent_unordered_map.hpp b/include/vulkan/utility/vk_concurrent_unordered_map.hpp
index 631346d..57b5810 100644
--- a/include/vulkan/utility/vk_concurrent_unordered_map.hpp
+++ b/include/vulkan/utility/vk_concurrent_unordered_map.hpp
@@ -9,6 +9,8 @@
 
 #pragma once
 
+#include <stdint.h>
+
 #include <array>
 #include <functional>
 #include <mutex>
diff --git a/src/layer/vk_layer_settings.cpp b/src/layer/vk_layer_settings.cpp
index 61e3fa6..bc696f6 100644
--- a/src/layer/vk_layer_settings.cpp
+++ b/src/layer/vk_layer_settings.cpp
@@ -7,17 +7,19 @@
 // Author(s):
 // - Christophe Riccio <christophe@lunarg.com>
 #include "vulkan/layer/vk_layer_settings.h"
-#include "layer_settings_util.hpp"
 #include "layer_settings_manager.hpp"
+#include "layer_settings_util.hpp"
 
-#include <memory>
-#include <charconv>
-#include <cstdlib>
+#include <algorithm>
 #include <cassert>
-#include <cstring>
 #include <cctype>
-#include <cstring>
+#include <charconv>
 #include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <cstring>
+#include <memory>
+#include <system_error>
 #include <unordered_map>
 
 // This is used only for unit tests in test_layer_setting_file
diff --git a/src/vulkan/vk_safe_struct_core.cpp b/src/vulkan/vk_safe_struct_core.cpp
index f99de19..191919c 100644
--- a/src/vulkan/vk_safe_struct_core.cpp
+++ b/src/vulkan/vk_safe_struct_core.cpp
@@ -17,6 +17,7 @@
 #include <vulkan/utility/vk_safe_struct.hpp>
 #include <vulkan/utility/vk_struct_helper.hpp>
 
+#include <cstddef>
 #include <cstring>
 
 namespace vku {
diff --git a/src/vulkan/vk_safe_struct_khr.cpp b/src/vulkan/vk_safe_struct_khr.cpp
index bde9965..5afca11 100644
--- a/src/vulkan/vk_safe_struct_khr.cpp
+++ b/src/vulkan/vk_safe_struct_khr.cpp
@@ -17,6 +17,7 @@
 #include <vulkan/utility/vk_safe_struct.hpp>
 #include <vulkan/utility/vk_struct_helper.hpp>
 
+#include <cstddef>
 #include <cstring>
 
 namespace vku {
diff --git a/src/vulkan/vk_safe_struct_vendor.cpp b/src/vulkan/vk_safe_struct_vendor.cpp
index 18a87db..94a1d11 100644
--- a/src/vulkan/vk_safe_struct_vendor.cpp
+++ b/src/vulkan/vk_safe_struct_vendor.cpp
@@ -17,6 +17,7 @@
 #include <vulkan/utility/vk_safe_struct.hpp>
 #include <vulkan/utility/vk_struct_helper.hpp>
 
+#include <cstddef>
 #include <cstring>
 
 namespace vku {

From 2b185cfb534bb1a65d8b798315d8efbadfe4368b Mon Sep 17 00:00:00 2001
From: Takuto Ikuta <atetubou@gmail.com>
Date: Fri, 13 Dec 2024 14:12:05 +0900
Subject: [PATCH 070/106] Update safe_struct_generator.py

---
 scripts/generators/safe_struct_generator.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/scripts/generators/safe_struct_generator.py b/scripts/generators/safe_struct_generator.py
index 282115e..72e2281 100644
--- a/scripts/generators/safe_struct_generator.py
+++ b/scripts/generators/safe_struct_generator.py
@@ -400,6 +400,7 @@ void FreePnextChain(const void *pNext) {
             #include <vulkan/utility/vk_safe_struct.hpp>
             #include <vulkan/utility/vk_struct_helper.hpp>
 
+            #include <cstddef>
             #include <cstring>
 
             namespace vku {

From 7f8738669b15a7a158b2a77aff2033973dcd8751 Mon Sep 17 00:00:00 2001
From: Takuto Ikuta <atetubou@gmail.com>
Date: Fri, 13 Dec 2024 14:26:19 +0900
Subject: [PATCH 071/106] Update vk_safe_struct_ext.cpp

---
 src/vulkan/vk_safe_struct_ext.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/vulkan/vk_safe_struct_ext.cpp b/src/vulkan/vk_safe_struct_ext.cpp
index 08abcf0..0e4ccd1 100644
--- a/src/vulkan/vk_safe_struct_ext.cpp
+++ b/src/vulkan/vk_safe_struct_ext.cpp
@@ -17,6 +17,7 @@
 #include <vulkan/utility/vk_safe_struct.hpp>
 #include <vulkan/utility/vk_struct_helper.hpp>
 
+#include <cstddef>
 #include <cstring>
 
 namespace vku {

From 5a88b6042edb8f03eefc8de73bd73a899989373f Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Fri, 20 Dec 2024 10:21:49 -0800
Subject: [PATCH 072/106] build: Update to header 1.4.304

---
 include/vulkan/vk_enum_string_helper.h | 4 ++--
 scripts/known_good.json                | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index d169a27..cb5e9b9 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -3688,8 +3688,8 @@ static inline const char* string_VkDriverId(VkDriverId input_value) {
             return "VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA";
         case VK_DRIVER_ID_MESA_HONEYKRISP:
             return "VK_DRIVER_ID_MESA_HONEYKRISP";
-        case VK_DRIVER_ID_RESERVED_27:
-            return "VK_DRIVER_ID_RESERVED_27";
+        case VK_DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN:
+            return "VK_DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN";
         default:
             return "Unhandled VkDriverId";
     }
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 5de8cec..c94251b 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.4.303"
+            "commit": "v1.4.304"
         },
         {
             "name": "googletest",

From 2fe3a7791dc9c34a581dc45522ab9b4363b4f321 Mon Sep 17 00:00:00 2001
From: spencer-lunarg <spencer@lunarg.com>
Date: Wed, 15 Jan 2025 12:07:30 -0500
Subject: [PATCH 073/106] format: Add note for Multi-planar

---
 include/vulkan/utility/vk_format_utils.h     |  8 +++++---
 scripts/generators/format_utils_generator.py | 14 ++++++++------
 2 files changed, 13 insertions(+), 9 deletions(-)

diff --git a/include/vulkan/utility/vk_format_utils.h b/include/vulkan/utility/vk_format_utils.h
index 862f8e1..9d4d7b0 100644
--- a/include/vulkan/utility/vk_format_utils.h
+++ b/include/vulkan/utility/vk_format_utils.h
@@ -1,8 +1,8 @@
 // *** THIS FILE IS GENERATED - DO NOT EDIT ***
 // See format_utils_generator.py for modifications
-// Copyright 2023 The Khronos Group Inc.
-// Copyright 2023 Valve Corporation
-// Copyright 2023 LunarG, Inc.
+// Copyright 2023-2025 The Khronos Group Inc.
+// Copyright 2023-2025 Valve Corporation
+// Copyright 2023-2025 LunarG, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
 
@@ -249,6 +249,8 @@ inline bool vkuFormatIsSinglePlane_422(VkFormat format);
 inline uint32_t vkuFormatPlaneCount(VkFormat format);
 
 // Returns whether a VkFormat is multiplane
+// Note - Formats like VK_FORMAT_G8B8G8R8_422_UNORM are NOT multi-planar, they require a
+//        VkSamplerYcbcrConversion and you should use vkuFormatRequiresYcbcrConversion instead
 inline bool vkuFormatIsMultiplane(VkFormat format) { return ((vkuFormatPlaneCount(format)) > 1u); }
 
 // Returns a VkFormat that is compatible with a given plane of a multiplane format
diff --git a/scripts/generators/format_utils_generator.py b/scripts/generators/format_utils_generator.py
index 4329447..ff76406 100644
--- a/scripts/generators/format_utils_generator.py
+++ b/scripts/generators/format_utils_generator.py
@@ -1,8 +1,8 @@
 #!/usr/bin/python3 -i
 #
-# Copyright 2023 The Khronos Group Inc.
-# Copyright 2023 Valve Corporation
-# Copyright 2023 LunarG, Inc.
+# Copyright 2023-2025 The Khronos Group Inc.
+# Copyright 2023-2025 Valve Corporation
+# Copyright 2023-2025 LunarG, Inc.
 #
 # SPDX-License-Identifier: Apache-2.0
 
@@ -71,9 +71,9 @@ class FormatUtilsOutputGenerator(BaseGenerator):
         out = []
         out.append(f'''// *** THIS FILE IS GENERATED - DO NOT EDIT ***
 // See {os.path.basename(__file__)} for modifications
-// Copyright 2023 The Khronos Group Inc.
-// Copyright 2023 Valve Corporation
-// Copyright 2023 LunarG, Inc.
+// Copyright 2023-2025 The Khronos Group Inc.
+// Copyright 2023-2025 Valve Corporation
+// Copyright 2023-2025 LunarG, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
 ''')
@@ -195,6 +195,8 @@ inline bool vkuFormatIsSinglePlane_422(VkFormat format);
 inline uint32_t vkuFormatPlaneCount(VkFormat format);
 
 // Returns whether a VkFormat is multiplane
+// Note - Formats like VK_FORMAT_G8B8G8R8_422_UNORM are NOT multi-planar, they require a
+//        VkSamplerYcbcrConversion and you should use vkuFormatRequiresYcbcrConversion instead
 inline bool vkuFormatIsMultiplane(VkFormat format) { return ((vkuFormatPlaneCount(format)) > 1u); }
 
 // Returns a VkFormat that is compatible with a given plane of a multiplane format

From 7b23ba7a5f86936a8d783baf64a77c38977d6890 Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Fri, 17 Jan 2025 08:44:11 -0800
Subject: [PATCH 074/106] build: Update to header 1.4.305

---
 include/vulkan/utility/vk_safe_struct.hpp   |  97 ++++++++++---
 include/vulkan/utility/vk_struct_helper.hpp |   5 +-
 include/vulkan/vk_enum_string_helper.h      |  36 ++++-
 scripts/known_good.json                     |   2 +-
 src/vulkan/vk_safe_struct_ext.cpp           |  48 -------
 src/vulkan/vk_safe_struct_khr.cpp           | 148 ++++++++++++++++++++
 src/vulkan/vk_safe_struct_utils.cpp         |  30 +++-
 src/vulkan/vk_safe_struct_vendor.cpp        |  51 +++++++
 8 files changed, 339 insertions(+), 78 deletions(-)

diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index 69bc5c4..1beeab1 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -9593,6 +9593,61 @@ struct safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR {
         return reinterpret_cast<VkPhysicalDeviceLayeredApiVulkanPropertiesKHR const*>(this);
     }
 };
+struct safe_VkPhysicalDeviceMaintenance8FeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 maintenance8;
+
+    safe_VkPhysicalDeviceMaintenance8FeaturesKHR(const VkPhysicalDeviceMaintenance8FeaturesKHR* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceMaintenance8FeaturesKHR(const safe_VkPhysicalDeviceMaintenance8FeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceMaintenance8FeaturesKHR& operator=(const safe_VkPhysicalDeviceMaintenance8FeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceMaintenance8FeaturesKHR();
+    ~safe_VkPhysicalDeviceMaintenance8FeaturesKHR();
+    void initialize(const VkPhysicalDeviceMaintenance8FeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMaintenance8FeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMaintenance8FeaturesKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceMaintenance8FeaturesKHR*>(this); }
+    VkPhysicalDeviceMaintenance8FeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMaintenance8FeaturesKHR const*>(this);
+    }
+};
+struct safe_VkMemoryBarrierAccessFlags3KHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkAccessFlags3KHR srcAccessMask3;
+    VkAccessFlags3KHR dstAccessMask3;
+
+    safe_VkMemoryBarrierAccessFlags3KHR(const VkMemoryBarrierAccessFlags3KHR* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkMemoryBarrierAccessFlags3KHR(const safe_VkMemoryBarrierAccessFlags3KHR& copy_src);
+    safe_VkMemoryBarrierAccessFlags3KHR& operator=(const safe_VkMemoryBarrierAccessFlags3KHR& copy_src);
+    safe_VkMemoryBarrierAccessFlags3KHR();
+    ~safe_VkMemoryBarrierAccessFlags3KHR();
+    void initialize(const VkMemoryBarrierAccessFlags3KHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMemoryBarrierAccessFlags3KHR* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryBarrierAccessFlags3KHR* ptr() { return reinterpret_cast<VkMemoryBarrierAccessFlags3KHR*>(this); }
+    VkMemoryBarrierAccessFlags3KHR const* ptr() const { return reinterpret_cast<VkMemoryBarrierAccessFlags3KHR const*>(this); }
+};
+struct safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 depthClampZeroOne;
+
+    safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR(const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR(const safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR& operator=(const safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR();
+    ~safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR();
+    void initialize(const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDepthClampZeroOneFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDepthClampZeroOneFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceDepthClampZeroOneFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDepthClampZeroOneFeaturesKHR const*>(this);
+    }
+};
 struct safe_VkDebugReportCallbackCreateInfoEXT {
     VkStructureType sType;
     const void* pNext{};
@@ -16798,26 +16853,6 @@ struct safe_VkDescriptorSetLayoutHostMappingInfoVALVE {
         return reinterpret_cast<VkDescriptorSetLayoutHostMappingInfoVALVE const*>(this);
     }
 };
-struct safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT {
-    VkStructureType sType;
-    void* pNext{};
-    VkBool32 depthClampZeroOne;
-
-    safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* in_struct,
-                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(const safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT& copy_src);
-    safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT& operator=(const safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT& copy_src);
-    safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT();
-    ~safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT();
-    void initialize(const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
-    VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* ptr() {
-        return reinterpret_cast<VkPhysicalDeviceDepthClampZeroOneFeaturesEXT*>(this);
-    }
-    VkPhysicalDeviceDepthClampZeroOneFeaturesEXT const* ptr() const {
-        return reinterpret_cast<VkPhysicalDeviceDepthClampZeroOneFeaturesEXT const*>(this);
-    }
-};
 struct safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT {
     VkStructureType sType;
     void* pNext{};
@@ -19512,6 +19547,28 @@ struct safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV {
         return reinterpret_cast<VkPhysicalDeviceCooperativeMatrix2PropertiesNV const*>(this);
     }
 };
+struct safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 pipelineOpacityMicromap;
+
+    safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM(const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM* in_struct,
+                                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM(
+        const safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM& copy_src);
+    safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM& operator=(
+        const safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM& copy_src);
+    safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM();
+    ~safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM();
+    void initialize(const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePipelineOpacityMicromapFeaturesARM* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePipelineOpacityMicromapFeaturesARM*>(this);
+    }
+    VkPhysicalDevicePipelineOpacityMicromapFeaturesARM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePipelineOpacityMicromapFeaturesARM const*>(this);
+    }
+};
 struct safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT {
     VkStructureType sType;
     void* pNext{};
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index ca9e0d9..f6b9e10 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -503,6 +503,9 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance7Properti
 template <> inline VkStructureType GetSType<VkPhysicalDeviceLayeredApiPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceLayeredApiPropertiesListKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceLayeredApiVulkanPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance8FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkMemoryBarrierAccessFlags3KHR>() { return VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceDepthClampZeroOneFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkDebugReportCallbackCreateInfoEXT>() { return VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkPipelineRasterizationStateRasterizationOrderAMD>() { return VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD; }
 template <> inline VkStructureType GetSType<VkDebugMarkerObjectNameInfoEXT>() { return VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT; }
@@ -882,7 +885,6 @@ template <> inline VkStructureType GetSType<VkImageViewSlicedCreateInfoEXT>() {
 template <> inline VkStructureType GetSType<VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE; }
 template <> inline VkStructureType GetSType<VkDescriptorSetBindingReferenceVALVE>() { return VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE; }
 template <> inline VkStructureType GetSType<VkDescriptorSetLayoutHostMappingInfoVALVE>() { return VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceDepthClampZeroOneFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceRenderPassStripedFeaturesARM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceRenderPassStripedPropertiesARM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM; }
@@ -1016,6 +1018,7 @@ template <> inline VkStructureType GetSType<VkHdrVividDynamicMetadataHUAWEI>() {
 template <> inline VkStructureType GetSType<VkCooperativeMatrixFlexibleDimensionsPropertiesNV>() { return VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeMatrix2FeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeMatrix2PropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDevicePipelineOpacityMicromapFeaturesARM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryTrianglesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryAabbsDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index cb5e9b9..4e939bc 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -1690,8 +1690,6 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE";
         case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE:
             return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM:
@@ -2044,6 +2042,10 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT";
         case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT:
             return "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR";
+        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR:
+            return "VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA:
@@ -2064,6 +2066,10 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT";
         default:
@@ -6061,6 +6067,8 @@ static inline const char* string_VkPipelineCacheCreateFlagBits(VkPipelineCacheCr
     switch (input_value) {
         case VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT:
             return "VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT";
+        case VK_PIPELINE_CACHE_CREATE_INTERNALLY_SYNCHRONIZED_MERGE_BIT_KHR:
+            return "VK_PIPELINE_CACHE_CREATE_INTERNALLY_SYNCHRONIZED_MERGE_BIT_KHR";
         default:
             return "Unhandled VkPipelineCacheCreateFlagBits";
     }
@@ -6529,6 +6537,8 @@ static inline const char* string_VkDependencyFlagBits(VkDependencyFlagBits input
             return "VK_DEPENDENCY_VIEW_LOCAL_BIT";
         case VK_DEPENDENCY_FEEDBACK_LOOP_BIT_EXT:
             return "VK_DEPENDENCY_FEEDBACK_LOOP_BIT_EXT";
+        case VK_DEPENDENCY_QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES_BIT_KHR:
+            return "VK_DEPENDENCY_QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES_BIT_KHR";
         default:
             return "Unhandled VkDependencyFlagBits";
     }
@@ -7621,6 +7631,7 @@ static inline const char* string_VkPipelineCreateFlagBits2(uint64_t input_value)
     if (input_value == VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT) return "VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT";
     if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV) return "VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV";
     if (input_value == VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT) return "VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT";
+    if (input_value == VK_PIPELINE_CREATE_2_DISALLOW_OPACITY_MICROMAP_BIT_ARM) return "VK_PIPELINE_CREATE_2_DISALLOW_OPACITY_MICROMAP_BIT_ARM";
     if (input_value == VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR) return "VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR";
     if (input_value == VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT) return "VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT";
     return "Unhandled VkPipelineCreateFlagBits2";
@@ -8856,6 +8867,27 @@ static inline std::string string_VkVideoEncodeAV1RateControlFlagsKHR(VkVideoEnco
     return ret;
 }
 #endif // __cplusplus
+static inline const char* string_VkAccessFlagBits3KHR(uint64_t input_value) {
+    if (input_value == VK_ACCESS_3_NONE_KHR) return "VK_ACCESS_3_NONE_KHR";
+    return "Unhandled VkAccessFlagBits3KHR";
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkAccessFlags3KHR(VkAccessFlags3KHR input_value) {
+    std::string ret;
+    int index = 0;
+    while(input_value) {
+        if (input_value & 1) {
+            if( !ret.empty()) ret.append("|");
+            ret.append(string_VkAccessFlagBits3KHR(static_cast<uint64_t>(1ULL << index)));
+        }
+        ++index;
+        input_value >>= 1;
+    }
+    if (ret.empty()) ret.append("VkAccessFlags3KHR(0)");
+    return ret;
+}
+#endif // __cplusplus
 static inline const char* string_VkDebugReportFlagBitsEXT(VkDebugReportFlagBitsEXT input_value) {
     switch (input_value) {
         case VK_DEBUG_REPORT_INFORMATION_BIT_EXT:
diff --git a/scripts/known_good.json b/scripts/known_good.json
index c94251b..25c2e57 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.4.304"
+            "commit": "v1.4.305"
         },
         {
             "name": "googletest",
diff --git a/src/vulkan/vk_safe_struct_ext.cpp b/src/vulkan/vk_safe_struct_ext.cpp
index 0e4ccd1..c971694 100644
--- a/src/vulkan/vk_safe_struct_ext.cpp
+++ b/src/vulkan/vk_safe_struct_ext.cpp
@@ -12339,54 +12339,6 @@ void safe_VkImageViewSlicedCreateInfoEXT::initialize(const safe_VkImageViewSlice
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
-safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT::safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
-    const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), depthClampZeroOne(in_struct->depthClampZeroOne) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT::safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT()
-    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT), pNext(nullptr), depthClampZeroOne() {}
-
-safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT::safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
-    const safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT& copy_src) {
-    sType = copy_src.sType;
-    depthClampZeroOne = copy_src.depthClampZeroOne;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT& safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT::operator=(
-    const safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    depthClampZeroOne = copy_src.depthClampZeroOne;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT::~safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT() { FreePnextChain(pNext); }
-
-void safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT::initialize(const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* in_struct,
-                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    depthClampZeroOne = in_struct->depthClampZeroOne;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT::initialize(
-    const safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    depthClampZeroOne = copy_src->depthClampZeroOne;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
 safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT::safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
     const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType), nonSeamlessCubeMap(in_struct->nonSeamlessCubeMap) {
diff --git a/src/vulkan/vk_safe_struct_khr.cpp b/src/vulkan/vk_safe_struct_khr.cpp
index 5afca11..a34ee9b 100644
--- a/src/vulkan/vk_safe_struct_khr.cpp
+++ b/src/vulkan/vk_safe_struct_khr.cpp
@@ -14672,6 +14672,154 @@ void safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR::initialize(
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkPhysicalDeviceMaintenance8FeaturesKHR::safe_VkPhysicalDeviceMaintenance8FeaturesKHR(
+    const VkPhysicalDeviceMaintenance8FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), maintenance8(in_struct->maintenance8) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMaintenance8FeaturesKHR::safe_VkPhysicalDeviceMaintenance8FeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR), pNext(nullptr), maintenance8() {}
+
+safe_VkPhysicalDeviceMaintenance8FeaturesKHR::safe_VkPhysicalDeviceMaintenance8FeaturesKHR(
+    const safe_VkPhysicalDeviceMaintenance8FeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    maintenance8 = copy_src.maintenance8;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMaintenance8FeaturesKHR& safe_VkPhysicalDeviceMaintenance8FeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceMaintenance8FeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maintenance8 = copy_src.maintenance8;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMaintenance8FeaturesKHR::~safe_VkPhysicalDeviceMaintenance8FeaturesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceMaintenance8FeaturesKHR::initialize(const VkPhysicalDeviceMaintenance8FeaturesKHR* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maintenance8 = in_struct->maintenance8;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMaintenance8FeaturesKHR::initialize(const safe_VkPhysicalDeviceMaintenance8FeaturesKHR* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maintenance8 = copy_src->maintenance8;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkMemoryBarrierAccessFlags3KHR::safe_VkMemoryBarrierAccessFlags3KHR(const VkMemoryBarrierAccessFlags3KHR* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType), srcAccessMask3(in_struct->srcAccessMask3), dstAccessMask3(in_struct->dstAccessMask3) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMemoryBarrierAccessFlags3KHR::safe_VkMemoryBarrierAccessFlags3KHR()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR), pNext(nullptr), srcAccessMask3(), dstAccessMask3() {}
+
+safe_VkMemoryBarrierAccessFlags3KHR::safe_VkMemoryBarrierAccessFlags3KHR(const safe_VkMemoryBarrierAccessFlags3KHR& copy_src) {
+    sType = copy_src.sType;
+    srcAccessMask3 = copy_src.srcAccessMask3;
+    dstAccessMask3 = copy_src.dstAccessMask3;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMemoryBarrierAccessFlags3KHR& safe_VkMemoryBarrierAccessFlags3KHR::operator=(
+    const safe_VkMemoryBarrierAccessFlags3KHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    srcAccessMask3 = copy_src.srcAccessMask3;
+    dstAccessMask3 = copy_src.dstAccessMask3;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMemoryBarrierAccessFlags3KHR::~safe_VkMemoryBarrierAccessFlags3KHR() { FreePnextChain(pNext); }
+
+void safe_VkMemoryBarrierAccessFlags3KHR::initialize(const VkMemoryBarrierAccessFlags3KHR* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    srcAccessMask3 = in_struct->srcAccessMask3;
+    dstAccessMask3 = in_struct->dstAccessMask3;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMemoryBarrierAccessFlags3KHR::initialize(const safe_VkMemoryBarrierAccessFlags3KHR* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    srcAccessMask3 = copy_src->srcAccessMask3;
+    dstAccessMask3 = copy_src->dstAccessMask3;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR::safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR(
+    const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), depthClampZeroOne(in_struct->depthClampZeroOne) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR::safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR), pNext(nullptr), depthClampZeroOne() {}
+
+safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR::safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR(
+    const safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    depthClampZeroOne = copy_src.depthClampZeroOne;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR& safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    depthClampZeroOne = copy_src.depthClampZeroOne;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR::~safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR::initialize(const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    depthClampZeroOne = in_struct->depthClampZeroOne;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR::initialize(
+    const safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    depthClampZeroOne = copy_src->depthClampZeroOne;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkDeviceOrHostAddressConstKHR::safe_VkDeviceOrHostAddressConstKHR(const VkDeviceOrHostAddressConstKHR* in_struct,
                                                                        PNextCopyState*) {
     initialize(in_struct);
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index 660a5f0..9741ca7 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -887,6 +887,15 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR:
                 safe_pNext = new safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR(reinterpret_cast<const VkPhysicalDeviceLayeredApiVulkanPropertiesKHR *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceMaintenance8FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceMaintenance8FeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR:
+                safe_pNext = new safe_VkMemoryBarrierAccessFlags3KHR(reinterpret_cast<const VkMemoryBarrierAccessFlags3KHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
                 safe_pNext = new safe_VkDebugReportCallbackCreateInfoEXT(reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>(pNext), copy_state, false);
                 break;
@@ -1653,9 +1662,6 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
                 safe_pNext = new safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(reinterpret_cast<const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *>(pNext), copy_state, false);
                 break;
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT:
-                safe_pNext = new safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *>(pNext), copy_state, false);
-                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
                 safe_pNext = new safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *>(pNext), copy_state, false);
                 break;
@@ -1960,6 +1966,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV:
                 safe_pNext = new safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrix2PropertiesNV *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM:
+                safe_pNext = new safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM(reinterpret_cast<const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
                 safe_pNext = new safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *>(pNext), copy_state, false);
                 break;
@@ -2866,6 +2875,15 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR:
             delete reinterpret_cast<safe_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR:
+            delete reinterpret_cast<safe_VkPhysicalDeviceMaintenance8FeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR:
+            delete reinterpret_cast<safe_VkMemoryBarrierAccessFlags3KHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR:
+            delete reinterpret_cast<safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *>(header);
+            break;
         case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
             delete reinterpret_cast<safe_VkDebugReportCallbackCreateInfoEXT *>(header);
             break;
@@ -3632,9 +3650,6 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
             delete reinterpret_cast<safe_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *>(header);
             break;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT:
-            delete reinterpret_cast<safe_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT *>(header);
-            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
             delete reinterpret_cast<safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *>(header);
             break;
@@ -3939,6 +3954,9 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV:
             delete reinterpret_cast<safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM:
+            delete reinterpret_cast<safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
             delete reinterpret_cast<safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *>(header);
             break;
diff --git a/src/vulkan/vk_safe_struct_vendor.cpp b/src/vulkan/vk_safe_struct_vendor.cpp
index 94a1d11..602644f 100644
--- a/src/vulkan/vk_safe_struct_vendor.cpp
+++ b/src/vulkan/vk_safe_struct_vendor.cpp
@@ -15973,6 +15973,57 @@ void safe_VkPhysicalDeviceCooperativeMatrix2PropertiesNV::initialize(
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM::safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM(
+    const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), pipelineOpacityMicromap(in_struct->pipelineOpacityMicromap) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM::safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM), pNext(nullptr), pipelineOpacityMicromap() {}
+
+safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM::safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM(
+    const safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM& copy_src) {
+    sType = copy_src.sType;
+    pipelineOpacityMicromap = copy_src.pipelineOpacityMicromap;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM& safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM::operator=(
+    const safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pipelineOpacityMicromap = copy_src.pipelineOpacityMicromap;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM::~safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM::initialize(
+    const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pipelineOpacityMicromap = in_struct->pipelineOpacityMicromap;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM::initialize(
+    const safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pipelineOpacityMicromap = copy_src->pipelineOpacityMicromap;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 }  // namespace vku
 
 // NOLINTEND

From 249718532de66af4496b7fe886f951d657395884 Mon Sep 17 00:00:00 2001
From: spencer-lunarg <spencer@lunarg.com>
Date: Mon, 20 Jan 2025 14:41:23 -0500
Subject: [PATCH 075/106] formats: Remove vkuFormatElementIsTexel

---
 include/vulkan/utility/vk_format_utils.h     | 11 -----------
 scripts/generators/format_utils_generator.py | 11 -----------
 tests/test_formats.cpp                       | 18 ++++--------------
 3 files changed, 4 insertions(+), 36 deletions(-)

diff --git a/include/vulkan/utility/vk_format_utils.h b/include/vulkan/utility/vk_format_utils.h
index 9d4d7b0..d1310bb 100644
--- a/include/vulkan/utility/vk_format_utils.h
+++ b/include/vulkan/utility/vk_format_utils.h
@@ -270,9 +270,6 @@ inline VkExtent3D vkuFormatTexelBlockExtent(VkFormat format);
 // Returns the Compatibility Class of a VkFormat as defined by the spec
 inline enum VKU_FORMAT_COMPATIBILITY_CLASS vkuFormatCompatibilityClass(VkFormat format);
 
-// Return true if a VkFormat is 'normal', with one texel per format element
-inline bool vkuFormatElementIsTexel(VkFormat format);
-
 // Return size, in bytes, of one element of a VkFormat
 // Format must not be a depth, stencil, or multiplane format
 inline uint32_t vkuFormatElementSize(VkFormat format);
@@ -2039,14 +2036,6 @@ inline VkExtent3D vkuFormatTexelBlockExtent(VkFormat format) { return vkuGetForm
 
 inline enum VKU_FORMAT_COMPATIBILITY_CLASS vkuFormatCompatibilityClass(VkFormat format) { return vkuGetFormatInfo(format).compatibility; }
 
-inline bool vkuFormatElementIsTexel(VkFormat format) {
-    if (vkuFormatIsPacked(format) || vkuFormatIsCompressed(format) || vkuFormatIsSinglePlane_422(format) || vkuFormatIsMultiplane(format)) {
-        return false;
-    } else {
-        return true;
-    }
-}
-
 inline uint32_t vkuFormatElementSize(VkFormat format) {
     return vkuFormatElementSizeWithAspect(format, VK_IMAGE_ASPECT_COLOR_BIT);
 }
diff --git a/scripts/generators/format_utils_generator.py b/scripts/generators/format_utils_generator.py
index ff76406..92967dd 100644
--- a/scripts/generators/format_utils_generator.py
+++ b/scripts/generators/format_utils_generator.py
@@ -216,9 +216,6 @@ inline VkExtent3D vkuFormatTexelBlockExtent(VkFormat format);
 // Returns the Compatibility Class of a VkFormat as defined by the spec
 inline enum VKU_FORMAT_COMPATIBILITY_CLASS vkuFormatCompatibilityClass(VkFormat format);
 
-// Return true if a VkFormat is 'normal', with one texel per format element
-inline bool vkuFormatElementIsTexel(VkFormat format);
-
 // Return size, in bytes, of one element of a VkFormat
 // Format must not be a depth, stencil, or multiplane format
 inline uint32_t vkuFormatElementSize(VkFormat format);
@@ -563,14 +560,6 @@ inline VkExtent3D vkuFormatTexelBlockExtent(VkFormat format) { return vkuGetForm
 
 inline enum VKU_FORMAT_COMPATIBILITY_CLASS vkuFormatCompatibilityClass(VkFormat format) { return vkuGetFormatInfo(format).compatibility; }
 
-inline bool vkuFormatElementIsTexel(VkFormat format) {
-    if (vkuFormatIsPacked(format) || vkuFormatIsCompressed(format) || vkuFormatIsSinglePlane_422(format) || vkuFormatIsMultiplane(format)) {
-        return false;
-    } else {
-        return true;
-    }
-}
-
 inline uint32_t vkuFormatElementSize(VkFormat format) {
     return vkuFormatElementSizeWithAspect(format, VK_IMAGE_ASPECT_COLOR_BIT);
 }
diff --git a/tests/test_formats.cpp b/tests/test_formats.cpp
index dd0483c..5440241 100644
--- a/tests/test_formats.cpp
+++ b/tests/test_formats.cpp
@@ -1,6 +1,6 @@
-// Copyright 2023 The Khronos Group Inc.
-// Copyright 2023 Valve Corporation
-// Copyright 2023 LunarG, Inc.
+// Copyright 2023-2025 The Khronos Group Inc.
+// Copyright 2023-2025 Valve Corporation
+// Copyright 2023-2025 LunarG, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
 //
@@ -503,17 +503,7 @@ TEST(format_utils, vkuFormatCompatibilityClass) {
         }
     }
 }
-TEST(format_utils, vkuFormatElementIsTexel) {
-    constexpr auto formats = magic_enum::enum_values<VkFormat>();
-    for (auto format : formats) {
-        if (!(vkuFormatIsPacked(format) || vkuFormatIsCompressed(format) || vkuFormatIsSinglePlane_422(format) ||
-              vkuFormatIsMultiplane(format))) {
-            EXPECT_TRUE(vkuFormatElementIsTexel(format));
-        } else {
-            EXPECT_FALSE(vkuFormatElementIsTexel(format));
-        }
-    }
-}
+
 TEST(format_utils, vkuFormatElementSizeWithAspect) {
     EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_R64G64_SFLOAT, VK_IMAGE_ASPECT_NONE), 16u);
     EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_R64G64_SFLOAT, VK_IMAGE_ASPECT_STENCIL_BIT), 0u);

From 4923254936be07659c7b65fe2b37ce121174cba3 Mon Sep 17 00:00:00 2001
From: spencer-lunarg <spencer@lunarg.com>
Date: Tue, 21 Jan 2025 12:20:48 -0500
Subject: [PATCH 076/106] formats: Add
 vkuFormatIsDepthStencilWithColorSizeCompatible

---
 include/vulkan/utility/vk_format_utils.h     | 25 ++++++++++++++++++++
 scripts/generators/format_utils_generator.py | 25 ++++++++++++++++++++
 tests/test_formats.cpp                       | 12 ++++++++++
 3 files changed, 62 insertions(+)

diff --git a/include/vulkan/utility/vk_format_utils.h b/include/vulkan/utility/vk_format_utils.h
index d1310bb..e82ea8c 100644
--- a/include/vulkan/utility/vk_format_utils.h
+++ b/include/vulkan/utility/vk_format_utils.h
@@ -261,6 +261,10 @@ inline VkFormat vkuFindMultiplaneCompatibleFormat(VkFormat mp_fmt, VkImageAspect
 // Will return {1, 1} if given a plane aspect that doesn't exist for the VkFormat
 inline VkExtent2D vkuFindMultiplaneExtentDivisors(VkFormat mp_fmt, VkImageAspectFlagBits plane_aspect);
 
+// From table in spec vkspec.html#formats-compatible-zs-color
+// Introduced in VK_KHR_maintenance8 to allow copying between color and depth/stencil formats
+inline bool vkuFormatIsDepthStencilWithColorSizeCompatible(VkFormat color_format, VkFormat ds_format);
+
 // Returns the count of components in a VkFormat
 inline uint32_t vkuFormatComponentCount(VkFormat format);
 
@@ -2030,6 +2034,27 @@ inline VkExtent2D vkuFindMultiplaneExtentDivisors(VkFormat mp_fmt, VkImageAspect
     return divisors;
 }
 
+// TODO - This should be generated, but will need updating the spec XML and table
+inline bool vkuFormatIsDepthStencilWithColorSizeCompatible(VkFormat color_format, VkFormat ds_format) {
+    switch (ds_format) {
+        case VK_FORMAT_D32_SFLOAT:
+        case VK_FORMAT_D32_SFLOAT_S8_UINT:
+            return color_format == VK_FORMAT_R32_SFLOAT || color_format == VK_FORMAT_R32_SINT || color_format == VK_FORMAT_R32_UINT;
+        case VK_FORMAT_X8_D24_UNORM_PACK32:
+        case VK_FORMAT_D24_UNORM_S8_UINT:
+            return color_format == VK_FORMAT_R32_SFLOAT || color_format == VK_FORMAT_R32_SINT || color_format == VK_FORMAT_R32_UINT;
+        case VK_FORMAT_D16_UNORM:
+        case VK_FORMAT_D16_UNORM_S8_UINT:
+            return color_format == VK_FORMAT_R16_SFLOAT || color_format == VK_FORMAT_R16_UNORM ||
+                   color_format == VK_FORMAT_R16_SNORM  || color_format == VK_FORMAT_R16_UINT || color_format == VK_FORMAT_R16_SINT;
+        case VK_FORMAT_S8_UINT:
+            return color_format == VK_FORMAT_R8_UINT || color_format == VK_FORMAT_R8_SINT ||
+                   color_format == VK_FORMAT_R8_UNORM || color_format == VK_FORMAT_R8_SNORM;
+        default:
+            return false;
+    }
+}
+
 inline uint32_t vkuFormatComponentCount(VkFormat format) { return vkuGetFormatInfo(format).component_count; }
 
 inline VkExtent3D vkuFormatTexelBlockExtent(VkFormat format) { return vkuGetFormatInfo(format).block_extent; }
diff --git a/scripts/generators/format_utils_generator.py b/scripts/generators/format_utils_generator.py
index 92967dd..fe073d6 100644
--- a/scripts/generators/format_utils_generator.py
+++ b/scripts/generators/format_utils_generator.py
@@ -207,6 +207,10 @@ inline VkFormat vkuFindMultiplaneCompatibleFormat(VkFormat mp_fmt, VkImageAspect
 // Will return {1, 1} if given a plane aspect that doesn't exist for the VkFormat
 inline VkExtent2D vkuFindMultiplaneExtentDivisors(VkFormat mp_fmt, VkImageAspectFlagBits plane_aspect);
 
+// From table in spec vkspec.html#formats-compatible-zs-color
+// Introduced in VK_KHR_maintenance8 to allow copying between color and depth/stencil formats
+inline bool vkuFormatIsDepthStencilWithColorSizeCompatible(VkFormat color_format, VkFormat ds_format);
+
 // Returns the count of components in a VkFormat
 inline uint32_t vkuFormatComponentCount(VkFormat format);
 
@@ -554,6 +558,27 @@ inline VkExtent2D vkuFindMultiplaneExtentDivisors(VkFormat mp_fmt, VkImageAspect
     return divisors;
 }
 
+// TODO - This should be generated, but will need updating the spec XML and table
+inline bool vkuFormatIsDepthStencilWithColorSizeCompatible(VkFormat color_format, VkFormat ds_format) {
+    switch (ds_format) {
+        case VK_FORMAT_D32_SFLOAT:
+        case VK_FORMAT_D32_SFLOAT_S8_UINT:
+            return color_format == VK_FORMAT_R32_SFLOAT || color_format == VK_FORMAT_R32_SINT || color_format == VK_FORMAT_R32_UINT;
+        case VK_FORMAT_X8_D24_UNORM_PACK32:
+        case VK_FORMAT_D24_UNORM_S8_UINT:
+            return color_format == VK_FORMAT_R32_SFLOAT || color_format == VK_FORMAT_R32_SINT || color_format == VK_FORMAT_R32_UINT;
+        case VK_FORMAT_D16_UNORM:
+        case VK_FORMAT_D16_UNORM_S8_UINT:
+            return color_format == VK_FORMAT_R16_SFLOAT || color_format == VK_FORMAT_R16_UNORM ||
+                   color_format == VK_FORMAT_R16_SNORM  || color_format == VK_FORMAT_R16_UINT || color_format == VK_FORMAT_R16_SINT;
+        case VK_FORMAT_S8_UINT:
+            return color_format == VK_FORMAT_R8_UINT || color_format == VK_FORMAT_R8_SINT ||
+                   color_format == VK_FORMAT_R8_UNORM || color_format == VK_FORMAT_R8_SNORM;
+        default:
+            return false;
+    }
+}
+
 inline uint32_t vkuFormatComponentCount(VkFormat format) { return vkuGetFormatInfo(format).component_count; }
 
 inline VkExtent3D vkuFormatTexelBlockExtent(VkFormat format) { return vkuGetFormatInfo(format).block_extent; }
diff --git a/tests/test_formats.cpp b/tests/test_formats.cpp
index 5440241..68ec5de 100644
--- a/tests/test_formats.cpp
+++ b/tests/test_formats.cpp
@@ -412,6 +412,18 @@ TEST(format_utils, vkuFindMultiplaneExtentDivisors) {
     EXPECT_EQ(vkuFindMultiplaneExtentDivisors(VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, VK_IMAGE_ASPECT_PLANE_2_BIT).height, 1u);
 }
 
+TEST(format_utils, vkuFormatIsDepthStencilWithColorSizeCompatible) {
+    EXPECT_FALSE(
+        vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, VK_FORMAT_D16_UNORM));
+    EXPECT_FALSE(vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_D16_UNORM, VK_FORMAT_R16_SFLOAT));
+    EXPECT_FALSE(vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_R8_UINT, VK_FORMAT_D16_UNORM_S8_UINT));
+    EXPECT_FALSE(vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_R16_UNORM, VK_FORMAT_S8_UINT));
+
+    EXPECT_TRUE(vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_R16_SFLOAT, VK_FORMAT_D16_UNORM));
+    EXPECT_TRUE(vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_R16_UNORM, VK_FORMAT_D16_UNORM_S8_UINT));
+    EXPECT_TRUE(vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_R8_UINT, VK_FORMAT_S8_UINT));
+}
+
 TEST(format_utils, vkuFormatComponentCount) {
     for (auto [format, format_str] : magic_enum::enum_entries<VkFormat>()) {
         if (vkuFormatIsCompressed(format)) {

From 9cf0d32399260b89bb74ce3401601b0457ffe476 Mon Sep 17 00:00:00 2001
From: spencer-lunarg <spencer@lunarg.com>
Date: Tue, 21 Jan 2025 12:03:02 -0500
Subject: [PATCH 077/106] formats: Add vkuFormatTexelBlockSize

---
 include/vulkan/utility/vk_format_utils.h     | 15 +++++++--
 scripts/generators/format_utils_generator.py | 15 +++++++--
 tests/integration/vk_format_utils.c          |  8 ++---
 tests/integration/vk_format_utils_2.c        |  8 ++---
 tests/test_formats.cpp                       | 34 ++++++--------------
 5 files changed, 43 insertions(+), 37 deletions(-)

diff --git a/include/vulkan/utility/vk_format_utils.h b/include/vulkan/utility/vk_format_utils.h
index e82ea8c..fee1219 100644
--- a/include/vulkan/utility/vk_format_utils.h
+++ b/include/vulkan/utility/vk_format_utils.h
@@ -274,12 +274,19 @@ inline VkExtent3D vkuFormatTexelBlockExtent(VkFormat format);
 // Returns the Compatibility Class of a VkFormat as defined by the spec
 inline enum VKU_FORMAT_COMPATIBILITY_CLASS vkuFormatCompatibilityClass(VkFormat format);
 
+// Returns the number of bytes in a single Texel Block.
+// When dealing with a depth/stencil format, need to consider using vkuFormatStencilSize or vkuFormatDepthSize.
+// When dealing with mulit-planar formats, need to consider using vkuGetPlaneIndex.
+inline uint32_t vkuFormatTexelBlockSize(VkFormat format);
+
 // Return size, in bytes, of one element of a VkFormat
 // Format must not be a depth, stencil, or multiplane format
+// Deprecated - Use vkuFormatTexelBlockSize - there is no "element" size in the spec
 inline uint32_t vkuFormatElementSize(VkFormat format);
 
 // Return the size in bytes of one texel of a VkFormat
 // For compressed or multi-plane, this may be a fractional number
+// Deprecated - Use vkuFormatTexelBlockSize - there is no "element" size in the spec
 inline uint32_t vkuFormatElementSizeWithAspect(VkFormat format, VkImageAspectFlagBits aspectMask);
 
 // Return the size in bytes of one texel of a VkFormat
@@ -352,7 +359,7 @@ struct VKU_FORMAT_COMPONENT_INFO {
 // Generic information for all formats
 struct VKU_FORMAT_INFO {
     enum VKU_FORMAT_COMPATIBILITY_CLASS compatibility;
-    uint32_t block_size;  // bytes
+    uint32_t texel_block_size;  // bytes
     uint32_t texel_per_block;
     VkExtent3D block_extent;
     uint32_t component_count;
@@ -2061,10 +2068,14 @@ inline VkExtent3D vkuFormatTexelBlockExtent(VkFormat format) { return vkuGetForm
 
 inline enum VKU_FORMAT_COMPATIBILITY_CLASS vkuFormatCompatibilityClass(VkFormat format) { return vkuGetFormatInfo(format).compatibility; }
 
+inline uint32_t vkuFormatTexelBlockSize(VkFormat format) { return vkuGetFormatInfo(format).texel_block_size; }
+
+// Deprecated - Use vkuFormatTexelBlockSize
 inline uint32_t vkuFormatElementSize(VkFormat format) {
     return vkuFormatElementSizeWithAspect(format, VK_IMAGE_ASPECT_COLOR_BIT);
 }
 
+// Deprecated - Use vkuFormatTexelBlockSize
 inline uint32_t vkuFormatElementSizeWithAspect(VkFormat format, VkImageAspectFlagBits aspectMask) {
     // Depth/Stencil aspect have separate helper functions
     if (aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) {
@@ -2077,7 +2088,7 @@ inline uint32_t vkuFormatElementSizeWithAspect(VkFormat format, VkImageAspectFla
         format = vkuFindMultiplaneCompatibleFormat(format, aspectMask);
     }
 
-    return vkuGetFormatInfo(format).block_size;
+    return vkuGetFormatInfo(format).texel_block_size;
 }
 
 inline double vkuFormatTexelSize(VkFormat format) {
diff --git a/scripts/generators/format_utils_generator.py b/scripts/generators/format_utils_generator.py
index fe073d6..d6a208a 100644
--- a/scripts/generators/format_utils_generator.py
+++ b/scripts/generators/format_utils_generator.py
@@ -220,12 +220,19 @@ inline VkExtent3D vkuFormatTexelBlockExtent(VkFormat format);
 // Returns the Compatibility Class of a VkFormat as defined by the spec
 inline enum VKU_FORMAT_COMPATIBILITY_CLASS vkuFormatCompatibilityClass(VkFormat format);
 
+// Returns the number of bytes in a single Texel Block.
+// When dealing with a depth/stencil format, need to consider using vkuFormatStencilSize or vkuFormatDepthSize.
+// When dealing with mulit-planar formats, need to consider using vkuGetPlaneIndex.
+inline uint32_t vkuFormatTexelBlockSize(VkFormat format);
+
 // Return size, in bytes, of one element of a VkFormat
 // Format must not be a depth, stencil, or multiplane format
+// Deprecated - Use vkuFormatTexelBlockSize - there is no "element" size in the spec
 inline uint32_t vkuFormatElementSize(VkFormat format);
 
 // Return the size in bytes of one texel of a VkFormat
 // For compressed or multi-plane, this may be a fractional number
+// Deprecated - Use vkuFormatTexelBlockSize - there is no "element" size in the spec
 inline uint32_t vkuFormatElementSizeWithAspect(VkFormat format, VkImageAspectFlagBits aspectMask);
 
 // Return the size in bytes of one texel of a VkFormat
@@ -291,7 +298,7 @@ struct VKU_FORMAT_COMPONENT_INFO {
 // Generic information for all formats
 struct VKU_FORMAT_INFO {
     enum VKU_FORMAT_COMPATIBILITY_CLASS compatibility;
-    uint32_t block_size;  // bytes
+    uint32_t texel_block_size;  // bytes
     uint32_t texel_per_block;
     VkExtent3D block_extent;
     uint32_t component_count;
@@ -585,10 +592,14 @@ inline VkExtent3D vkuFormatTexelBlockExtent(VkFormat format) { return vkuGetForm
 
 inline enum VKU_FORMAT_COMPATIBILITY_CLASS vkuFormatCompatibilityClass(VkFormat format) { return vkuGetFormatInfo(format).compatibility; }
 
+inline uint32_t vkuFormatTexelBlockSize(VkFormat format) { return vkuGetFormatInfo(format).texel_block_size; }
+
+// Deprecated - Use vkuFormatTexelBlockSize
 inline uint32_t vkuFormatElementSize(VkFormat format) {
     return vkuFormatElementSizeWithAspect(format, VK_IMAGE_ASPECT_COLOR_BIT);
 }
 
+// Deprecated - Use vkuFormatTexelBlockSize
 inline uint32_t vkuFormatElementSizeWithAspect(VkFormat format, VkImageAspectFlagBits aspectMask) {
     // Depth/Stencil aspect have separate helper functions
     if (aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) {
@@ -601,7 +612,7 @@ inline uint32_t vkuFormatElementSizeWithAspect(VkFormat format, VkImageAspectFla
         format = vkuFindMultiplaneCompatibleFormat(format, aspectMask);
     }
 
-    return vkuGetFormatInfo(format).block_size;
+    return vkuGetFormatInfo(format).texel_block_size;
 }
 
 inline double vkuFormatTexelSize(VkFormat format) {
diff --git a/tests/integration/vk_format_utils.c b/tests/integration/vk_format_utils.c
index e1c5854..17399f3 100644
--- a/tests/integration/vk_format_utils.c
+++ b/tests/integration/vk_format_utils.c
@@ -1,6 +1,6 @@
-// Copyright 2023 The Khronos Group Inc.
-// Copyright 2023 Valve Corporation
-// Copyright 2023 LunarG, Inc.
+// Copyright 2023-2025 The Khronos Group Inc.
+// Copyright 2023-2025 Valve Corporation
+// Copyright 2023-2025 LunarG, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
 #include <vulkan/utility/vk_format_utils.h>
@@ -8,7 +8,7 @@
 bool check_format_utils() {
     vkuGetPlaneIndex(VK_IMAGE_ASPECT_PLANE_1_BIT);
     vkuFormatHasGreen(VK_FORMAT_R8G8B8A8_UNORM);
-    vkuFormatElementSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_STENCIL_BIT);
+    vkuFormatTexelBlockSize(VK_FORMAT_ASTC_5x4_SRGB_BLOCK);
     struct VKU_FORMAT_INFO f = vkuGetFormatInfo(VK_FORMAT_R8G8B8A8_SRGB);
     if (f.component_count != 4) {
         return false;
diff --git a/tests/integration/vk_format_utils_2.c b/tests/integration/vk_format_utils_2.c
index 090e4c8..57256d0 100644
--- a/tests/integration/vk_format_utils_2.c
+++ b/tests/integration/vk_format_utils_2.c
@@ -1,6 +1,6 @@
-// Copyright 2023 The Khronos Group Inc.
-// Copyright 2023 Valve Corporation
-// Copyright 2023 LunarG, Inc.
+// Copyright 2023-2025 The Khronos Group Inc.
+// Copyright 2023-2025 Valve Corporation
+// Copyright 2023-2025 LunarG, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
 #include <vulkan/utility/vk_format_utils.h>
@@ -9,7 +9,7 @@
 bool check_format_utils_2() {
     vkuGetPlaneIndex(VK_IMAGE_ASPECT_PLANE_1_BIT);
     vkuFormatHasGreen(VK_FORMAT_R8G8B8A8_UNORM);
-    vkuFormatElementSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_STENCIL_BIT);
+    vkuFormatTexelBlockSize(VK_FORMAT_ASTC_5x4_SRGB_BLOCK);
     struct VKU_FORMAT_INFO f = vkuGetFormatInfo(VK_FORMAT_R8G8B8A8_SRGB);
     if (f.component_count != 4) {
         return false;
diff --git a/tests/test_formats.cpp b/tests/test_formats.cpp
index 68ec5de..85becc4 100644
--- a/tests/test_formats.cpp
+++ b/tests/test_formats.cpp
@@ -516,32 +516,16 @@ TEST(format_utils, vkuFormatCompatibilityClass) {
     }
 }
 
-TEST(format_utils, vkuFormatElementSizeWithAspect) {
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_R64G64_SFLOAT, VK_IMAGE_ASPECT_NONE), 16u);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_R64G64_SFLOAT, VK_IMAGE_ASPECT_STENCIL_BIT), 0u);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_R64G64_SFLOAT, VK_IMAGE_ASPECT_DEPTH_BIT), 0u);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_NONE), 16u);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_PLANE_0_BIT), 16u);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_PLANE_1_BIT), 16u);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_PLANE_2_BIT), 16u);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_STENCIL_BIT), 0u);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_DEPTH_BIT), 0u);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_NONE), 0u);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_PLANE_0_BIT), 2u);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_PLANE_1_BIT), 2u);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_PLANE_2_BIT), 2u);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_STENCIL_BIT), 0u);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_DEPTH_BIT), 0u);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_D32_SFLOAT, VK_IMAGE_ASPECT_NONE), 4u);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_D32_SFLOAT, VK_IMAGE_ASPECT_STENCIL_BIT), 0u);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_D32_SFLOAT, VK_IMAGE_ASPECT_DEPTH_BIT), 4u);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_D32_SFLOAT_S8_UINT, VK_IMAGE_ASPECT_NONE), 5u);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_D32_SFLOAT_S8_UINT, VK_IMAGE_ASPECT_STENCIL_BIT), 1u);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_D32_SFLOAT_S8_UINT, VK_IMAGE_ASPECT_DEPTH_BIT), 4u);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_S8_UINT, VK_IMAGE_ASPECT_NONE), 1u);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_S8_UINT, VK_IMAGE_ASPECT_STENCIL_BIT), 1u);
-    EXPECT_EQ(vkuFormatElementSizeWithAspect(VK_FORMAT_S8_UINT, VK_IMAGE_ASPECT_DEPTH_BIT), 0u);
+TEST(format_utils, vkuFormatTexelBlockSize) {
+    EXPECT_EQ(vkuFormatTexelBlockSize(VK_FORMAT_R64G64_SFLOAT), 16u);
+    EXPECT_EQ(vkuFormatTexelBlockSize(VK_FORMAT_ASTC_5x4_SRGB_BLOCK), 16u);
+    EXPECT_EQ(vkuFormatTexelBlockSize(VK_FORMAT_ASTC_5x5_SRGB_BLOCK), 16u);
+    EXPECT_EQ(vkuFormatTexelBlockSize(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM), 6u);
+    EXPECT_EQ(vkuFormatTexelBlockSize(VK_FORMAT_D32_SFLOAT), 4u);
+    EXPECT_EQ(vkuFormatTexelBlockSize(VK_FORMAT_D32_SFLOAT_S8_UINT), 5u);
+    EXPECT_EQ(vkuFormatTexelBlockSize(VK_FORMAT_S8_UINT), 1u);
 }
+
 TEST(format_utils, vkuFormatTexelSizeWithAspect) {
     EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_R64G64_SFLOAT, VK_IMAGE_ASPECT_NONE), 16);
     EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_R64G64_SFLOAT, VK_IMAGE_ASPECT_STENCIL_BIT), 0);

From f07e27717a642fa193c967440f21ed634ea17987 Mon Sep 17 00:00:00 2001
From: spencer-lunarg <spencer@lunarg.com>
Date: Tue, 21 Jan 2025 13:16:07 -0500
Subject: [PATCH 078/106] formats: Add vkuFormatTexelsPerBlock

---
 include/vulkan/utility/vk_format_utils.h     |  8 +++++++-
 scripts/generators/format_utils_generator.py |  8 +++++++-
 tests/test_formats.cpp                       | 12 ++++++++++++
 3 files changed, 26 insertions(+), 2 deletions(-)

diff --git a/include/vulkan/utility/vk_format_utils.h b/include/vulkan/utility/vk_format_utils.h
index fee1219..aa0bdbc 100644
--- a/include/vulkan/utility/vk_format_utils.h
+++ b/include/vulkan/utility/vk_format_utils.h
@@ -274,6 +274,10 @@ inline VkExtent3D vkuFormatTexelBlockExtent(VkFormat format);
 // Returns the Compatibility Class of a VkFormat as defined by the spec
 inline enum VKU_FORMAT_COMPATIBILITY_CLASS vkuFormatCompatibilityClass(VkFormat format);
 
+// Returns the number of texels inside a texel block
+// Will always be 1 when not using compressed block formats
+inline uint32_t vkuFormatTexelsPerBlock(VkFormat format);
+
 // Returns the number of bytes in a single Texel Block.
 // When dealing with a depth/stencil format, need to consider using vkuFormatStencilSize or vkuFormatDepthSize.
 // When dealing with mulit-planar formats, need to consider using vkuGetPlaneIndex.
@@ -360,7 +364,7 @@ struct VKU_FORMAT_COMPONENT_INFO {
 struct VKU_FORMAT_INFO {
     enum VKU_FORMAT_COMPATIBILITY_CLASS compatibility;
     uint32_t texel_block_size;  // bytes
-    uint32_t texel_per_block;
+    uint32_t texels_per_block;
     VkExtent3D block_extent;
     uint32_t component_count;
     struct VKU_FORMAT_COMPONENT_INFO components[VKU_FORMAT_MAX_COMPONENTS];
@@ -2068,6 +2072,8 @@ inline VkExtent3D vkuFormatTexelBlockExtent(VkFormat format) { return vkuGetForm
 
 inline enum VKU_FORMAT_COMPATIBILITY_CLASS vkuFormatCompatibilityClass(VkFormat format) { return vkuGetFormatInfo(format).compatibility; }
 
+inline uint32_t vkuFormatTexelsPerBlock(VkFormat format) { return vkuGetFormatInfo(format).texels_per_block; }
+
 inline uint32_t vkuFormatTexelBlockSize(VkFormat format) { return vkuGetFormatInfo(format).texel_block_size; }
 
 // Deprecated - Use vkuFormatTexelBlockSize
diff --git a/scripts/generators/format_utils_generator.py b/scripts/generators/format_utils_generator.py
index d6a208a..ee05230 100644
--- a/scripts/generators/format_utils_generator.py
+++ b/scripts/generators/format_utils_generator.py
@@ -220,6 +220,10 @@ inline VkExtent3D vkuFormatTexelBlockExtent(VkFormat format);
 // Returns the Compatibility Class of a VkFormat as defined by the spec
 inline enum VKU_FORMAT_COMPATIBILITY_CLASS vkuFormatCompatibilityClass(VkFormat format);
 
+// Returns the number of texels inside a texel block
+// Will always be 1 when not using compressed block formats
+inline uint32_t vkuFormatTexelsPerBlock(VkFormat format);
+
 // Returns the number of bytes in a single Texel Block.
 // When dealing with a depth/stencil format, need to consider using vkuFormatStencilSize or vkuFormatDepthSize.
 // When dealing with mulit-planar formats, need to consider using vkuGetPlaneIndex.
@@ -299,7 +303,7 @@ struct VKU_FORMAT_COMPONENT_INFO {
 struct VKU_FORMAT_INFO {
     enum VKU_FORMAT_COMPATIBILITY_CLASS compatibility;
     uint32_t texel_block_size;  // bytes
-    uint32_t texel_per_block;
+    uint32_t texels_per_block;
     VkExtent3D block_extent;
     uint32_t component_count;
     struct VKU_FORMAT_COMPONENT_INFO components[VKU_FORMAT_MAX_COMPONENTS];
@@ -592,6 +596,8 @@ inline VkExtent3D vkuFormatTexelBlockExtent(VkFormat format) { return vkuGetForm
 
 inline enum VKU_FORMAT_COMPATIBILITY_CLASS vkuFormatCompatibilityClass(VkFormat format) { return vkuGetFormatInfo(format).compatibility; }
 
+inline uint32_t vkuFormatTexelsPerBlock(VkFormat format) { return vkuGetFormatInfo(format).texels_per_block; }
+
 inline uint32_t vkuFormatTexelBlockSize(VkFormat format) { return vkuGetFormatInfo(format).texel_block_size; }
 
 // Deprecated - Use vkuFormatTexelBlockSize
diff --git a/tests/test_formats.cpp b/tests/test_formats.cpp
index 85becc4..2ec5a52 100644
--- a/tests/test_formats.cpp
+++ b/tests/test_formats.cpp
@@ -516,6 +516,18 @@ TEST(format_utils, vkuFormatCompatibilityClass) {
     }
 }
 
+TEST(format_utils, vkuFormatTexelsPerBlock) {
+    EXPECT_EQ(vkuFormatTexelsPerBlock(VK_FORMAT_R64G64_SFLOAT), 1u);
+    EXPECT_EQ(vkuFormatTexelsPerBlock(VK_FORMAT_BC6H_UFLOAT_BLOCK), 16u);
+    EXPECT_EQ(vkuFormatTexelsPerBlock(VK_FORMAT_ASTC_5x4_SRGB_BLOCK), 20u);
+    EXPECT_EQ(vkuFormatTexelsPerBlock(VK_FORMAT_ASTC_5x5_SRGB_BLOCK), 25u);
+    EXPECT_EQ(vkuFormatTexelsPerBlock(VK_FORMAT_ASTC_12x12_SRGB_BLOCK), 144u);
+    EXPECT_EQ(vkuFormatTexelsPerBlock(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM), 1u);
+    EXPECT_EQ(vkuFormatTexelsPerBlock(VK_FORMAT_D32_SFLOAT), 1u);
+    EXPECT_EQ(vkuFormatTexelsPerBlock(VK_FORMAT_D32_SFLOAT_S8_UINT), 1u);
+    EXPECT_EQ(vkuFormatTexelsPerBlock(VK_FORMAT_S8_UINT), 1u);
+}
+
 TEST(format_utils, vkuFormatTexelBlockSize) {
     EXPECT_EQ(vkuFormatTexelBlockSize(VK_FORMAT_R64G64_SFLOAT), 16u);
     EXPECT_EQ(vkuFormatTexelBlockSize(VK_FORMAT_ASTC_5x4_SRGB_BLOCK), 16u);

From 8ec84823afa46cd054c8b094269eab958e078010 Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Fri, 24 Jan 2025 08:28:51 -0800
Subject: [PATCH 079/106] build: Update to header 1.4.306

---
 include/vulkan/utility/vk_dispatch_table.h  |   8 +
 include/vulkan/utility/vk_safe_struct.hpp   | 138 ++++++++
 include/vulkan/utility/vk_struct_helper.hpp |   9 +
 include/vulkan/vk_enum_string_helper.h      |  22 ++
 scripts/known_good.json                     |   2 +-
 src/vulkan/vk_safe_struct_ext.cpp           | 155 +++++++++
 src/vulkan/vk_safe_struct_khr.cpp           | 352 ++++++++++++++++++++
 src/vulkan/vk_safe_struct_utils.cpp         |  34 ++
 8 files changed, 719 insertions(+), 1 deletion(-)

diff --git a/include/vulkan/utility/vk_dispatch_table.h b/include/vulkan/utility/vk_dispatch_table.h
index d8f80c4..ccb9ea6 100644
--- a/include/vulkan/utility/vk_dispatch_table.h
+++ b/include/vulkan/utility/vk_dispatch_table.h
@@ -768,6 +768,10 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkDestroyIndirectExecutionSetEXT DestroyIndirectExecutionSetEXT;
     PFN_vkUpdateIndirectExecutionSetPipelineEXT UpdateIndirectExecutionSetPipelineEXT;
     PFN_vkUpdateIndirectExecutionSetShaderEXT UpdateIndirectExecutionSetShaderEXT;
+#ifdef VK_USE_PLATFORM_METAL_EXT
+    PFN_vkGetMemoryMetalHandleEXT GetMemoryMetalHandleEXT;
+    PFN_vkGetMemoryMetalHandlePropertiesEXT GetMemoryMetalHandlePropertiesEXT;
+#endif  // VK_USE_PLATFORM_METAL_EXT
     PFN_vkCreateAccelerationStructureKHR CreateAccelerationStructureKHR;
     PFN_vkDestroyAccelerationStructureKHR DestroyAccelerationStructureKHR;
     PFN_vkCmdBuildAccelerationStructuresKHR CmdBuildAccelerationStructuresKHR;
@@ -1400,6 +1404,10 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
     table->DestroyIndirectExecutionSetEXT = (PFN_vkDestroyIndirectExecutionSetEXT)gdpa(device, "vkDestroyIndirectExecutionSetEXT");
     table->UpdateIndirectExecutionSetPipelineEXT = (PFN_vkUpdateIndirectExecutionSetPipelineEXT)gdpa(device, "vkUpdateIndirectExecutionSetPipelineEXT");
     table->UpdateIndirectExecutionSetShaderEXT = (PFN_vkUpdateIndirectExecutionSetShaderEXT)gdpa(device, "vkUpdateIndirectExecutionSetShaderEXT");
+#ifdef VK_USE_PLATFORM_METAL_EXT
+    table->GetMemoryMetalHandleEXT = (PFN_vkGetMemoryMetalHandleEXT)gdpa(device, "vkGetMemoryMetalHandleEXT");
+    table->GetMemoryMetalHandlePropertiesEXT = (PFN_vkGetMemoryMetalHandlePropertiesEXT)gdpa(device, "vkGetMemoryMetalHandlePropertiesEXT");
+#endif  // VK_USE_PLATFORM_METAL_EXT
     table->CreateAccelerationStructureKHR = (PFN_vkCreateAccelerationStructureKHR)gdpa(device, "vkCreateAccelerationStructureKHR");
     table->DestroyAccelerationStructureKHR = (PFN_vkDestroyAccelerationStructureKHR)gdpa(device, "vkDestroyAccelerationStructureKHR");
     table->CmdBuildAccelerationStructuresKHR = (PFN_vkCmdBuildAccelerationStructuresKHR)gdpa(device, "vkCmdBuildAccelerationStructuresKHR");
diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index 1beeab1..d57dce6 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -9628,6 +9628,92 @@ struct safe_VkMemoryBarrierAccessFlags3KHR {
     VkMemoryBarrierAccessFlags3KHR* ptr() { return reinterpret_cast<VkMemoryBarrierAccessFlags3KHR*>(this); }
     VkMemoryBarrierAccessFlags3KHR const* ptr() const { return reinterpret_cast<VkMemoryBarrierAccessFlags3KHR const*>(this); }
 };
+struct safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 videoMaintenance2;
+
+    safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR(const VkPhysicalDeviceVideoMaintenance2FeaturesKHR* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR(const safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR& operator=(const safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR();
+    ~safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR();
+    void initialize(const VkPhysicalDeviceVideoMaintenance2FeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVideoMaintenance2FeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceVideoMaintenance2FeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceVideoMaintenance2FeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceVideoMaintenance2FeaturesKHR const*>(this);
+    }
+};
+struct safe_VkVideoDecodeH264InlineSessionParametersInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    const StdVideoH264SequenceParameterSet* pStdSPS{};
+    const StdVideoH264PictureParameterSet* pStdPPS{};
+
+    safe_VkVideoDecodeH264InlineSessionParametersInfoKHR(const VkVideoDecodeH264InlineSessionParametersInfoKHR* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoDecodeH264InlineSessionParametersInfoKHR(const safe_VkVideoDecodeH264InlineSessionParametersInfoKHR& copy_src);
+    safe_VkVideoDecodeH264InlineSessionParametersInfoKHR& operator=(
+        const safe_VkVideoDecodeH264InlineSessionParametersInfoKHR& copy_src);
+    safe_VkVideoDecodeH264InlineSessionParametersInfoKHR();
+    ~safe_VkVideoDecodeH264InlineSessionParametersInfoKHR();
+    void initialize(const VkVideoDecodeH264InlineSessionParametersInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoDecodeH264InlineSessionParametersInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeH264InlineSessionParametersInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoDecodeH264InlineSessionParametersInfoKHR*>(this);
+    }
+    VkVideoDecodeH264InlineSessionParametersInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoDecodeH264InlineSessionParametersInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoDecodeH265InlineSessionParametersInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    const StdVideoH265VideoParameterSet* pStdVPS{};
+    const StdVideoH265SequenceParameterSet* pStdSPS{};
+    const StdVideoH265PictureParameterSet* pStdPPS{};
+
+    safe_VkVideoDecodeH265InlineSessionParametersInfoKHR(const VkVideoDecodeH265InlineSessionParametersInfoKHR* in_struct,
+                                                         PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoDecodeH265InlineSessionParametersInfoKHR(const safe_VkVideoDecodeH265InlineSessionParametersInfoKHR& copy_src);
+    safe_VkVideoDecodeH265InlineSessionParametersInfoKHR& operator=(
+        const safe_VkVideoDecodeH265InlineSessionParametersInfoKHR& copy_src);
+    safe_VkVideoDecodeH265InlineSessionParametersInfoKHR();
+    ~safe_VkVideoDecodeH265InlineSessionParametersInfoKHR();
+    void initialize(const VkVideoDecodeH265InlineSessionParametersInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoDecodeH265InlineSessionParametersInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeH265InlineSessionParametersInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoDecodeH265InlineSessionParametersInfoKHR*>(this);
+    }
+    VkVideoDecodeH265InlineSessionParametersInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoDecodeH265InlineSessionParametersInfoKHR const*>(this);
+    }
+};
+struct safe_VkVideoDecodeAV1InlineSessionParametersInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    const StdVideoAV1SequenceHeader* pStdSequenceHeader{};
+
+    safe_VkVideoDecodeAV1InlineSessionParametersInfoKHR(const VkVideoDecodeAV1InlineSessionParametersInfoKHR* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkVideoDecodeAV1InlineSessionParametersInfoKHR(const safe_VkVideoDecodeAV1InlineSessionParametersInfoKHR& copy_src);
+    safe_VkVideoDecodeAV1InlineSessionParametersInfoKHR& operator=(
+        const safe_VkVideoDecodeAV1InlineSessionParametersInfoKHR& copy_src);
+    safe_VkVideoDecodeAV1InlineSessionParametersInfoKHR();
+    ~safe_VkVideoDecodeAV1InlineSessionParametersInfoKHR();
+    void initialize(const VkVideoDecodeAV1InlineSessionParametersInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoDecodeAV1InlineSessionParametersInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeAV1InlineSessionParametersInfoKHR* ptr() {
+        return reinterpret_cast<VkVideoDecodeAV1InlineSessionParametersInfoKHR*>(this);
+    }
+    VkVideoDecodeAV1InlineSessionParametersInfoKHR const* ptr() const {
+        return reinterpret_cast<VkVideoDecodeAV1InlineSessionParametersInfoKHR const*>(this);
+    }
+};
 struct safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR {
     VkStructureType sType;
     void* pNext{};
@@ -19569,6 +19655,58 @@ struct safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM {
         return reinterpret_cast<VkPhysicalDevicePipelineOpacityMicromapFeaturesARM const*>(this);
     }
 };
+#ifdef VK_USE_PLATFORM_METAL_EXT
+struct safe_VkImportMemoryMetalHandleInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalMemoryHandleTypeFlagBits handleType;
+    void* handle{};
+
+    safe_VkImportMemoryMetalHandleInfoEXT(const VkImportMemoryMetalHandleInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkImportMemoryMetalHandleInfoEXT(const safe_VkImportMemoryMetalHandleInfoEXT& copy_src);
+    safe_VkImportMemoryMetalHandleInfoEXT& operator=(const safe_VkImportMemoryMetalHandleInfoEXT& copy_src);
+    safe_VkImportMemoryMetalHandleInfoEXT();
+    ~safe_VkImportMemoryMetalHandleInfoEXT();
+    void initialize(const VkImportMemoryMetalHandleInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkImportMemoryMetalHandleInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkImportMemoryMetalHandleInfoEXT* ptr() { return reinterpret_cast<VkImportMemoryMetalHandleInfoEXT*>(this); }
+    VkImportMemoryMetalHandleInfoEXT const* ptr() const { return reinterpret_cast<VkImportMemoryMetalHandleInfoEXT const*>(this); }
+};
+struct safe_VkMemoryMetalHandlePropertiesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t memoryTypeBits;
+
+    safe_VkMemoryMetalHandlePropertiesEXT(const VkMemoryMetalHandlePropertiesEXT* in_struct, PNextCopyState* copy_state = {},
+                                          bool copy_pnext = true);
+    safe_VkMemoryMetalHandlePropertiesEXT(const safe_VkMemoryMetalHandlePropertiesEXT& copy_src);
+    safe_VkMemoryMetalHandlePropertiesEXT& operator=(const safe_VkMemoryMetalHandlePropertiesEXT& copy_src);
+    safe_VkMemoryMetalHandlePropertiesEXT();
+    ~safe_VkMemoryMetalHandlePropertiesEXT();
+    void initialize(const VkMemoryMetalHandlePropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMemoryMetalHandlePropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryMetalHandlePropertiesEXT* ptr() { return reinterpret_cast<VkMemoryMetalHandlePropertiesEXT*>(this); }
+    VkMemoryMetalHandlePropertiesEXT const* ptr() const { return reinterpret_cast<VkMemoryMetalHandlePropertiesEXT const*>(this); }
+};
+struct safe_VkMemoryGetMetalHandleInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceMemory memory;
+    VkExternalMemoryHandleTypeFlagBits handleType;
+
+    safe_VkMemoryGetMetalHandleInfoEXT(const VkMemoryGetMetalHandleInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    safe_VkMemoryGetMetalHandleInfoEXT(const safe_VkMemoryGetMetalHandleInfoEXT& copy_src);
+    safe_VkMemoryGetMetalHandleInfoEXT& operator=(const safe_VkMemoryGetMetalHandleInfoEXT& copy_src);
+    safe_VkMemoryGetMetalHandleInfoEXT();
+    ~safe_VkMemoryGetMetalHandleInfoEXT();
+    void initialize(const VkMemoryGetMetalHandleInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMemoryGetMetalHandleInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryGetMetalHandleInfoEXT* ptr() { return reinterpret_cast<VkMemoryGetMetalHandleInfoEXT*>(this); }
+    VkMemoryGetMetalHandleInfoEXT const* ptr() const { return reinterpret_cast<VkMemoryGetMetalHandleInfoEXT const*>(this); }
+};
+#endif  // VK_USE_PLATFORM_METAL_EXT
 struct safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT {
     VkStructureType sType;
     void* pNext{};
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index f6b9e10..02b77e0 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -505,6 +505,10 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceLayeredApiProperties
 template <> inline VkStructureType GetSType<VkPhysicalDeviceLayeredApiVulkanPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance8FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkMemoryBarrierAccessFlags3KHR>() { return VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceVideoMaintenance2FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkVideoDecodeH264InlineSessionParametersInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkVideoDecodeH265InlineSessionParametersInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkVideoDecodeAV1InlineSessionParametersInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceDepthClampZeroOneFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkDebugReportCallbackCreateInfoEXT>() { return VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkPipelineRasterizationStateRasterizationOrderAMD>() { return VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD; }
@@ -1019,6 +1023,11 @@ template <> inline VkStructureType GetSType<VkCooperativeMatrixFlexibleDimension
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeMatrix2FeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeMatrix2PropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDevicePipelineOpacityMicromapFeaturesARM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM; }
+#ifdef VK_USE_PLATFORM_METAL_EXT
+template <> inline VkStructureType GetSType<VkImportMemoryMetalHandleInfoEXT>() { return VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT; }
+template <> inline VkStructureType GetSType<VkMemoryMetalHandlePropertiesEXT>() { return VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT; }
+template <> inline VkStructureType GetSType<VkMemoryGetMetalHandleInfoEXT>() { return VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT; }
+#endif  // VK_USE_PLATFORM_METAL_EXT
 template <> inline VkStructureType GetSType<VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryTrianglesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryAabbsDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index 4e939bc..aa1dfbf 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -2056,6 +2056,14 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT";
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT:
             return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI";
         case VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI:
@@ -2068,6 +2076,12 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM";
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT:
+            return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT";
+        case VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT:
+            return "VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT";
+        case VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT:
+            return "VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
@@ -6945,6 +6959,12 @@ static inline const char* string_VkExternalMemoryHandleTypeFlagBits(VkExternalMe
             return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV";
         case VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX:
             return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX";
+        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLBUFFER_BIT_EXT:
+            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLBUFFER_BIT_EXT";
+        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLTEXTURE_BIT_EXT:
+            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLTEXTURE_BIT_EXT";
+        case VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLHEAP_BIT_EXT:
+            return "VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLHEAP_BIT_EXT";
         default:
             return "Unhandled VkExternalMemoryHandleTypeFlagBits";
     }
@@ -8032,6 +8052,8 @@ static inline const char* string_VkVideoSessionCreateFlagBitsKHR(VkVideoSessionC
             return "VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR";
         case VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_EMPHASIS_MAP_BIT_KHR:
             return "VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_EMPHASIS_MAP_BIT_KHR";
+        case VK_VIDEO_SESSION_CREATE_INLINE_SESSION_PARAMETERS_BIT_KHR:
+            return "VK_VIDEO_SESSION_CREATE_INLINE_SESSION_PARAMETERS_BIT_KHR";
         default:
             return "Unhandled VkVideoSessionCreateFlagBitsKHR";
     }
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 25c2e57..27099c8 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.4.305"
+            "commit": "v1.4.306"
         },
         {
             "name": "googletest",
diff --git a/src/vulkan/vk_safe_struct_ext.cpp b/src/vulkan/vk_safe_struct_ext.cpp
index c971694..f3f6e6a 100644
--- a/src/vulkan/vk_safe_struct_ext.cpp
+++ b/src/vulkan/vk_safe_struct_ext.cpp
@@ -15493,6 +15493,161 @@ void safe_VkPipelineViewportDepthClampControlCreateInfoEXT::initialize(
         pDepthClampRange = new VkDepthClampRangeEXT(*copy_src->pDepthClampRange);
     }
 }
+#ifdef VK_USE_PLATFORM_METAL_EXT
+
+safe_VkImportMemoryMetalHandleInfoEXT::safe_VkImportMemoryMetalHandleInfoEXT(const VkImportMemoryMetalHandleInfoEXT* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType), handleType(in_struct->handleType), handle(in_struct->handle) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkImportMemoryMetalHandleInfoEXT::safe_VkImportMemoryMetalHandleInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT), pNext(nullptr), handleType(), handle(nullptr) {}
+
+safe_VkImportMemoryMetalHandleInfoEXT::safe_VkImportMemoryMetalHandleInfoEXT(
+    const safe_VkImportMemoryMetalHandleInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    handleType = copy_src.handleType;
+    handle = copy_src.handle;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkImportMemoryMetalHandleInfoEXT& safe_VkImportMemoryMetalHandleInfoEXT::operator=(
+    const safe_VkImportMemoryMetalHandleInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    handleType = copy_src.handleType;
+    handle = copy_src.handle;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkImportMemoryMetalHandleInfoEXT::~safe_VkImportMemoryMetalHandleInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkImportMemoryMetalHandleInfoEXT::initialize(const VkImportMemoryMetalHandleInfoEXT* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    handleType = in_struct->handleType;
+    handle = in_struct->handle;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkImportMemoryMetalHandleInfoEXT::initialize(const safe_VkImportMemoryMetalHandleInfoEXT* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    handleType = copy_src->handleType;
+    handle = copy_src->handle;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkMemoryMetalHandlePropertiesEXT::safe_VkMemoryMetalHandlePropertiesEXT(const VkMemoryMetalHandlePropertiesEXT* in_struct,
+                                                                             [[maybe_unused]] PNextCopyState* copy_state,
+                                                                             bool copy_pnext)
+    : sType(in_struct->sType), memoryTypeBits(in_struct->memoryTypeBits) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMemoryMetalHandlePropertiesEXT::safe_VkMemoryMetalHandlePropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT), pNext(nullptr), memoryTypeBits() {}
+
+safe_VkMemoryMetalHandlePropertiesEXT::safe_VkMemoryMetalHandlePropertiesEXT(
+    const safe_VkMemoryMetalHandlePropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    memoryTypeBits = copy_src.memoryTypeBits;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMemoryMetalHandlePropertiesEXT& safe_VkMemoryMetalHandlePropertiesEXT::operator=(
+    const safe_VkMemoryMetalHandlePropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    memoryTypeBits = copy_src.memoryTypeBits;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMemoryMetalHandlePropertiesEXT::~safe_VkMemoryMetalHandlePropertiesEXT() { FreePnextChain(pNext); }
+
+void safe_VkMemoryMetalHandlePropertiesEXT::initialize(const VkMemoryMetalHandlePropertiesEXT* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    memoryTypeBits = in_struct->memoryTypeBits;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMemoryMetalHandlePropertiesEXT::initialize(const safe_VkMemoryMetalHandlePropertiesEXT* copy_src,
+                                                       [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memoryTypeBits = copy_src->memoryTypeBits;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkMemoryGetMetalHandleInfoEXT::safe_VkMemoryGetMetalHandleInfoEXT(const VkMemoryGetMetalHandleInfoEXT* in_struct,
+                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), memory(in_struct->memory), handleType(in_struct->handleType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMemoryGetMetalHandleInfoEXT::safe_VkMemoryGetMetalHandleInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT), pNext(nullptr), memory(), handleType() {}
+
+safe_VkMemoryGetMetalHandleInfoEXT::safe_VkMemoryGetMetalHandleInfoEXT(const safe_VkMemoryGetMetalHandleInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    memory = copy_src.memory;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMemoryGetMetalHandleInfoEXT& safe_VkMemoryGetMetalHandleInfoEXT::operator=(
+    const safe_VkMemoryGetMetalHandleInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    memory = copy_src.memory;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMemoryGetMetalHandleInfoEXT::~safe_VkMemoryGetMetalHandleInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkMemoryGetMetalHandleInfoEXT::initialize(const VkMemoryGetMetalHandleInfoEXT* in_struct,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    memory = in_struct->memory;
+    handleType = in_struct->handleType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMemoryGetMetalHandleInfoEXT::initialize(const safe_VkMemoryGetMetalHandleInfoEXT* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memory = copy_src->memory;
+    handleType = copy_src->handleType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+#endif  // VK_USE_PLATFORM_METAL_EXT
 
 safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT::safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(
     const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
diff --git a/src/vulkan/vk_safe_struct_khr.cpp b/src/vulkan/vk_safe_struct_khr.cpp
index a34ee9b..e0416c3 100644
--- a/src/vulkan/vk_safe_struct_khr.cpp
+++ b/src/vulkan/vk_safe_struct_khr.cpp
@@ -14772,6 +14772,358 @@ void safe_VkMemoryBarrierAccessFlags3KHR::initialize(const safe_VkMemoryBarrierA
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR::safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR(
+    const VkPhysicalDeviceVideoMaintenance2FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), videoMaintenance2(in_struct->videoMaintenance2) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR::safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR), pNext(nullptr), videoMaintenance2() {}
+
+safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR::safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR(
+    const safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    videoMaintenance2 = copy_src.videoMaintenance2;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR& safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    videoMaintenance2 = copy_src.videoMaintenance2;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR::~safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR::initialize(const VkPhysicalDeviceVideoMaintenance2FeaturesKHR* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    videoMaintenance2 = in_struct->videoMaintenance2;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR::initialize(
+    const safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    videoMaintenance2 = copy_src->videoMaintenance2;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoDecodeH264InlineSessionParametersInfoKHR::safe_VkVideoDecodeH264InlineSessionParametersInfoKHR(
+    const VkVideoDecodeH264InlineSessionParametersInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), pStdSPS(nullptr), pStdPPS(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pStdSPS) {
+        pStdSPS = new StdVideoH264SequenceParameterSet(*in_struct->pStdSPS);
+    }
+
+    if (in_struct->pStdPPS) {
+        pStdPPS = new StdVideoH264PictureParameterSet(*in_struct->pStdPPS);
+    }
+}
+
+safe_VkVideoDecodeH264InlineSessionParametersInfoKHR::safe_VkVideoDecodeH264InlineSessionParametersInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR),
+      pNext(nullptr),
+      pStdSPS(nullptr),
+      pStdPPS(nullptr) {}
+
+safe_VkVideoDecodeH264InlineSessionParametersInfoKHR::safe_VkVideoDecodeH264InlineSessionParametersInfoKHR(
+    const safe_VkVideoDecodeH264InlineSessionParametersInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pStdSPS = nullptr;
+    pStdPPS = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdSPS) {
+        pStdSPS = new StdVideoH264SequenceParameterSet(*copy_src.pStdSPS);
+    }
+
+    if (copy_src.pStdPPS) {
+        pStdPPS = new StdVideoH264PictureParameterSet(*copy_src.pStdPPS);
+    }
+}
+
+safe_VkVideoDecodeH264InlineSessionParametersInfoKHR& safe_VkVideoDecodeH264InlineSessionParametersInfoKHR::operator=(
+    const safe_VkVideoDecodeH264InlineSessionParametersInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pStdSPS) delete pStdSPS;
+    if (pStdPPS) delete pStdPPS;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pStdSPS = nullptr;
+    pStdPPS = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdSPS) {
+        pStdSPS = new StdVideoH264SequenceParameterSet(*copy_src.pStdSPS);
+    }
+
+    if (copy_src.pStdPPS) {
+        pStdPPS = new StdVideoH264PictureParameterSet(*copy_src.pStdPPS);
+    }
+
+    return *this;
+}
+
+safe_VkVideoDecodeH264InlineSessionParametersInfoKHR::~safe_VkVideoDecodeH264InlineSessionParametersInfoKHR() {
+    if (pStdSPS) delete pStdSPS;
+    if (pStdPPS) delete pStdPPS;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoDecodeH264InlineSessionParametersInfoKHR::initialize(
+    const VkVideoDecodeH264InlineSessionParametersInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pStdSPS) delete pStdSPS;
+    if (pStdPPS) delete pStdPPS;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pStdSPS = nullptr;
+    pStdPPS = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pStdSPS) {
+        pStdSPS = new StdVideoH264SequenceParameterSet(*in_struct->pStdSPS);
+    }
+
+    if (in_struct->pStdPPS) {
+        pStdPPS = new StdVideoH264PictureParameterSet(*in_struct->pStdPPS);
+    }
+}
+
+void safe_VkVideoDecodeH264InlineSessionParametersInfoKHR::initialize(
+    const safe_VkVideoDecodeH264InlineSessionParametersInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pStdSPS = nullptr;
+    pStdPPS = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pStdSPS) {
+        pStdSPS = new StdVideoH264SequenceParameterSet(*copy_src->pStdSPS);
+    }
+
+    if (copy_src->pStdPPS) {
+        pStdPPS = new StdVideoH264PictureParameterSet(*copy_src->pStdPPS);
+    }
+}
+
+safe_VkVideoDecodeH265InlineSessionParametersInfoKHR::safe_VkVideoDecodeH265InlineSessionParametersInfoKHR(
+    const VkVideoDecodeH265InlineSessionParametersInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), pStdVPS(nullptr), pStdSPS(nullptr), pStdPPS(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pStdVPS) {
+        pStdVPS = new StdVideoH265VideoParameterSet(*in_struct->pStdVPS);
+    }
+
+    if (in_struct->pStdSPS) {
+        pStdSPS = new StdVideoH265SequenceParameterSet(*in_struct->pStdSPS);
+    }
+
+    if (in_struct->pStdPPS) {
+        pStdPPS = new StdVideoH265PictureParameterSet(*in_struct->pStdPPS);
+    }
+}
+
+safe_VkVideoDecodeH265InlineSessionParametersInfoKHR::safe_VkVideoDecodeH265InlineSessionParametersInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR),
+      pNext(nullptr),
+      pStdVPS(nullptr),
+      pStdSPS(nullptr),
+      pStdPPS(nullptr) {}
+
+safe_VkVideoDecodeH265InlineSessionParametersInfoKHR::safe_VkVideoDecodeH265InlineSessionParametersInfoKHR(
+    const safe_VkVideoDecodeH265InlineSessionParametersInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pStdVPS = nullptr;
+    pStdSPS = nullptr;
+    pStdPPS = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdVPS) {
+        pStdVPS = new StdVideoH265VideoParameterSet(*copy_src.pStdVPS);
+    }
+
+    if (copy_src.pStdSPS) {
+        pStdSPS = new StdVideoH265SequenceParameterSet(*copy_src.pStdSPS);
+    }
+
+    if (copy_src.pStdPPS) {
+        pStdPPS = new StdVideoH265PictureParameterSet(*copy_src.pStdPPS);
+    }
+}
+
+safe_VkVideoDecodeH265InlineSessionParametersInfoKHR& safe_VkVideoDecodeH265InlineSessionParametersInfoKHR::operator=(
+    const safe_VkVideoDecodeH265InlineSessionParametersInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pStdVPS) delete pStdVPS;
+    if (pStdSPS) delete pStdSPS;
+    if (pStdPPS) delete pStdPPS;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pStdVPS = nullptr;
+    pStdSPS = nullptr;
+    pStdPPS = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdVPS) {
+        pStdVPS = new StdVideoH265VideoParameterSet(*copy_src.pStdVPS);
+    }
+
+    if (copy_src.pStdSPS) {
+        pStdSPS = new StdVideoH265SequenceParameterSet(*copy_src.pStdSPS);
+    }
+
+    if (copy_src.pStdPPS) {
+        pStdPPS = new StdVideoH265PictureParameterSet(*copy_src.pStdPPS);
+    }
+
+    return *this;
+}
+
+safe_VkVideoDecodeH265InlineSessionParametersInfoKHR::~safe_VkVideoDecodeH265InlineSessionParametersInfoKHR() {
+    if (pStdVPS) delete pStdVPS;
+    if (pStdSPS) delete pStdSPS;
+    if (pStdPPS) delete pStdPPS;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoDecodeH265InlineSessionParametersInfoKHR::initialize(
+    const VkVideoDecodeH265InlineSessionParametersInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pStdVPS) delete pStdVPS;
+    if (pStdSPS) delete pStdSPS;
+    if (pStdPPS) delete pStdPPS;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pStdVPS = nullptr;
+    pStdSPS = nullptr;
+    pStdPPS = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pStdVPS) {
+        pStdVPS = new StdVideoH265VideoParameterSet(*in_struct->pStdVPS);
+    }
+
+    if (in_struct->pStdSPS) {
+        pStdSPS = new StdVideoH265SequenceParameterSet(*in_struct->pStdSPS);
+    }
+
+    if (in_struct->pStdPPS) {
+        pStdPPS = new StdVideoH265PictureParameterSet(*in_struct->pStdPPS);
+    }
+}
+
+void safe_VkVideoDecodeH265InlineSessionParametersInfoKHR::initialize(
+    const safe_VkVideoDecodeH265InlineSessionParametersInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pStdVPS = nullptr;
+    pStdSPS = nullptr;
+    pStdPPS = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pStdVPS) {
+        pStdVPS = new StdVideoH265VideoParameterSet(*copy_src->pStdVPS);
+    }
+
+    if (copy_src->pStdSPS) {
+        pStdSPS = new StdVideoH265SequenceParameterSet(*copy_src->pStdSPS);
+    }
+
+    if (copy_src->pStdPPS) {
+        pStdPPS = new StdVideoH265PictureParameterSet(*copy_src->pStdPPS);
+    }
+}
+
+safe_VkVideoDecodeAV1InlineSessionParametersInfoKHR::safe_VkVideoDecodeAV1InlineSessionParametersInfoKHR(
+    const VkVideoDecodeAV1InlineSessionParametersInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), pStdSequenceHeader(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pStdSequenceHeader) {
+        pStdSequenceHeader = new StdVideoAV1SequenceHeader(*in_struct->pStdSequenceHeader);
+    }
+}
+
+safe_VkVideoDecodeAV1InlineSessionParametersInfoKHR::safe_VkVideoDecodeAV1InlineSessionParametersInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR), pNext(nullptr), pStdSequenceHeader(nullptr) {}
+
+safe_VkVideoDecodeAV1InlineSessionParametersInfoKHR::safe_VkVideoDecodeAV1InlineSessionParametersInfoKHR(
+    const safe_VkVideoDecodeAV1InlineSessionParametersInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pStdSequenceHeader = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdSequenceHeader) {
+        pStdSequenceHeader = new StdVideoAV1SequenceHeader(*copy_src.pStdSequenceHeader);
+    }
+}
+
+safe_VkVideoDecodeAV1InlineSessionParametersInfoKHR& safe_VkVideoDecodeAV1InlineSessionParametersInfoKHR::operator=(
+    const safe_VkVideoDecodeAV1InlineSessionParametersInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pStdSequenceHeader) delete pStdSequenceHeader;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pStdSequenceHeader = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdSequenceHeader) {
+        pStdSequenceHeader = new StdVideoAV1SequenceHeader(*copy_src.pStdSequenceHeader);
+    }
+
+    return *this;
+}
+
+safe_VkVideoDecodeAV1InlineSessionParametersInfoKHR::~safe_VkVideoDecodeAV1InlineSessionParametersInfoKHR() {
+    if (pStdSequenceHeader) delete pStdSequenceHeader;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoDecodeAV1InlineSessionParametersInfoKHR::initialize(
+    const VkVideoDecodeAV1InlineSessionParametersInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pStdSequenceHeader) delete pStdSequenceHeader;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pStdSequenceHeader = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pStdSequenceHeader) {
+        pStdSequenceHeader = new StdVideoAV1SequenceHeader(*in_struct->pStdSequenceHeader);
+    }
+}
+
+void safe_VkVideoDecodeAV1InlineSessionParametersInfoKHR::initialize(
+    const safe_VkVideoDecodeAV1InlineSessionParametersInfoKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pStdSequenceHeader = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pStdSequenceHeader) {
+        pStdSequenceHeader = new StdVideoAV1SequenceHeader(*copy_src->pStdSequenceHeader);
+    }
+}
+
 safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR::safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR(
     const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType), depthClampZeroOne(in_struct->depthClampZeroOne) {
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index 9741ca7..a5e7be5 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -893,6 +893,18 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR:
                 safe_pNext = new safe_VkMemoryBarrierAccessFlags3KHR(reinterpret_cast<const VkMemoryBarrierAccessFlags3KHR *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceVideoMaintenance2FeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR:
+                safe_pNext = new safe_VkVideoDecodeH264InlineSessionParametersInfoKHR(reinterpret_cast<const VkVideoDecodeH264InlineSessionParametersInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR:
+                safe_pNext = new safe_VkVideoDecodeH265InlineSessionParametersInfoKHR(reinterpret_cast<const VkVideoDecodeH265InlineSessionParametersInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR:
+                safe_pNext = new safe_VkVideoDecodeAV1InlineSessionParametersInfoKHR(reinterpret_cast<const VkVideoDecodeAV1InlineSessionParametersInfoKHR *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR:
                 safe_pNext = new safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *>(pNext), copy_state, false);
                 break;
@@ -1969,6 +1981,11 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM:
                 safe_pNext = new safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM(reinterpret_cast<const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *>(pNext), copy_state, false);
                 break;
+#ifdef VK_USE_PLATFORM_METAL_EXT
+            case VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT:
+                safe_pNext = new safe_VkImportMemoryMetalHandleInfoEXT(reinterpret_cast<const VkImportMemoryMetalHandleInfoEXT *>(pNext), copy_state, false);
+                break;
+#endif  // VK_USE_PLATFORM_METAL_EXT
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
                 safe_pNext = new safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *>(pNext), copy_state, false);
                 break;
@@ -2881,6 +2898,18 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR:
             delete reinterpret_cast<safe_VkMemoryBarrierAccessFlags3KHR *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR:
+            delete reinterpret_cast<safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR:
+            delete reinterpret_cast<safe_VkVideoDecodeH264InlineSessionParametersInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR:
+            delete reinterpret_cast<safe_VkVideoDecodeH265InlineSessionParametersInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR:
+            delete reinterpret_cast<safe_VkVideoDecodeAV1InlineSessionParametersInfoKHR *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR:
             delete reinterpret_cast<safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *>(header);
             break;
@@ -3957,6 +3986,11 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM:
             delete reinterpret_cast<safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *>(header);
             break;
+#ifdef VK_USE_PLATFORM_METAL_EXT
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT:
+            delete reinterpret_cast<safe_VkImportMemoryMetalHandleInfoEXT *>(header);
+            break;
+#endif  // VK_USE_PLATFORM_METAL_EXT
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
             delete reinterpret_cast<safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *>(header);
             break;

From 1ddbe6c40aeaf98d4138f07c325ebb01beeece68 Mon Sep 17 00:00:00 2001
From: spencer-lunarg <spencer@lunarg.com>
Date: Mon, 27 Jan 2025 10:59:56 -0500
Subject: [PATCH 080/106] scripts: Sync up base generator and vulkan object

---
 scripts/generators/base_generator.py | 30 ++++++++++++++++++++--------
 scripts/generators/vulkan_object.py  |  2 +-
 2 files changed, 23 insertions(+), 9 deletions(-)

diff --git a/scripts/generators/base_generator.py b/scripts/generators/base_generator.py
index 639acfe..8d4ee06 100644
--- a/scripts/generators/base_generator.py
+++ b/scripts/generators/base_generator.py
@@ -1,8 +1,8 @@
 #!/usr/bin/python3 -i
 #
-# Copyright (c) 2023-2024 Valve Corporation
-# Copyright (c) 2023-2024 LunarG, Inc.
-# Copyright (c) 2023-2024 RasterGrid Kft.
+# Copyright (c) 2023-2025 Valve Corporation
+# Copyright (c) 2023-2025 LunarG, Inc.
+# Copyright (c) 2023-2025 RasterGrid Kft.
 #
 # SPDX-License-Identifier: Apache-2.0
 
@@ -26,7 +26,7 @@ vulkanConventions = VulkanConventions()
 
 # Helpers to keep things cleaner
 def splitIfGet(elem, name):
-    return elem.get(name).split(',') if elem.get(name) is not None else None
+    return elem.get(name).split(',') if elem.get(name) is not None and elem.get(name) != '' else None
 
 def textIfFind(elem, name):
     return elem.find(name).text if elem.find(name) is not None else None
@@ -86,14 +86,14 @@ def EnableCaching() -> None:
 class APISpecific:
     # Version object factory method
     @staticmethod
-    def createApiVersion(targetApiName: str, name: str, number: str) -> Version:
+    def createApiVersion(targetApiName: str, name: str) -> Version:
         match targetApiName:
 
             # Vulkan specific API version creation
             case 'vulkan':
                 nameApi = name.replace('VK_', 'VK_API_')
                 nameString = f'"{name}"'
-                return Version(name, nameString, nameApi, number)
+                return Version(name, nameString, nameApi)
 
 
 # This Generator Option is used across all generators.
@@ -295,12 +295,25 @@ class BaseGenerator(OutputGenerator):
             for required in dict:
                 for group in dict[required]:
                     for structName in dict[required][group]:
+                        isAlias = structName in self.structAliasMap
+                        structName = self.structAliasMap[structName] if isAlias else structName
+                        # An EXT struct can alias a KHR struct,
+                        # that in turns aliaes a core struct
+                        # => Try to propagate aliasing, it can safely result in a no-op
                         isAlias = structName in self.structAliasMap
                         structName = self.structAliasMap[structName] if isAlias else structName
                         if structName in self.vk.structs:
                             struct = self.vk.structs[structName]
                             struct.extensions.extend([extension] if extension not in struct.extensions else [])
 
+        # While we update struct alias inside other structs, the command itself might have the struct as a first level param.
+        # We use this time to update params to have the promoted name
+        # Example - https://github.com/KhronosGroup/Vulkan-ValidationLayers/issues/9322
+        for command in self.vk.commands.values():
+            for member in command.params:
+                if member.type in self.structAliasMap:
+                    member.type = self.structAliasMap[member.type]
+
     def endFile(self):
         # This is the point were reg.py has ran, everything is collected
         # We do some post processing now
@@ -382,16 +395,17 @@ class BaseGenerator(OutputGenerator):
             obsoletedby = interface.get('obsoletedby')
             specialuse = splitIfGet(interface, 'specialuse')
             # Not sure if better way to get this info
+            specVersion = self.featureDictionary[name]['enumconstant'][None][None][0]
             nameString = self.featureDictionary[name]['enumconstant'][None][None][1]
 
-            self.currentExtension = Extension(name, nameString, instance, device, depends, vendorTag,
+            self.currentExtension = Extension(name, nameString, specVersion, instance, device, depends, vendorTag,
                                             platform, protect, provisional, promotedto, deprecatedby,
                                             obsoletedby, specialuse)
             self.vk.extensions[name] = self.currentExtension
         else: # version
             number = interface.get('number')
             if number != '1.0':
-                self.currentVersion = APISpecific.createApiVersion(self.targetApiName, name, number)
+                self.currentVersion = APISpecific.createApiVersion(self.targetApiName, name)
                 self.vk.versions[name] = self.currentVersion
 
     def endFeature(self):
diff --git a/scripts/generators/vulkan_object.py b/scripts/generators/vulkan_object.py
index 642e817..bb3bd24 100644
--- a/scripts/generators/vulkan_object.py
+++ b/scripts/generators/vulkan_object.py
@@ -13,6 +13,7 @@ class Extension:
     """<extension>"""
     name: str # ex) VK_KHR_SURFACE
     nameString: str # marco with string, ex) VK_KHR_SURFACE_EXTENSION_NAME
+    specVersion: str # marco with string, ex) VK_KHR_SURFACE_SPEC_VERSION
 
     # Only one will be True, the other is False
     instance: bool
@@ -47,7 +48,6 @@ class Version:
     name: str       # ex) VK_VERSION_1_1
     nameString: str # ex) "VK_VERSION_1_1" (no marco, so has quotes)
     nameApi: str    # ex) VK_API_VERSION_1_1
-    number: str     # ex) 1.1
 
 @dataclass
 class Handle:

From fe7a09b13899c5c77d956fa310286f7a7eb2c4ed Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Thu, 30 Jan 2025 08:59:00 -0800
Subject: [PATCH 081/106] build: Update to header 1.4.307

---
 include/vulkan/utility/vk_dispatch_table.h  |   14 +
 include/vulkan/utility/vk_safe_struct.hpp   |  590 ++++++-
 include/vulkan/utility/vk_struct_helper.hpp |   23 +-
 include/vulkan/vk_enum_string_helper.h      |  298 ++++
 scripts/generators/safe_struct_generator.py |   44 +-
 scripts/known_good.json                     |    2 +-
 src/vulkan/vk_safe_struct_core.cpp          |    8 +-
 src/vulkan/vk_safe_struct_ext.cpp           |    8 +-
 src/vulkan/vk_safe_struct_khr.cpp           |  134 +-
 src/vulkan/vk_safe_struct_utils.cpp         |   68 +-
 src/vulkan/vk_safe_struct_vendor.cpp        | 1699 ++++++++++++++++++-
 11 files changed, 2755 insertions(+), 133 deletions(-)

diff --git a/include/vulkan/utility/vk_dispatch_table.h b/include/vulkan/utility/vk_dispatch_table.h
index ccb9ea6..5772966 100644
--- a/include/vulkan/utility/vk_dispatch_table.h
+++ b/include/vulkan/utility/vk_dispatch_table.h
@@ -161,6 +161,7 @@ typedef struct VkuInstanceDispatchTable_ {
     PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX GetPhysicalDeviceScreenPresentationSupportQNX;
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
     PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV GetPhysicalDeviceOpticalFlowImageFormatsNV;
+    PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV GetPhysicalDeviceCooperativeVectorPropertiesNV;
     PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV;
 } VkuInstanceDispatchTable;
 
@@ -750,6 +751,8 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkCmdSetDepthClampRangeEXT CmdSetDepthClampRangeEXT;
     PFN_vkGetFramebufferTilePropertiesQCOM GetFramebufferTilePropertiesQCOM;
     PFN_vkGetDynamicRenderingTilePropertiesQCOM GetDynamicRenderingTilePropertiesQCOM;
+    PFN_vkConvertCooperativeVectorMatrixNV ConvertCooperativeVectorMatrixNV;
+    PFN_vkCmdConvertCooperativeVectorMatrixNV CmdConvertCooperativeVectorMatrixNV;
     PFN_vkSetLatencySleepModeNV SetLatencySleepModeNV;
     PFN_vkLatencySleepNV LatencySleepNV;
     PFN_vkSetLatencyMarkerNV SetLatencyMarkerNV;
@@ -759,6 +762,10 @@ typedef struct VkuDeviceDispatchTable_ {
 #ifdef VK_USE_PLATFORM_SCREEN_QNX
     PFN_vkGetScreenBufferPropertiesQNX GetScreenBufferPropertiesQNX;
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
+    PFN_vkGetClusterAccelerationStructureBuildSizesNV GetClusterAccelerationStructureBuildSizesNV;
+    PFN_vkCmdBuildClusterAccelerationStructureIndirectNV CmdBuildClusterAccelerationStructureIndirectNV;
+    PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV GetPartitionedAccelerationStructuresBuildSizesNV;
+    PFN_vkCmdBuildPartitionedAccelerationStructuresNV CmdBuildPartitionedAccelerationStructuresNV;
     PFN_vkGetGeneratedCommandsMemoryRequirementsEXT GetGeneratedCommandsMemoryRequirementsEXT;
     PFN_vkCmdPreprocessGeneratedCommandsEXT CmdPreprocessGeneratedCommandsEXT;
     PFN_vkCmdExecuteGeneratedCommandsEXT CmdExecuteGeneratedCommandsEXT;
@@ -1386,6 +1393,8 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
     table->CmdSetDepthClampRangeEXT = (PFN_vkCmdSetDepthClampRangeEXT)gdpa(device, "vkCmdSetDepthClampRangeEXT");
     table->GetFramebufferTilePropertiesQCOM = (PFN_vkGetFramebufferTilePropertiesQCOM)gdpa(device, "vkGetFramebufferTilePropertiesQCOM");
     table->GetDynamicRenderingTilePropertiesQCOM = (PFN_vkGetDynamicRenderingTilePropertiesQCOM)gdpa(device, "vkGetDynamicRenderingTilePropertiesQCOM");
+    table->ConvertCooperativeVectorMatrixNV = (PFN_vkConvertCooperativeVectorMatrixNV)gdpa(device, "vkConvertCooperativeVectorMatrixNV");
+    table->CmdConvertCooperativeVectorMatrixNV = (PFN_vkCmdConvertCooperativeVectorMatrixNV)gdpa(device, "vkCmdConvertCooperativeVectorMatrixNV");
     table->SetLatencySleepModeNV = (PFN_vkSetLatencySleepModeNV)gdpa(device, "vkSetLatencySleepModeNV");
     table->LatencySleepNV = (PFN_vkLatencySleepNV)gdpa(device, "vkLatencySleepNV");
     table->SetLatencyMarkerNV = (PFN_vkSetLatencyMarkerNV)gdpa(device, "vkSetLatencyMarkerNV");
@@ -1395,6 +1404,10 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
 #ifdef VK_USE_PLATFORM_SCREEN_QNX
     table->GetScreenBufferPropertiesQNX = (PFN_vkGetScreenBufferPropertiesQNX)gdpa(device, "vkGetScreenBufferPropertiesQNX");
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
+    table->GetClusterAccelerationStructureBuildSizesNV = (PFN_vkGetClusterAccelerationStructureBuildSizesNV)gdpa(device, "vkGetClusterAccelerationStructureBuildSizesNV");
+    table->CmdBuildClusterAccelerationStructureIndirectNV = (PFN_vkCmdBuildClusterAccelerationStructureIndirectNV)gdpa(device, "vkCmdBuildClusterAccelerationStructureIndirectNV");
+    table->GetPartitionedAccelerationStructuresBuildSizesNV = (PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV)gdpa(device, "vkGetPartitionedAccelerationStructuresBuildSizesNV");
+    table->CmdBuildPartitionedAccelerationStructuresNV = (PFN_vkCmdBuildPartitionedAccelerationStructuresNV)gdpa(device, "vkCmdBuildPartitionedAccelerationStructuresNV");
     table->GetGeneratedCommandsMemoryRequirementsEXT = (PFN_vkGetGeneratedCommandsMemoryRequirementsEXT)gdpa(device, "vkGetGeneratedCommandsMemoryRequirementsEXT");
     table->CmdPreprocessGeneratedCommandsEXT = (PFN_vkCmdPreprocessGeneratedCommandsEXT)gdpa(device, "vkCmdPreprocessGeneratedCommandsEXT");
     table->CmdExecuteGeneratedCommandsEXT = (PFN_vkCmdExecuteGeneratedCommandsEXT)gdpa(device, "vkCmdExecuteGeneratedCommandsEXT");
@@ -1575,6 +1588,7 @@ static inline void vkuInitInstanceDispatchTable(VkInstance instance, VkuInstance
     table->GetPhysicalDeviceScreenPresentationSupportQNX = (PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX)gipa(instance, "vkGetPhysicalDeviceScreenPresentationSupportQNX");
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
     table->GetPhysicalDeviceOpticalFlowImageFormatsNV = (PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV)gipa(instance, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV");
+    table->GetPhysicalDeviceCooperativeVectorPropertiesNV = (PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV)gipa(instance, "vkGetPhysicalDeviceCooperativeVectorPropertiesNV");
     table->GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = (PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV)gipa(instance, "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV");
 }
 // clang-format on
diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index d57dce6..9f44f69 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -3,10 +3,10 @@
 
 /***************************************************************************
  *
- * Copyright (c) 2015-2024 The Khronos Group Inc.
- * Copyright (c) 2015-2024 Valve Corporation
- * Copyright (c) 2015-2024 LunarG, Inc.
- * Copyright (c) 2015-2024 Google Inc.
+ * Copyright (c) 2015-2025 The Khronos Group Inc.
+ * Copyright (c) 2015-2025 Valve Corporation
+ * Copyright (c) 2015-2025 LunarG, Inc.
+ * Copyright (c) 2015-2025 Google Inc.
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -17266,6 +17266,91 @@ struct safe_VkPipelineIndirectDeviceAddressInfoNV {
         return reinterpret_cast<VkPipelineIndirectDeviceAddressInfoNV const*>(this);
     }
 };
+struct safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 spheres;
+    VkBool32 linearSweptSpheres;
+
+    safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV(
+        const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV(
+        const safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV& operator=(
+        const safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV();
+    ~safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV();
+    void initialize(const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV const*>(this);
+    }
+};
+struct safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkFormat vertexFormat;
+    safe_VkDeviceOrHostAddressConstKHR vertexData;
+    VkDeviceSize vertexStride;
+    VkFormat radiusFormat;
+    safe_VkDeviceOrHostAddressConstKHR radiusData;
+    VkDeviceSize radiusStride;
+    VkIndexType indexType;
+    safe_VkDeviceOrHostAddressConstKHR indexData;
+    VkDeviceSize indexStride;
+    VkRayTracingLssIndexingModeNV indexingMode;
+    VkRayTracingLssPrimitiveEndCapsModeNV endCapsMode;
+
+    safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV(
+        const VkAccelerationStructureGeometryLinearSweptSpheresDataNV* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV(
+        const safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV& copy_src);
+    safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV& operator=(
+        const safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV& copy_src);
+    safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV();
+    ~safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV();
+    void initialize(const VkAccelerationStructureGeometryLinearSweptSpheresDataNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureGeometryLinearSweptSpheresDataNV* ptr() {
+        return reinterpret_cast<VkAccelerationStructureGeometryLinearSweptSpheresDataNV*>(this);
+    }
+    VkAccelerationStructureGeometryLinearSweptSpheresDataNV const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureGeometryLinearSweptSpheresDataNV const*>(this);
+    }
+};
+struct safe_VkAccelerationStructureGeometrySpheresDataNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkFormat vertexFormat;
+    safe_VkDeviceOrHostAddressConstKHR vertexData;
+    VkDeviceSize vertexStride;
+    VkFormat radiusFormat;
+    safe_VkDeviceOrHostAddressConstKHR radiusData;
+    VkDeviceSize radiusStride;
+    VkIndexType indexType;
+    safe_VkDeviceOrHostAddressConstKHR indexData;
+    VkDeviceSize indexStride;
+
+    safe_VkAccelerationStructureGeometrySpheresDataNV(const VkAccelerationStructureGeometrySpheresDataNV* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkAccelerationStructureGeometrySpheresDataNV(const safe_VkAccelerationStructureGeometrySpheresDataNV& copy_src);
+    safe_VkAccelerationStructureGeometrySpheresDataNV& operator=(const safe_VkAccelerationStructureGeometrySpheresDataNV& copy_src);
+    safe_VkAccelerationStructureGeometrySpheresDataNV();
+    ~safe_VkAccelerationStructureGeometrySpheresDataNV();
+    void initialize(const VkAccelerationStructureGeometrySpheresDataNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAccelerationStructureGeometrySpheresDataNV* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureGeometrySpheresDataNV* ptr() {
+        return reinterpret_cast<VkAccelerationStructureGeometrySpheresDataNV*>(this);
+    }
+    VkAccelerationStructureGeometrySpheresDataNV const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureGeometrySpheresDataNV const*>(this);
+    }
+};
 struct safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV {
     VkStructureType sType;
     void* pNext{};
@@ -18195,6 +18280,101 @@ struct safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV {
         return reinterpret_cast<VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV const*>(this);
     }
 };
+struct safe_VkPhysicalDeviceCooperativeVectorPropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkShaderStageFlags cooperativeVectorSupportedStages;
+    VkBool32 cooperativeVectorTrainingFloat16Accumulation;
+    VkBool32 cooperativeVectorTrainingFloat32Accumulation;
+    uint32_t maxCooperativeVectorComponents;
+
+    safe_VkPhysicalDeviceCooperativeVectorPropertiesNV(const VkPhysicalDeviceCooperativeVectorPropertiesNV* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceCooperativeVectorPropertiesNV(const safe_VkPhysicalDeviceCooperativeVectorPropertiesNV& copy_src);
+    safe_VkPhysicalDeviceCooperativeVectorPropertiesNV& operator=(
+        const safe_VkPhysicalDeviceCooperativeVectorPropertiesNV& copy_src);
+    safe_VkPhysicalDeviceCooperativeVectorPropertiesNV();
+    ~safe_VkPhysicalDeviceCooperativeVectorPropertiesNV();
+    void initialize(const VkPhysicalDeviceCooperativeVectorPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceCooperativeVectorPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCooperativeVectorPropertiesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceCooperativeVectorPropertiesNV*>(this);
+    }
+    VkPhysicalDeviceCooperativeVectorPropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCooperativeVectorPropertiesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceCooperativeVectorFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 cooperativeVector;
+    VkBool32 cooperativeVectorTraining;
+
+    safe_VkPhysicalDeviceCooperativeVectorFeaturesNV(const VkPhysicalDeviceCooperativeVectorFeaturesNV* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceCooperativeVectorFeaturesNV(const safe_VkPhysicalDeviceCooperativeVectorFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceCooperativeVectorFeaturesNV& operator=(const safe_VkPhysicalDeviceCooperativeVectorFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceCooperativeVectorFeaturesNV();
+    ~safe_VkPhysicalDeviceCooperativeVectorFeaturesNV();
+    void initialize(const VkPhysicalDeviceCooperativeVectorFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceCooperativeVectorFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceCooperativeVectorFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceCooperativeVectorFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceCooperativeVectorFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceCooperativeVectorFeaturesNV const*>(this);
+    }
+};
+struct safe_VkCooperativeVectorPropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkComponentTypeKHR inputType;
+    VkComponentTypeKHR inputInterpretation;
+    VkComponentTypeKHR matrixInterpretation;
+    VkComponentTypeKHR biasInterpretation;
+    VkComponentTypeKHR resultType;
+    VkBool32 transpose;
+
+    safe_VkCooperativeVectorPropertiesNV(const VkCooperativeVectorPropertiesNV* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkCooperativeVectorPropertiesNV(const safe_VkCooperativeVectorPropertiesNV& copy_src);
+    safe_VkCooperativeVectorPropertiesNV& operator=(const safe_VkCooperativeVectorPropertiesNV& copy_src);
+    safe_VkCooperativeVectorPropertiesNV();
+    ~safe_VkCooperativeVectorPropertiesNV();
+    void initialize(const VkCooperativeVectorPropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCooperativeVectorPropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkCooperativeVectorPropertiesNV* ptr() { return reinterpret_cast<VkCooperativeVectorPropertiesNV*>(this); }
+    VkCooperativeVectorPropertiesNV const* ptr() const { return reinterpret_cast<VkCooperativeVectorPropertiesNV const*>(this); }
+};
+struct safe_VkConvertCooperativeVectorMatrixInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    size_t srcSize;
+    safe_VkDeviceOrHostAddressConstKHR srcData;
+    size_t* pDstSize{};
+    safe_VkDeviceOrHostAddressKHR dstData;
+    VkComponentTypeKHR srcComponentType;
+    VkComponentTypeKHR dstComponentType;
+    uint32_t numRows;
+    uint32_t numColumns;
+    VkCooperativeVectorMatrixLayoutNV srcLayout;
+    size_t srcStride;
+    VkCooperativeVectorMatrixLayoutNV dstLayout;
+    size_t dstStride;
+
+    safe_VkConvertCooperativeVectorMatrixInfoNV(const VkConvertCooperativeVectorMatrixInfoNV* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkConvertCooperativeVectorMatrixInfoNV(const safe_VkConvertCooperativeVectorMatrixInfoNV& copy_src);
+    safe_VkConvertCooperativeVectorMatrixInfoNV& operator=(const safe_VkConvertCooperativeVectorMatrixInfoNV& copy_src);
+    safe_VkConvertCooperativeVectorMatrixInfoNV();
+    ~safe_VkConvertCooperativeVectorMatrixInfoNV();
+    void initialize(const VkConvertCooperativeVectorMatrixInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkConvertCooperativeVectorMatrixInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkConvertCooperativeVectorMatrixInfoNV* ptr() { return reinterpret_cast<VkConvertCooperativeVectorMatrixInfoNV*>(this); }
+    VkConvertCooperativeVectorMatrixInfoNV const* ptr() const {
+        return reinterpret_cast<VkConvertCooperativeVectorMatrixInfoNV const*>(this);
+    }
+};
 struct safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV {
     VkStructureType sType;
     void* pNext{};
@@ -19118,6 +19298,388 @@ struct safe_VkPhysicalDeviceRayTracingValidationFeaturesNV {
         return reinterpret_cast<VkPhysicalDeviceRayTracingValidationFeaturesNV const*>(this);
     }
 };
+struct safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 clusterAccelerationStructure;
+
+    safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV(
+        const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV(
+        const safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV& operator=(
+        const safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV& copy_src);
+    safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV();
+    ~safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV();
+    void initialize(const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceClusterAccelerationStructureFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceClusterAccelerationStructureFeaturesNV*>(this);
+    }
+    VkPhysicalDeviceClusterAccelerationStructureFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceClusterAccelerationStructureFeaturesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxVerticesPerCluster;
+    uint32_t maxTrianglesPerCluster;
+    uint32_t clusterScratchByteAlignment;
+    uint32_t clusterByteAlignment;
+    uint32_t clusterTemplateByteAlignment;
+    uint32_t clusterBottomLevelByteAlignment;
+    uint32_t clusterTemplateBoundsByteAlignment;
+    uint32_t maxClusterGeometryIndex;
+
+    safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV(
+        const VkPhysicalDeviceClusterAccelerationStructurePropertiesNV* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV(
+        const safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV& copy_src);
+    safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV& operator=(
+        const safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV& copy_src);
+    safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV();
+    ~safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV();
+    void initialize(const VkPhysicalDeviceClusterAccelerationStructurePropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceClusterAccelerationStructurePropertiesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceClusterAccelerationStructurePropertiesNV*>(this);
+    }
+    VkPhysicalDeviceClusterAccelerationStructurePropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceClusterAccelerationStructurePropertiesNV const*>(this);
+    }
+};
+struct safe_VkClusterAccelerationStructureClustersBottomLevelInputNV {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxTotalClusterCount;
+    uint32_t maxClusterCountPerAccelerationStructure;
+
+    safe_VkClusterAccelerationStructureClustersBottomLevelInputNV(
+        const VkClusterAccelerationStructureClustersBottomLevelInputNV* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkClusterAccelerationStructureClustersBottomLevelInputNV(
+        const safe_VkClusterAccelerationStructureClustersBottomLevelInputNV& copy_src);
+    safe_VkClusterAccelerationStructureClustersBottomLevelInputNV& operator=(
+        const safe_VkClusterAccelerationStructureClustersBottomLevelInputNV& copy_src);
+    safe_VkClusterAccelerationStructureClustersBottomLevelInputNV();
+    ~safe_VkClusterAccelerationStructureClustersBottomLevelInputNV();
+    void initialize(const VkClusterAccelerationStructureClustersBottomLevelInputNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkClusterAccelerationStructureClustersBottomLevelInputNV* copy_src, PNextCopyState* copy_state = {});
+    VkClusterAccelerationStructureClustersBottomLevelInputNV* ptr() {
+        return reinterpret_cast<VkClusterAccelerationStructureClustersBottomLevelInputNV*>(this);
+    }
+    VkClusterAccelerationStructureClustersBottomLevelInputNV const* ptr() const {
+        return reinterpret_cast<VkClusterAccelerationStructureClustersBottomLevelInputNV const*>(this);
+    }
+};
+struct safe_VkClusterAccelerationStructureTriangleClusterInputNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkFormat vertexFormat;
+    uint32_t maxGeometryIndexValue;
+    uint32_t maxClusterUniqueGeometryCount;
+    uint32_t maxClusterTriangleCount;
+    uint32_t maxClusterVertexCount;
+    uint32_t maxTotalTriangleCount;
+    uint32_t maxTotalVertexCount;
+    uint32_t minPositionTruncateBitCount;
+
+    safe_VkClusterAccelerationStructureTriangleClusterInputNV(const VkClusterAccelerationStructureTriangleClusterInputNV* in_struct,
+                                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkClusterAccelerationStructureTriangleClusterInputNV(
+        const safe_VkClusterAccelerationStructureTriangleClusterInputNV& copy_src);
+    safe_VkClusterAccelerationStructureTriangleClusterInputNV& operator=(
+        const safe_VkClusterAccelerationStructureTriangleClusterInputNV& copy_src);
+    safe_VkClusterAccelerationStructureTriangleClusterInputNV();
+    ~safe_VkClusterAccelerationStructureTriangleClusterInputNV();
+    void initialize(const VkClusterAccelerationStructureTriangleClusterInputNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkClusterAccelerationStructureTriangleClusterInputNV* copy_src, PNextCopyState* copy_state = {});
+    VkClusterAccelerationStructureTriangleClusterInputNV* ptr() {
+        return reinterpret_cast<VkClusterAccelerationStructureTriangleClusterInputNV*>(this);
+    }
+    VkClusterAccelerationStructureTriangleClusterInputNV const* ptr() const {
+        return reinterpret_cast<VkClusterAccelerationStructureTriangleClusterInputNV const*>(this);
+    }
+};
+struct safe_VkClusterAccelerationStructureMoveObjectsInputNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkClusterAccelerationStructureTypeNV type;
+    VkBool32 noMoveOverlap;
+    VkDeviceSize maxMovedBytes;
+
+    safe_VkClusterAccelerationStructureMoveObjectsInputNV(const VkClusterAccelerationStructureMoveObjectsInputNV* in_struct,
+                                                          PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkClusterAccelerationStructureMoveObjectsInputNV(const safe_VkClusterAccelerationStructureMoveObjectsInputNV& copy_src);
+    safe_VkClusterAccelerationStructureMoveObjectsInputNV& operator=(
+        const safe_VkClusterAccelerationStructureMoveObjectsInputNV& copy_src);
+    safe_VkClusterAccelerationStructureMoveObjectsInputNV();
+    ~safe_VkClusterAccelerationStructureMoveObjectsInputNV();
+    void initialize(const VkClusterAccelerationStructureMoveObjectsInputNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkClusterAccelerationStructureMoveObjectsInputNV* copy_src, PNextCopyState* copy_state = {});
+    VkClusterAccelerationStructureMoveObjectsInputNV* ptr() {
+        return reinterpret_cast<VkClusterAccelerationStructureMoveObjectsInputNV*>(this);
+    }
+    VkClusterAccelerationStructureMoveObjectsInputNV const* ptr() const {
+        return reinterpret_cast<VkClusterAccelerationStructureMoveObjectsInputNV const*>(this);
+    }
+};
+union safe_VkClusterAccelerationStructureOpInputNV {
+    safe_VkClusterAccelerationStructureClustersBottomLevelInputNV* pClustersBottomLevel;
+    safe_VkClusterAccelerationStructureTriangleClusterInputNV* pTriangleClusters;
+    safe_VkClusterAccelerationStructureMoveObjectsInputNV* pMoveObjects;
+
+    safe_VkClusterAccelerationStructureOpInputNV(const VkClusterAccelerationStructureOpInputNV* in_struct,
+                                                 PNextCopyState* copy_state = {});
+    safe_VkClusterAccelerationStructureOpInputNV(const safe_VkClusterAccelerationStructureOpInputNV& copy_src);
+    safe_VkClusterAccelerationStructureOpInputNV& operator=(const safe_VkClusterAccelerationStructureOpInputNV& copy_src);
+    safe_VkClusterAccelerationStructureOpInputNV();
+    ~safe_VkClusterAccelerationStructureOpInputNV();
+    void initialize(const VkClusterAccelerationStructureOpInputNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkClusterAccelerationStructureOpInputNV* copy_src, PNextCopyState* copy_state = {});
+    VkClusterAccelerationStructureOpInputNV* ptr() { return reinterpret_cast<VkClusterAccelerationStructureOpInputNV*>(this); }
+    VkClusterAccelerationStructureOpInputNV const* ptr() const {
+        return reinterpret_cast<VkClusterAccelerationStructureOpInputNV const*>(this);
+    }
+};
+struct safe_VkClusterAccelerationStructureInputInfoNV {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxAccelerationStructureCount;
+    VkBuildAccelerationStructureFlagsKHR flags;
+    VkClusterAccelerationStructureOpTypeNV opType;
+    VkClusterAccelerationStructureOpModeNV opMode;
+    safe_VkClusterAccelerationStructureOpInputNV opInput;
+
+    safe_VkClusterAccelerationStructureInputInfoNV(const VkClusterAccelerationStructureInputInfoNV* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkClusterAccelerationStructureInputInfoNV(const safe_VkClusterAccelerationStructureInputInfoNV& copy_src);
+    safe_VkClusterAccelerationStructureInputInfoNV& operator=(const safe_VkClusterAccelerationStructureInputInfoNV& copy_src);
+    safe_VkClusterAccelerationStructureInputInfoNV();
+    ~safe_VkClusterAccelerationStructureInputInfoNV();
+    void initialize(const VkClusterAccelerationStructureInputInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkClusterAccelerationStructureInputInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkClusterAccelerationStructureInputInfoNV* ptr() { return reinterpret_cast<VkClusterAccelerationStructureInputInfoNV*>(this); }
+    VkClusterAccelerationStructureInputInfoNV const* ptr() const {
+        return reinterpret_cast<VkClusterAccelerationStructureInputInfoNV const*>(this);
+    }
+};
+struct safe_VkClusterAccelerationStructureCommandsInfoNV {
+    VkStructureType sType;
+    void* pNext{};
+    safe_VkClusterAccelerationStructureInputInfoNV input;
+    VkDeviceAddress dstImplicitData;
+    VkDeviceAddress scratchData;
+    VkStridedDeviceAddressRegionKHR dstAddressesArray;
+    VkStridedDeviceAddressRegionKHR dstSizesArray;
+    VkStridedDeviceAddressRegionKHR srcInfosArray;
+    VkDeviceAddress srcInfosCount;
+    VkClusterAccelerationStructureAddressResolutionFlagsNV addressResolutionFlags;
+
+    safe_VkClusterAccelerationStructureCommandsInfoNV(const VkClusterAccelerationStructureCommandsInfoNV* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkClusterAccelerationStructureCommandsInfoNV(const safe_VkClusterAccelerationStructureCommandsInfoNV& copy_src);
+    safe_VkClusterAccelerationStructureCommandsInfoNV& operator=(const safe_VkClusterAccelerationStructureCommandsInfoNV& copy_src);
+    safe_VkClusterAccelerationStructureCommandsInfoNV();
+    ~safe_VkClusterAccelerationStructureCommandsInfoNV();
+    void initialize(const VkClusterAccelerationStructureCommandsInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkClusterAccelerationStructureCommandsInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkClusterAccelerationStructureCommandsInfoNV* ptr() {
+        return reinterpret_cast<VkClusterAccelerationStructureCommandsInfoNV*>(this);
+    }
+    VkClusterAccelerationStructureCommandsInfoNV const* ptr() const {
+        return reinterpret_cast<VkClusterAccelerationStructureCommandsInfoNV const*>(this);
+    }
+};
+struct safe_VkAccelerationStructureBuildSizesInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceSize accelerationStructureSize;
+    VkDeviceSize updateScratchSize;
+    VkDeviceSize buildScratchSize;
+
+    safe_VkAccelerationStructureBuildSizesInfoKHR(const VkAccelerationStructureBuildSizesInfoKHR* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkAccelerationStructureBuildSizesInfoKHR(const safe_VkAccelerationStructureBuildSizesInfoKHR& copy_src);
+    safe_VkAccelerationStructureBuildSizesInfoKHR& operator=(const safe_VkAccelerationStructureBuildSizesInfoKHR& copy_src);
+    safe_VkAccelerationStructureBuildSizesInfoKHR();
+    ~safe_VkAccelerationStructureBuildSizesInfoKHR();
+    void initialize(const VkAccelerationStructureBuildSizesInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAccelerationStructureBuildSizesInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkAccelerationStructureBuildSizesInfoKHR* ptr() { return reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR*>(this); }
+    VkAccelerationStructureBuildSizesInfoKHR const* ptr() const {
+        return reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR const*>(this);
+    }
+};
+struct safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 allowClusterAccelerationStructure;
+
+    safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV(
+        const VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV(
+        const safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV& copy_src);
+    safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV& operator=(
+        const safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV& copy_src);
+    safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV();
+    ~safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV();
+    void initialize(const VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV* copy_src,
+                    PNextCopyState* copy_state = {});
+    VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV* ptr() {
+        return reinterpret_cast<VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV*>(this);
+    }
+    VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 partitionedAccelerationStructure;
+
+    safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV(
+        const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV(
+        const safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV& copy_src);
+    safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV& operator=(
+        const safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV& copy_src);
+    safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV();
+    ~safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV();
+    void initialize(const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV* copy_src,
+                    PNextCopyState* copy_state = {});
+    VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV*>(this);
+    }
+    VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxPartitionCount;
+
+    safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV(
+        const VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV(
+        const safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV& copy_src);
+    safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV& operator=(
+        const safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV& copy_src);
+    safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV();
+    ~safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV();
+    void initialize(const VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV* copy_src,
+                    PNextCopyState* copy_state = {});
+    VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV*>(this);
+    }
+    VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV const*>(this);
+    }
+};
+struct safe_VkPartitionedAccelerationStructureFlagsNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 enablePartitionTranslation;
+
+    safe_VkPartitionedAccelerationStructureFlagsNV(const VkPartitionedAccelerationStructureFlagsNV* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPartitionedAccelerationStructureFlagsNV(const safe_VkPartitionedAccelerationStructureFlagsNV& copy_src);
+    safe_VkPartitionedAccelerationStructureFlagsNV& operator=(const safe_VkPartitionedAccelerationStructureFlagsNV& copy_src);
+    safe_VkPartitionedAccelerationStructureFlagsNV();
+    ~safe_VkPartitionedAccelerationStructureFlagsNV();
+    void initialize(const VkPartitionedAccelerationStructureFlagsNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPartitionedAccelerationStructureFlagsNV* copy_src, PNextCopyState* copy_state = {});
+    VkPartitionedAccelerationStructureFlagsNV* ptr() { return reinterpret_cast<VkPartitionedAccelerationStructureFlagsNV*>(this); }
+    VkPartitionedAccelerationStructureFlagsNV const* ptr() const {
+        return reinterpret_cast<VkPartitionedAccelerationStructureFlagsNV const*>(this);
+    }
+};
+struct safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t accelerationStructureCount;
+    const VkDeviceAddress* pAccelerationStructures{};
+
+    safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV(
+        const VkWriteDescriptorSetPartitionedAccelerationStructureNV* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV(
+        const safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV& copy_src);
+    safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV& operator=(
+        const safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV& copy_src);
+    safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV();
+    ~safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV();
+    void initialize(const VkWriteDescriptorSetPartitionedAccelerationStructureNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV* copy_src, PNextCopyState* copy_state = {});
+    VkWriteDescriptorSetPartitionedAccelerationStructureNV* ptr() {
+        return reinterpret_cast<VkWriteDescriptorSetPartitionedAccelerationStructureNV*>(this);
+    }
+    VkWriteDescriptorSetPartitionedAccelerationStructureNV const* ptr() const {
+        return reinterpret_cast<VkWriteDescriptorSetPartitionedAccelerationStructureNV const*>(this);
+    }
+};
+struct safe_VkPartitionedAccelerationStructureInstancesInputNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBuildAccelerationStructureFlagsKHR flags;
+    uint32_t instanceCount;
+    uint32_t maxInstancePerPartitionCount;
+    uint32_t partitionCount;
+    uint32_t maxInstanceInGlobalPartitionCount;
+
+    safe_VkPartitionedAccelerationStructureInstancesInputNV(const VkPartitionedAccelerationStructureInstancesInputNV* in_struct,
+                                                            PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPartitionedAccelerationStructureInstancesInputNV(
+        const safe_VkPartitionedAccelerationStructureInstancesInputNV& copy_src);
+    safe_VkPartitionedAccelerationStructureInstancesInputNV& operator=(
+        const safe_VkPartitionedAccelerationStructureInstancesInputNV& copy_src);
+    safe_VkPartitionedAccelerationStructureInstancesInputNV();
+    ~safe_VkPartitionedAccelerationStructureInstancesInputNV();
+    void initialize(const VkPartitionedAccelerationStructureInstancesInputNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPartitionedAccelerationStructureInstancesInputNV* copy_src, PNextCopyState* copy_state = {});
+    VkPartitionedAccelerationStructureInstancesInputNV* ptr() {
+        return reinterpret_cast<VkPartitionedAccelerationStructureInstancesInputNV*>(this);
+    }
+    VkPartitionedAccelerationStructureInstancesInputNV const* ptr() const {
+        return reinterpret_cast<VkPartitionedAccelerationStructureInstancesInputNV const*>(this);
+    }
+};
+struct safe_VkBuildPartitionedAccelerationStructureInfoNV {
+    VkStructureType sType;
+    void* pNext{};
+    safe_VkPartitionedAccelerationStructureInstancesInputNV input;
+    VkDeviceAddress srcAccelerationStructureData;
+    VkDeviceAddress dstAccelerationStructureData;
+    VkDeviceAddress scratchData;
+    VkDeviceAddress srcInfos;
+    VkDeviceAddress srcInfosCount;
+
+    safe_VkBuildPartitionedAccelerationStructureInfoNV(const VkBuildPartitionedAccelerationStructureInfoNV* in_struct,
+                                                       PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkBuildPartitionedAccelerationStructureInfoNV(const safe_VkBuildPartitionedAccelerationStructureInfoNV& copy_src);
+    safe_VkBuildPartitionedAccelerationStructureInfoNV& operator=(
+        const safe_VkBuildPartitionedAccelerationStructureInfoNV& copy_src);
+    safe_VkBuildPartitionedAccelerationStructureInfoNV();
+    ~safe_VkBuildPartitionedAccelerationStructureInfoNV();
+    void initialize(const VkBuildPartitionedAccelerationStructureInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBuildPartitionedAccelerationStructureInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkBuildPartitionedAccelerationStructureInfoNV* ptr() {
+        return reinterpret_cast<VkBuildPartitionedAccelerationStructureInfoNV*>(this);
+    }
+    VkBuildPartitionedAccelerationStructureInfoNV const* ptr() const {
+        return reinterpret_cast<VkBuildPartitionedAccelerationStructureInfoNV const*>(this);
+    }
+};
 struct safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT {
     VkStructureType sType;
     void* pNext{};
@@ -20052,26 +20614,6 @@ struct safe_VkCopyAccelerationStructureInfoKHR {
         return reinterpret_cast<VkCopyAccelerationStructureInfoKHR const*>(this);
     }
 };
-struct safe_VkAccelerationStructureBuildSizesInfoKHR {
-    VkStructureType sType;
-    const void* pNext{};
-    VkDeviceSize accelerationStructureSize;
-    VkDeviceSize updateScratchSize;
-    VkDeviceSize buildScratchSize;
-
-    safe_VkAccelerationStructureBuildSizesInfoKHR(const VkAccelerationStructureBuildSizesInfoKHR* in_struct,
-                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkAccelerationStructureBuildSizesInfoKHR(const safe_VkAccelerationStructureBuildSizesInfoKHR& copy_src);
-    safe_VkAccelerationStructureBuildSizesInfoKHR& operator=(const safe_VkAccelerationStructureBuildSizesInfoKHR& copy_src);
-    safe_VkAccelerationStructureBuildSizesInfoKHR();
-    ~safe_VkAccelerationStructureBuildSizesInfoKHR();
-    void initialize(const VkAccelerationStructureBuildSizesInfoKHR* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkAccelerationStructureBuildSizesInfoKHR* copy_src, PNextCopyState* copy_state = {});
-    VkAccelerationStructureBuildSizesInfoKHR* ptr() { return reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR*>(this); }
-    VkAccelerationStructureBuildSizesInfoKHR const* ptr() const {
-        return reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR const*>(this);
-    }
-};
 struct safe_VkRayTracingShaderGroupCreateInfoKHR {
     VkStructureType sType;
     const void* pNext{};
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index 02b77e0..ea915c6 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -905,6 +905,9 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceMemoryDecompressionP
 template <> inline VkStructureType GetSType<VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkComputePipelineIndirectBufferInfoNV>() { return VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV; }
 template <> inline VkStructureType GetSType<VkPipelineIndirectDeviceAddressInfoNV>() { return VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV; }
+template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryLinearSweptSpheresDataNV>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV; }
+template <> inline VkStructureType GetSType<VkAccelerationStructureGeometrySpheresDataNV>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceLinearColorAttachmentFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkImageViewSampleWeightCreateInfoQCOM>() { return VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM; }
@@ -951,6 +954,10 @@ template <> inline VkStructureType GetSType<VkAmigoProfilingSubmitInfoSEC>() { r
 template <> inline VkStructureType GetSType<VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeVectorPropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceCooperativeVectorFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV; }
+template <> inline VkStructureType GetSType<VkCooperativeVectorPropertiesNV>() { return VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV; }
+template <> inline VkStructureType GetSType<VkConvertCooperativeVectorMatrixInfoNV>() { return VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT; }
@@ -998,6 +1005,21 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceCommandBufferInherit
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingValidationFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceClusterAccelerationStructureFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceClusterAccelerationStructurePropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV; }
+template <> inline VkStructureType GetSType<VkClusterAccelerationStructureClustersBottomLevelInputNV>() { return VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV; }
+template <> inline VkStructureType GetSType<VkClusterAccelerationStructureTriangleClusterInputNV>() { return VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV; }
+template <> inline VkStructureType GetSType<VkClusterAccelerationStructureMoveObjectsInputNV>() { return VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV; }
+template <> inline VkStructureType GetSType<VkClusterAccelerationStructureInputInfoNV>() { return VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV; }
+template <> inline VkStructureType GetSType<VkClusterAccelerationStructureCommandsInfoNV>() { return VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV; }
+template <> inline VkStructureType GetSType<VkAccelerationStructureBuildSizesInfoKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV>() { return VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV; }
+template <> inline VkStructureType GetSType<VkPartitionedAccelerationStructureFlagsNV>() { return VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV; }
+template <> inline VkStructureType GetSType<VkWriteDescriptorSetPartitionedAccelerationStructureNV>() { return VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV; }
+template <> inline VkStructureType GetSType<VkPartitionedAccelerationStructureInstancesInputNV>() { return VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV; }
+template <> inline VkStructureType GetSType<VkBuildPartitionedAccelerationStructureInfoNV>() { return VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT; }
 template <> inline VkStructureType GetSType<VkGeneratedCommandsMemoryRequirementsInfoEXT>() { return VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT; }
@@ -1043,7 +1065,6 @@ template <> inline VkStructureType GetSType<VkAccelerationStructureVersionInfoKH
 template <> inline VkStructureType GetSType<VkCopyAccelerationStructureToMemoryInfoKHR>() { return VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkCopyMemoryToAccelerationStructureInfoKHR>() { return VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkCopyAccelerationStructureInfoKHR>() { return VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR; }
-template <> inline VkStructureType GetSType<VkAccelerationStructureBuildSizesInfoKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkRayTracingShaderGroupCreateInfoKHR>() { return VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkRayTracingPipelineInterfaceCreateInfoKHR>() { return VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkRayTracingPipelineCreateInfoKHR>() { return VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index aa1dfbf..3e3b6bd 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -1722,6 +1722,12 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV";
         case VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV:
             return "VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV";
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV:
+            return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV";
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV:
+            return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR:
@@ -1836,6 +1842,14 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV";
+        case VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV:
+            return "VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV";
+        case VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV:
+            return "VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV:
@@ -2014,6 +2028,34 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV";
+        case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV:
+            return "VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV";
+        case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV:
+            return "VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV";
+        case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV:
+            return "VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV";
+        case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV:
+            return "VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV";
+        case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV:
+            return "VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV";
+        case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV:
+            return "VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV";
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV:
+            return "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV";
+        case VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV:
+            return "VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV";
+        case VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV:
+            return "VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV";
+        case VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV:
+            return "VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT:
@@ -3504,6 +3546,8 @@ static inline const char* string_VkDescriptorType(VkDescriptorType input_value)
             return "VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM";
         case VK_DESCRIPTOR_TYPE_MUTABLE_EXT:
             return "VK_DESCRIPTOR_TYPE_MUTABLE_EXT";
+        case VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV:
+            return "VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV";
         default:
             return "Unhandled VkDescriptorType";
     }
@@ -4006,6 +4050,14 @@ static inline const char* string_VkComponentTypeKHR(VkComponentTypeKHR input_val
             return "VK_COMPONENT_TYPE_UINT32_KHR";
         case VK_COMPONENT_TYPE_UINT64_KHR:
             return "VK_COMPONENT_TYPE_UINT64_KHR";
+        case VK_COMPONENT_TYPE_SINT8_PACKED_NV:
+            return "VK_COMPONENT_TYPE_SINT8_PACKED_NV";
+        case VK_COMPONENT_TYPE_UINT8_PACKED_NV:
+            return "VK_COMPONENT_TYPE_UINT8_PACKED_NV";
+        case VK_COMPONENT_TYPE_FLOAT_E4M3_NV:
+            return "VK_COMPONENT_TYPE_FLOAT_E4M3_NV";
+        case VK_COMPONENT_TYPE_FLOAT_E5M2_NV:
+            return "VK_COMPONENT_TYPE_FLOAT_E5M2_NV";
         default:
             return "Unhandled VkComponentTypeKHR";
     }
@@ -4370,6 +4422,10 @@ static inline const char* string_VkGeometryTypeKHR(VkGeometryTypeKHR input_value
             return "VK_GEOMETRY_TYPE_AABBS_KHR";
         case VK_GEOMETRY_TYPE_INSTANCES_KHR:
             return "VK_GEOMETRY_TYPE_INSTANCES_KHR";
+        case VK_GEOMETRY_TYPE_SPHERES_NV:
+            return "VK_GEOMETRY_TYPE_SPHERES_NV";
+        case VK_GEOMETRY_TYPE_LINEAR_SWEPT_SPHERES_NV:
+            return "VK_GEOMETRY_TYPE_LINEAR_SWEPT_SPHERES_NV";
         default:
             return "Unhandled VkGeometryTypeKHR";
     }
@@ -4750,6 +4806,8 @@ static inline const char* string_VkOpacityMicromapSpecialIndexEXT(VkOpacityMicro
             return "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT";
         case VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT:
             return "VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT";
+        case VK_OPACITY_MICROMAP_SPECIAL_INDEX_CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV:
+            return "VK_OPACITY_MICROMAP_SPECIAL_INDEX_CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV";
         default:
             return "Unhandled VkOpacityMicromapSpecialIndexEXT";
     }
@@ -4790,6 +4848,26 @@ static inline const char* string_VkDisplacementMicromapFormatNV(VkDisplacementMi
     }
 }
 #endif  // VK_ENABLE_BETA_EXTENSIONS
+static inline const char* string_VkRayTracingLssIndexingModeNV(VkRayTracingLssIndexingModeNV input_value) {
+    switch (input_value) {
+        case VK_RAY_TRACING_LSS_INDEXING_MODE_LIST_NV:
+            return "VK_RAY_TRACING_LSS_INDEXING_MODE_LIST_NV";
+        case VK_RAY_TRACING_LSS_INDEXING_MODE_SUCCESSIVE_NV:
+            return "VK_RAY_TRACING_LSS_INDEXING_MODE_SUCCESSIVE_NV";
+        default:
+            return "Unhandled VkRayTracingLssIndexingModeNV";
+    }
+}
+static inline const char* string_VkRayTracingLssPrimitiveEndCapsModeNV(VkRayTracingLssPrimitiveEndCapsModeNV input_value) {
+    switch (input_value) {
+        case VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_NONE_NV:
+            return "VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_NONE_NV";
+        case VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_CHAINED_NV:
+            return "VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_CHAINED_NV";
+        default:
+            return "Unhandled VkRayTracingLssPrimitiveEndCapsModeNV";
+    }
+}
 static inline const char* string_VkSubpassMergeStatusEXT(VkSubpassMergeStatusEXT input_value) {
     switch (input_value) {
         case VK_SUBPASS_MERGE_STATUS_MERGED_EXT:
@@ -4924,6 +5002,20 @@ static inline const char* string_VkRayTracingInvocationReorderModeNV(VkRayTracin
             return "Unhandled VkRayTracingInvocationReorderModeNV";
     }
 }
+static inline const char* string_VkCooperativeVectorMatrixLayoutNV(VkCooperativeVectorMatrixLayoutNV input_value) {
+    switch (input_value) {
+        case VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_ROW_MAJOR_NV:
+            return "VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_ROW_MAJOR_NV";
+        case VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_COLUMN_MAJOR_NV:
+            return "VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_COLUMN_MAJOR_NV";
+        case VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_INFERENCING_OPTIMAL_NV:
+            return "VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_INFERENCING_OPTIMAL_NV";
+        case VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_TRAINING_OPTIMAL_NV:
+            return "VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_TRAINING_OPTIMAL_NV";
+        default:
+            return "Unhandled VkCooperativeVectorMatrixLayoutNV";
+    }
+}
 static inline const char* string_VkLayerSettingTypeEXT(VkLayerSettingTypeEXT input_value) {
     switch (input_value) {
         case VK_LAYER_SETTING_TYPE_BOOL32_EXT:
@@ -5034,6 +5126,58 @@ static inline const char* string_VkDisplaySurfaceStereoTypeNV(VkDisplaySurfaceSt
             return "Unhandled VkDisplaySurfaceStereoTypeNV";
     }
 }
+static inline const char* string_VkClusterAccelerationStructureTypeNV(VkClusterAccelerationStructureTypeNV input_value) {
+    switch (input_value) {
+        case VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_CLUSTERS_BOTTOM_LEVEL_NV:
+            return "VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_CLUSTERS_BOTTOM_LEVEL_NV";
+        case VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_NV:
+            return "VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_NV";
+        case VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_TEMPLATE_NV:
+            return "VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_TEMPLATE_NV";
+        default:
+            return "Unhandled VkClusterAccelerationStructureTypeNV";
+    }
+}
+static inline const char* string_VkClusterAccelerationStructureOpTypeNV(VkClusterAccelerationStructureOpTypeNV input_value) {
+    switch (input_value) {
+        case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_MOVE_OBJECTS_NV:
+            return "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_MOVE_OBJECTS_NV";
+        case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_CLUSTERS_BOTTOM_LEVEL_NV:
+            return "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_CLUSTERS_BOTTOM_LEVEL_NV";
+        case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_NV:
+            return "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_NV";
+        case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_TEMPLATE_NV:
+            return "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_TEMPLATE_NV";
+        case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_INSTANTIATE_TRIANGLE_CLUSTER_NV:
+            return "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_INSTANTIATE_TRIANGLE_CLUSTER_NV";
+        default:
+            return "Unhandled VkClusterAccelerationStructureOpTypeNV";
+    }
+}
+static inline const char* string_VkClusterAccelerationStructureOpModeNV(VkClusterAccelerationStructureOpModeNV input_value) {
+    switch (input_value) {
+        case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_IMPLICIT_DESTINATIONS_NV:
+            return "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_IMPLICIT_DESTINATIONS_NV";
+        case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_EXPLICIT_DESTINATIONS_NV:
+            return "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_EXPLICIT_DESTINATIONS_NV";
+        case VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_COMPUTE_SIZES_NV:
+            return "VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_COMPUTE_SIZES_NV";
+        default:
+            return "Unhandled VkClusterAccelerationStructureOpModeNV";
+    }
+}
+static inline const char* string_VkPartitionedAccelerationStructureOpTypeNV(VkPartitionedAccelerationStructureOpTypeNV input_value) {
+    switch (input_value) {
+        case VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_INSTANCE_NV:
+            return "VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_INSTANCE_NV";
+        case VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_UPDATE_INSTANCE_NV:
+            return "VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_UPDATE_INSTANCE_NV";
+        case VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_PARTITION_TRANSLATION_NV:
+            return "VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_PARTITION_TRANSLATION_NV";
+        default:
+            return "Unhandled VkPartitionedAccelerationStructureOpTypeNV";
+    }
+}
 static inline const char* string_VkIndirectExecutionSetInfoTypeEXT(VkIndirectExecutionSetInfoTypeEXT input_value) {
     switch (input_value) {
         case VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT:
@@ -7385,6 +7529,7 @@ static inline const char* string_VkPipelineStageFlagBits2(uint64_t input_value)
     if (input_value == VK_PIPELINE_STAGE_2_MICROMAP_BUILD_BIT_EXT) return "VK_PIPELINE_STAGE_2_MICROMAP_BUILD_BIT_EXT";
     if (input_value == VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI) return "VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI";
     if (input_value == VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV) return "VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV";
+    if (input_value == VK_PIPELINE_STAGE_2_CONVERT_COOPERATIVE_VECTOR_MATRIX_BIT_NV) return "VK_PIPELINE_STAGE_2_CONVERT_COOPERATIVE_VECTOR_MATRIX_BIT_NV";
     return "Unhandled VkPipelineStageFlagBits2";
 }
 
@@ -7561,6 +7706,7 @@ static inline const char* string_VkFormatFeatureFlagBits2(uint64_t input_value)
     if (input_value == VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR) return "VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR";
     if (input_value == VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR) return "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR";
     if (input_value == VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR) return "VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR";
+    if (input_value == VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV) return "VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV";
     if (input_value == VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV) return "VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV";
     if (input_value == VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM) return "VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM";
     if (input_value == VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM) return "VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM";
@@ -7628,6 +7774,7 @@ static inline const char* string_VkPipelineCreateFlagBits2(uint64_t input_value)
 #ifdef VK_ENABLE_BETA_EXTENSIONS
     if (input_value == VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX) return "VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX";
 #endif  // VK_ENABLE_BETA_EXTENSIONS
+    if (input_value == VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES_BIT_NV) return "VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES_BIT_NV";
     if (input_value == VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT) return "VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT";
     if (input_value == VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV) return "VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV";
     if (input_value == VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR) return "VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR";
@@ -9885,6 +10032,157 @@ static inline std::string string_VkShaderCreateFlagsEXT(VkShaderCreateFlagsEXT i
     return ret;
 }
 #endif // __cplusplus
+static inline const char* string_VkClusterAccelerationStructureAddressResolutionFlagBitsNV(VkClusterAccelerationStructureAddressResolutionFlagBitsNV input_value) {
+    switch (input_value) {
+        case VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_IMPLICIT_DATA_BIT_NV:
+            return "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_IMPLICIT_DATA_BIT_NV";
+        case VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SCRATCH_DATA_BIT_NV:
+            return "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SCRATCH_DATA_BIT_NV";
+        case VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_ADDRESS_ARRAY_BIT_NV:
+            return "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_ADDRESS_ARRAY_BIT_NV";
+        case VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_SIZES_ARRAY_BIT_NV:
+            return "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_SIZES_ARRAY_BIT_NV";
+        case VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_ARRAY_BIT_NV:
+            return "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_ARRAY_BIT_NV";
+        case VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_COUNT_BIT_NV:
+            return "VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_COUNT_BIT_NV";
+        default:
+            return "Unhandled VkClusterAccelerationStructureAddressResolutionFlagBitsNV";
+    }
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkClusterAccelerationStructureAddressResolutionFlagsNV(VkClusterAccelerationStructureAddressResolutionFlagsNV input_value) {
+    std::string ret;
+    int index = 0;
+    while(input_value) {
+        if (input_value & 1) {
+            if( !ret.empty()) ret.append("|");
+            ret.append(string_VkClusterAccelerationStructureAddressResolutionFlagBitsNV(static_cast<VkClusterAccelerationStructureAddressResolutionFlagBitsNV>(1U << index)));
+        }
+        ++index;
+        input_value >>= 1;
+    }
+    if (ret.empty()) ret.append("VkClusterAccelerationStructureAddressResolutionFlagsNV(0)");
+    return ret;
+}
+#endif // __cplusplus
+static inline const char* string_VkClusterAccelerationStructureClusterFlagBitsNV(VkClusterAccelerationStructureClusterFlagBitsNV input_value) {
+    switch (input_value) {
+        case VK_CLUSTER_ACCELERATION_STRUCTURE_CLUSTER_ALLOW_DISABLE_OPACITY_MICROMAPS_NV:
+            return "VK_CLUSTER_ACCELERATION_STRUCTURE_CLUSTER_ALLOW_DISABLE_OPACITY_MICROMAPS_NV";
+        default:
+            return "Unhandled VkClusterAccelerationStructureClusterFlagBitsNV";
+    }
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkClusterAccelerationStructureClusterFlagsNV(VkClusterAccelerationStructureClusterFlagsNV input_value) {
+    std::string ret;
+    int index = 0;
+    while(input_value) {
+        if (input_value & 1) {
+            if( !ret.empty()) ret.append("|");
+            ret.append(string_VkClusterAccelerationStructureClusterFlagBitsNV(static_cast<VkClusterAccelerationStructureClusterFlagBitsNV>(1U << index)));
+        }
+        ++index;
+        input_value >>= 1;
+    }
+    if (ret.empty()) ret.append("VkClusterAccelerationStructureClusterFlagsNV(0)");
+    return ret;
+}
+#endif // __cplusplus
+static inline const char* string_VkClusterAccelerationStructureGeometryFlagBitsNV(VkClusterAccelerationStructureGeometryFlagBitsNV input_value) {
+    switch (input_value) {
+        case VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_CULL_DISABLE_BIT_NV:
+            return "VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_CULL_DISABLE_BIT_NV";
+        case VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_NO_DUPLICATE_ANYHIT_INVOCATION_BIT_NV:
+            return "VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_NO_DUPLICATE_ANYHIT_INVOCATION_BIT_NV";
+        case VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_OPAQUE_BIT_NV:
+            return "VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_OPAQUE_BIT_NV";
+        default:
+            return "Unhandled VkClusterAccelerationStructureGeometryFlagBitsNV";
+    }
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkClusterAccelerationStructureGeometryFlagsNV(VkClusterAccelerationStructureGeometryFlagsNV input_value) {
+    std::string ret;
+    int index = 0;
+    while(input_value) {
+        if (input_value & 1) {
+            if( !ret.empty()) ret.append("|");
+            ret.append(string_VkClusterAccelerationStructureGeometryFlagBitsNV(static_cast<VkClusterAccelerationStructureGeometryFlagBitsNV>(1U << index)));
+        }
+        ++index;
+        input_value >>= 1;
+    }
+    if (ret.empty()) ret.append("VkClusterAccelerationStructureGeometryFlagsNV(0)");
+    return ret;
+}
+#endif // __cplusplus
+static inline const char* string_VkClusterAccelerationStructureIndexFormatFlagBitsNV(VkClusterAccelerationStructureIndexFormatFlagBitsNV input_value) {
+    switch (input_value) {
+        case VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_8BIT_NV:
+            return "VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_8BIT_NV";
+        case VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_16BIT_NV:
+            return "VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_16BIT_NV";
+        case VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_32BIT_NV:
+            return "VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_32BIT_NV";
+        default:
+            return "Unhandled VkClusterAccelerationStructureIndexFormatFlagBitsNV";
+    }
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkClusterAccelerationStructureIndexFormatFlagsNV(VkClusterAccelerationStructureIndexFormatFlagsNV input_value) {
+    std::string ret;
+    int index = 0;
+    while(input_value) {
+        if (input_value & 1) {
+            if( !ret.empty()) ret.append("|");
+            ret.append(string_VkClusterAccelerationStructureIndexFormatFlagBitsNV(static_cast<VkClusterAccelerationStructureIndexFormatFlagBitsNV>(1U << index)));
+        }
+        ++index;
+        input_value >>= 1;
+    }
+    if (ret.empty()) ret.append("VkClusterAccelerationStructureIndexFormatFlagsNV(0)");
+    return ret;
+}
+#endif // __cplusplus
+static inline const char* string_VkPartitionedAccelerationStructureInstanceFlagBitsNV(VkPartitionedAccelerationStructureInstanceFlagBitsNV input_value) {
+    switch (input_value) {
+        case VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FACING_CULL_DISABLE_BIT_NV:
+            return "VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FACING_CULL_DISABLE_BIT_NV";
+        case VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FLIP_FACING_BIT_NV:
+            return "VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FLIP_FACING_BIT_NV";
+        case VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_OPAQUE_BIT_NV:
+            return "VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_OPAQUE_BIT_NV";
+        case VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_NO_OPAQUE_BIT_NV:
+            return "VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_NO_OPAQUE_BIT_NV";
+        case VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_ENABLE_EXPLICIT_BOUNDING_BOX_NV:
+            return "VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_ENABLE_EXPLICIT_BOUNDING_BOX_NV";
+        default:
+            return "Unhandled VkPartitionedAccelerationStructureInstanceFlagBitsNV";
+    }
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkPartitionedAccelerationStructureInstanceFlagsNV(VkPartitionedAccelerationStructureInstanceFlagsNV input_value) {
+    std::string ret;
+    int index = 0;
+    while(input_value) {
+        if (input_value & 1) {
+            if( !ret.empty()) ret.append("|");
+            ret.append(string_VkPartitionedAccelerationStructureInstanceFlagBitsNV(static_cast<VkPartitionedAccelerationStructureInstanceFlagBitsNV>(1U << index)));
+        }
+        ++index;
+        input_value >>= 1;
+    }
+    if (ret.empty()) ret.append("VkPartitionedAccelerationStructureInstanceFlagsNV(0)");
+    return ret;
+}
+#endif // __cplusplus
 static inline const char* string_VkIndirectCommandsInputModeFlagBitsEXT(VkIndirectCommandsInputModeFlagBitsEXT input_value) {
     switch (input_value) {
         case VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT:
diff --git a/scripts/generators/safe_struct_generator.py b/scripts/generators/safe_struct_generator.py
index 72e2281..cb67ccb 100644
--- a/scripts/generators/safe_struct_generator.py
+++ b/scripts/generators/safe_struct_generator.py
@@ -1,10 +1,10 @@
 #!/usr/bin/python3 -i
 #
-# Copyright (c) 2015-2024 The Khronos Group Inc.
-# Copyright (c) 2015-2024 Valve Corporation
-# Copyright (c) 2015-2024 LunarG, Inc.
-# Copyright (c) 2015-2024 Google Inc.
-# Copyright (c) 2023-2024 RasterGrid Kft.
+# Copyright (c) 2015-2025 The Khronos Group Inc.
+# Copyright (c) 2015-2025 Valve Corporation
+# Copyright (c) 2015-2025 LunarG, Inc.
+# Copyright (c) 2015-2025 Google Inc.
+# Copyright (c) 2023-2025 RasterGrid Kft.
 #
 # SPDX-License-Identifier: Apache-2.0
 
@@ -139,10 +139,10 @@ class SafeStructOutputGenerator(BaseGenerator):
 
             /***************************************************************************
             *
-            * Copyright (c) 2015-2024 The Khronos Group Inc.
-            * Copyright (c) 2015-2024 Valve Corporation
-            * Copyright (c) 2015-2024 LunarG, Inc.
-            * Copyright (c) 2015-2024 Google Inc.
+            * Copyright (c) 2015-2025 The Khronos Group Inc.
+            * Copyright (c) 2015-2025 Valve Corporation
+            * Copyright (c) 2015-2025 LunarG, Inc.
+            * Copyright (c) 2015-2025 Google Inc.
             *
             * SPDX-License-Identifier: Apache-2.0
             *
@@ -726,21 +726,13 @@ void FreePnextChain(const void *pNext) {
 
             safe_name = self.convertName(struct.name)
             if struct.union:
-                if struct.name in self.union_of_pointers:
-                    default_init_list = ' type_at_end {0},'
-                    out.append(f'''
-                        {safe_name}::{safe_name}(const {struct.name}* in_struct{self.custom_construct_params.get(struct.name, '')}, [[maybe_unused]] PNextCopyState* copy_state{copy_pnext_param})
-                        {{
-                        {copy_pnext + construct_txt}}}
-                        ''')
-                else:
-                    # Unions don't allow multiple members in the initialization list, so just call initialize
-                    out.append(f'''
-                        {safe_name}::{safe_name}(const {struct.name}* in_struct{self.custom_construct_params.get(struct.name, '')}, PNextCopyState*)
-                        {{
-                            initialize(in_struct);
-                        }}
-                        ''')
+                # Unions don't allow multiple members in the initialization list, so just call initialize
+                out.append(f'''
+                    {safe_name}::{safe_name}(const {struct.name}* in_struct{self.custom_construct_params.get(struct.name, '')}, PNextCopyState*)
+                    {{
+                        initialize(in_struct);
+                    }}
+                    ''')
             else:
                 out.append(f'''
                     {safe_name}::{safe_name}(const {struct.name}* in_struct{self.custom_construct_params.get(struct.name, '')}, [[maybe_unused]] PNextCopyState* copy_state{copy_pnext_param}) :{init_list}
@@ -748,7 +740,11 @@ void FreePnextChain(const void *pNext) {
                     {copy_pnext_if + construct_txt}}}
                     ''')
             if '' != default_init_list:
+                # trim trailing comma from initializer list
                 default_init_list = f' :{default_init_list[:-1]}'
+                # truncate union initializer list to first element
+                if struct.union:
+                    default_init_list = default_init_list.split(',')[0]
             default_init_body = '\n' + custom_defeault_construct_txt[struct.name] if struct.name in custom_defeault_construct_txt else ''
             out.append(f'''
                 {safe_name}::{safe_name}(){default_init_list}
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 27099c8..9bed905 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.4.306"
+            "commit": "v1.4.307"
         },
         {
             "name": "googletest",
diff --git a/src/vulkan/vk_safe_struct_core.cpp b/src/vulkan/vk_safe_struct_core.cpp
index 191919c..615ad8e 100644
--- a/src/vulkan/vk_safe_struct_core.cpp
+++ b/src/vulkan/vk_safe_struct_core.cpp
@@ -3,10 +3,10 @@
 
 /***************************************************************************
  *
- * Copyright (c) 2015-2024 The Khronos Group Inc.
- * Copyright (c) 2015-2024 Valve Corporation
- * Copyright (c) 2015-2024 LunarG, Inc.
- * Copyright (c) 2015-2024 Google Inc.
+ * Copyright (c) 2015-2025 The Khronos Group Inc.
+ * Copyright (c) 2015-2025 Valve Corporation
+ * Copyright (c) 2015-2025 LunarG, Inc.
+ * Copyright (c) 2015-2025 Google Inc.
  *
  * SPDX-License-Identifier: Apache-2.0
  *
diff --git a/src/vulkan/vk_safe_struct_ext.cpp b/src/vulkan/vk_safe_struct_ext.cpp
index f3f6e6a..2a7e197 100644
--- a/src/vulkan/vk_safe_struct_ext.cpp
+++ b/src/vulkan/vk_safe_struct_ext.cpp
@@ -3,10 +3,10 @@
 
 /***************************************************************************
  *
- * Copyright (c) 2015-2024 The Khronos Group Inc.
- * Copyright (c) 2015-2024 Valve Corporation
- * Copyright (c) 2015-2024 LunarG, Inc.
- * Copyright (c) 2015-2024 Google Inc.
+ * Copyright (c) 2015-2025 The Khronos Group Inc.
+ * Copyright (c) 2015-2025 Valve Corporation
+ * Copyright (c) 2015-2025 LunarG, Inc.
+ * Copyright (c) 2015-2025 Google Inc.
  *
  * SPDX-License-Identifier: Apache-2.0
  *
diff --git a/src/vulkan/vk_safe_struct_khr.cpp b/src/vulkan/vk_safe_struct_khr.cpp
index e0416c3..303938a 100644
--- a/src/vulkan/vk_safe_struct_khr.cpp
+++ b/src/vulkan/vk_safe_struct_khr.cpp
@@ -3,10 +3,10 @@
 
 /***************************************************************************
  *
- * Copyright (c) 2015-2024 The Khronos Group Inc.
- * Copyright (c) 2015-2024 Valve Corporation
- * Copyright (c) 2015-2024 LunarG, Inc.
- * Copyright (c) 2015-2024 Google Inc.
+ * Copyright (c) 2015-2025 The Khronos Group Inc.
+ * Copyright (c) 2015-2025 Valve Corporation
+ * Copyright (c) 2015-2025 LunarG, Inc.
+ * Copyright (c) 2015-2025 Google Inc.
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -15242,6 +15242,69 @@ void safe_VkDeviceOrHostAddressKHR::initialize(const safe_VkDeviceOrHostAddressK
     hostAddress = copy_src->hostAddress;
 }
 
+safe_VkAccelerationStructureBuildSizesInfoKHR::safe_VkAccelerationStructureBuildSizesInfoKHR(
+    const VkAccelerationStructureBuildSizesInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      accelerationStructureSize(in_struct->accelerationStructureSize),
+      updateScratchSize(in_struct->updateScratchSize),
+      buildScratchSize(in_struct->buildScratchSize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkAccelerationStructureBuildSizesInfoKHR::safe_VkAccelerationStructureBuildSizesInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR),
+      pNext(nullptr),
+      accelerationStructureSize(),
+      updateScratchSize(),
+      buildScratchSize() {}
+
+safe_VkAccelerationStructureBuildSizesInfoKHR::safe_VkAccelerationStructureBuildSizesInfoKHR(
+    const safe_VkAccelerationStructureBuildSizesInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    accelerationStructureSize = copy_src.accelerationStructureSize;
+    updateScratchSize = copy_src.updateScratchSize;
+    buildScratchSize = copy_src.buildScratchSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkAccelerationStructureBuildSizesInfoKHR& safe_VkAccelerationStructureBuildSizesInfoKHR::operator=(
+    const safe_VkAccelerationStructureBuildSizesInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    accelerationStructureSize = copy_src.accelerationStructureSize;
+    updateScratchSize = copy_src.updateScratchSize;
+    buildScratchSize = copy_src.buildScratchSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkAccelerationStructureBuildSizesInfoKHR::~safe_VkAccelerationStructureBuildSizesInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkAccelerationStructureBuildSizesInfoKHR::initialize(const VkAccelerationStructureBuildSizesInfoKHR* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    accelerationStructureSize = in_struct->accelerationStructureSize;
+    updateScratchSize = in_struct->updateScratchSize;
+    buildScratchSize = in_struct->buildScratchSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkAccelerationStructureBuildSizesInfoKHR::initialize(const safe_VkAccelerationStructureBuildSizesInfoKHR* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    accelerationStructureSize = copy_src->accelerationStructureSize;
+    updateScratchSize = copy_src->updateScratchSize;
+    buildScratchSize = copy_src->buildScratchSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkAccelerationStructureGeometryTrianglesDataKHR::safe_VkAccelerationStructureGeometryTrianglesDataKHR(
     const VkAccelerationStructureGeometryTrianglesDataKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType),
@@ -16076,69 +16139,6 @@ void safe_VkCopyAccelerationStructureInfoKHR::initialize(const safe_VkCopyAccele
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
-safe_VkAccelerationStructureBuildSizesInfoKHR::safe_VkAccelerationStructureBuildSizesInfoKHR(
-    const VkAccelerationStructureBuildSizesInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType),
-      accelerationStructureSize(in_struct->accelerationStructureSize),
-      updateScratchSize(in_struct->updateScratchSize),
-      buildScratchSize(in_struct->buildScratchSize) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkAccelerationStructureBuildSizesInfoKHR::safe_VkAccelerationStructureBuildSizesInfoKHR()
-    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR),
-      pNext(nullptr),
-      accelerationStructureSize(),
-      updateScratchSize(),
-      buildScratchSize() {}
-
-safe_VkAccelerationStructureBuildSizesInfoKHR::safe_VkAccelerationStructureBuildSizesInfoKHR(
-    const safe_VkAccelerationStructureBuildSizesInfoKHR& copy_src) {
-    sType = copy_src.sType;
-    accelerationStructureSize = copy_src.accelerationStructureSize;
-    updateScratchSize = copy_src.updateScratchSize;
-    buildScratchSize = copy_src.buildScratchSize;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkAccelerationStructureBuildSizesInfoKHR& safe_VkAccelerationStructureBuildSizesInfoKHR::operator=(
-    const safe_VkAccelerationStructureBuildSizesInfoKHR& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    accelerationStructureSize = copy_src.accelerationStructureSize;
-    updateScratchSize = copy_src.updateScratchSize;
-    buildScratchSize = copy_src.buildScratchSize;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkAccelerationStructureBuildSizesInfoKHR::~safe_VkAccelerationStructureBuildSizesInfoKHR() { FreePnextChain(pNext); }
-
-void safe_VkAccelerationStructureBuildSizesInfoKHR::initialize(const VkAccelerationStructureBuildSizesInfoKHR* in_struct,
-                                                               [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    accelerationStructureSize = in_struct->accelerationStructureSize;
-    updateScratchSize = in_struct->updateScratchSize;
-    buildScratchSize = in_struct->buildScratchSize;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkAccelerationStructureBuildSizesInfoKHR::initialize(const safe_VkAccelerationStructureBuildSizesInfoKHR* copy_src,
-                                                               [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    accelerationStructureSize = copy_src->accelerationStructureSize;
-    updateScratchSize = copy_src->updateScratchSize;
-    buildScratchSize = copy_src->buildScratchSize;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
 safe_VkRayTracingShaderGroupCreateInfoKHR::safe_VkRayTracingShaderGroupCreateInfoKHR(
     const VkRayTracingShaderGroupCreateInfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType),
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index a5e7be5..4790801 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -3,10 +3,10 @@
 
 /***************************************************************************
  *
- * Copyright (c) 2015-2024 The Khronos Group Inc.
- * Copyright (c) 2015-2024 Valve Corporation
- * Copyright (c) 2015-2024 LunarG, Inc.
- * Copyright (c) 2015-2024 Google Inc.
+ * Copyright (c) 2015-2025 The Khronos Group Inc.
+ * Copyright (c) 2015-2025 Valve Corporation
+ * Copyright (c) 2015-2025 LunarG, Inc.
+ * Copyright (c) 2015-2025 Google Inc.
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -1716,6 +1716,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV:
                 safe_pNext = new safe_VkComputePipelineIndirectBufferInfoNV(reinterpret_cast<const VkComputePipelineIndirectBufferInfoNV *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV(reinterpret_cast<const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
                 safe_pNext = new safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(reinterpret_cast<const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *>(pNext), copy_state, false);
                 break;
@@ -1823,6 +1826,12 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
                 safe_pNext = new safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceCooperativeVectorPropertiesNV(reinterpret_cast<const VkPhysicalDeviceCooperativeVectorPropertiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceCooperativeVectorFeaturesNV(reinterpret_cast<const VkPhysicalDeviceCooperativeVectorFeaturesNV *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV:
                 safe_pNext = new safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV(reinterpret_cast<const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *>(pNext), copy_state, false);
                 break;
@@ -1939,6 +1948,27 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
                 safe_pNext = new safe_VkPhysicalDeviceRayTracingValidationFeaturesNV(reinterpret_cast<const VkPhysicalDeviceRayTracingValidationFeaturesNV *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV(reinterpret_cast<const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV(reinterpret_cast<const VkPhysicalDeviceClusterAccelerationStructurePropertiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV:
+                safe_pNext = new safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV(reinterpret_cast<const VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV(reinterpret_cast<const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV:
+                safe_pNext = new safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV(reinterpret_cast<const VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV:
+                safe_pNext = new safe_VkPartitionedAccelerationStructureFlagsNV(reinterpret_cast<const VkPartitionedAccelerationStructureFlagsNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV:
+                safe_pNext = new safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV(reinterpret_cast<const VkWriteDescriptorSetPartitionedAccelerationStructureNV *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT:
                 safe_pNext = new safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *>(pNext), copy_state, false);
                 break;
@@ -3721,6 +3751,9 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV:
             delete reinterpret_cast<safe_VkComputePipelineIndirectBufferInfoNV *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV:
+            delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
             delete reinterpret_cast<safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV *>(header);
             break;
@@ -3828,6 +3861,12 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
             delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV:
+            delete reinterpret_cast<safe_VkPhysicalDeviceCooperativeVectorPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV:
+            delete reinterpret_cast<safe_VkPhysicalDeviceCooperativeVectorFeaturesNV *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV:
             delete reinterpret_cast<safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *>(header);
             break;
@@ -3944,6 +3983,27 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
             delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingValidationFeaturesNV *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV:
+            delete reinterpret_cast<safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV:
+            delete reinterpret_cast<safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV:
+            delete reinterpret_cast<safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV:
+            delete reinterpret_cast<safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV:
+            delete reinterpret_cast<safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV:
+            delete reinterpret_cast<safe_VkPartitionedAccelerationStructureFlagsNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV:
+            delete reinterpret_cast<safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT:
             delete reinterpret_cast<safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *>(header);
             break;
diff --git a/src/vulkan/vk_safe_struct_vendor.cpp b/src/vulkan/vk_safe_struct_vendor.cpp
index 602644f..5d20575 100644
--- a/src/vulkan/vk_safe_struct_vendor.cpp
+++ b/src/vulkan/vk_safe_struct_vendor.cpp
@@ -3,10 +3,10 @@
 
 /***************************************************************************
  *
- * Copyright (c) 2015-2024 The Khronos Group Inc.
- * Copyright (c) 2015-2024 Valve Corporation
- * Copyright (c) 2015-2024 LunarG, Inc.
- * Copyright (c) 2015-2024 Google Inc.
+ * Copyright (c) 2015-2025 The Khronos Group Inc.
+ * Copyright (c) 2015-2025 Valve Corporation
+ * Copyright (c) 2015-2025 LunarG, Inc.
+ * Copyright (c) 2015-2025 Google Inc.
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -11712,6 +11712,272 @@ void safe_VkPipelineIndirectDeviceAddressInfoNV::initialize(const safe_VkPipelin
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV::safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV(
+    const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), spheres(in_struct->spheres), linearSweptSpheres(in_struct->linearSweptSpheres) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV::safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV),
+      pNext(nullptr),
+      spheres(),
+      linearSweptSpheres() {}
+
+safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV::safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV(
+    const safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    spheres = copy_src.spheres;
+    linearSweptSpheres = copy_src.linearSweptSpheres;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV& safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    spheres = copy_src.spheres;
+    linearSweptSpheres = copy_src.linearSweptSpheres;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV::~safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV::initialize(
+    const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    spheres = in_struct->spheres;
+    linearSweptSpheres = in_struct->linearSweptSpheres;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV::initialize(
+    const safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    spheres = copy_src->spheres;
+    linearSweptSpheres = copy_src->linearSweptSpheres;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV::safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV(
+    const VkAccelerationStructureGeometryLinearSweptSpheresDataNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      vertexFormat(in_struct->vertexFormat),
+      vertexData(&in_struct->vertexData),
+      vertexStride(in_struct->vertexStride),
+      radiusFormat(in_struct->radiusFormat),
+      radiusData(&in_struct->radiusData),
+      radiusStride(in_struct->radiusStride),
+      indexType(in_struct->indexType),
+      indexData(&in_struct->indexData),
+      indexStride(in_struct->indexStride),
+      indexingMode(in_struct->indexingMode),
+      endCapsMode(in_struct->endCapsMode) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV::safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV),
+      pNext(nullptr),
+      vertexFormat(),
+      vertexStride(),
+      radiusFormat(),
+      radiusStride(),
+      indexType(),
+      indexStride(),
+      indexingMode(),
+      endCapsMode() {}
+
+safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV::safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV(
+    const safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV& copy_src) {
+    sType = copy_src.sType;
+    vertexFormat = copy_src.vertexFormat;
+    vertexData.initialize(&copy_src.vertexData);
+    vertexStride = copy_src.vertexStride;
+    radiusFormat = copy_src.radiusFormat;
+    radiusData.initialize(&copy_src.radiusData);
+    radiusStride = copy_src.radiusStride;
+    indexType = copy_src.indexType;
+    indexData.initialize(&copy_src.indexData);
+    indexStride = copy_src.indexStride;
+    indexingMode = copy_src.indexingMode;
+    endCapsMode = copy_src.endCapsMode;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV&
+safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV::operator=(
+    const safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    vertexFormat = copy_src.vertexFormat;
+    vertexData.initialize(&copy_src.vertexData);
+    vertexStride = copy_src.vertexStride;
+    radiusFormat = copy_src.radiusFormat;
+    radiusData.initialize(&copy_src.radiusData);
+    radiusStride = copy_src.radiusStride;
+    indexType = copy_src.indexType;
+    indexData.initialize(&copy_src.indexData);
+    indexStride = copy_src.indexStride;
+    indexingMode = copy_src.indexingMode;
+    endCapsMode = copy_src.endCapsMode;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV::~safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV::initialize(
+    const VkAccelerationStructureGeometryLinearSweptSpheresDataNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    vertexFormat = in_struct->vertexFormat;
+    vertexData.initialize(&in_struct->vertexData);
+    vertexStride = in_struct->vertexStride;
+    radiusFormat = in_struct->radiusFormat;
+    radiusData.initialize(&in_struct->radiusData);
+    radiusStride = in_struct->radiusStride;
+    indexType = in_struct->indexType;
+    indexData.initialize(&in_struct->indexData);
+    indexStride = in_struct->indexStride;
+    indexingMode = in_struct->indexingMode;
+    endCapsMode = in_struct->endCapsMode;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV::initialize(
+    const safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    vertexFormat = copy_src->vertexFormat;
+    vertexData.initialize(&copy_src->vertexData);
+    vertexStride = copy_src->vertexStride;
+    radiusFormat = copy_src->radiusFormat;
+    radiusData.initialize(&copy_src->radiusData);
+    radiusStride = copy_src->radiusStride;
+    indexType = copy_src->indexType;
+    indexData.initialize(&copy_src->indexData);
+    indexStride = copy_src->indexStride;
+    indexingMode = copy_src->indexingMode;
+    endCapsMode = copy_src->endCapsMode;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkAccelerationStructureGeometrySpheresDataNV::safe_VkAccelerationStructureGeometrySpheresDataNV(
+    const VkAccelerationStructureGeometrySpheresDataNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      vertexFormat(in_struct->vertexFormat),
+      vertexData(&in_struct->vertexData),
+      vertexStride(in_struct->vertexStride),
+      radiusFormat(in_struct->radiusFormat),
+      radiusData(&in_struct->radiusData),
+      radiusStride(in_struct->radiusStride),
+      indexType(in_struct->indexType),
+      indexData(&in_struct->indexData),
+      indexStride(in_struct->indexStride) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkAccelerationStructureGeometrySpheresDataNV::safe_VkAccelerationStructureGeometrySpheresDataNV()
+    : sType(VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV),
+      pNext(nullptr),
+      vertexFormat(),
+      vertexStride(),
+      radiusFormat(),
+      radiusStride(),
+      indexType(),
+      indexStride() {}
+
+safe_VkAccelerationStructureGeometrySpheresDataNV::safe_VkAccelerationStructureGeometrySpheresDataNV(
+    const safe_VkAccelerationStructureGeometrySpheresDataNV& copy_src) {
+    sType = copy_src.sType;
+    vertexFormat = copy_src.vertexFormat;
+    vertexData.initialize(&copy_src.vertexData);
+    vertexStride = copy_src.vertexStride;
+    radiusFormat = copy_src.radiusFormat;
+    radiusData.initialize(&copy_src.radiusData);
+    radiusStride = copy_src.radiusStride;
+    indexType = copy_src.indexType;
+    indexData.initialize(&copy_src.indexData);
+    indexStride = copy_src.indexStride;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkAccelerationStructureGeometrySpheresDataNV& safe_VkAccelerationStructureGeometrySpheresDataNV::operator=(
+    const safe_VkAccelerationStructureGeometrySpheresDataNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    vertexFormat = copy_src.vertexFormat;
+    vertexData.initialize(&copy_src.vertexData);
+    vertexStride = copy_src.vertexStride;
+    radiusFormat = copy_src.radiusFormat;
+    radiusData.initialize(&copy_src.radiusData);
+    radiusStride = copy_src.radiusStride;
+    indexType = copy_src.indexType;
+    indexData.initialize(&copy_src.indexData);
+    indexStride = copy_src.indexStride;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkAccelerationStructureGeometrySpheresDataNV::~safe_VkAccelerationStructureGeometrySpheresDataNV() { FreePnextChain(pNext); }
+
+void safe_VkAccelerationStructureGeometrySpheresDataNV::initialize(const VkAccelerationStructureGeometrySpheresDataNV* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    vertexFormat = in_struct->vertexFormat;
+    vertexData.initialize(&in_struct->vertexData);
+    vertexStride = in_struct->vertexStride;
+    radiusFormat = in_struct->radiusFormat;
+    radiusData.initialize(&in_struct->radiusData);
+    radiusStride = in_struct->radiusStride;
+    indexType = in_struct->indexType;
+    indexData.initialize(&in_struct->indexData);
+    indexStride = in_struct->indexStride;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkAccelerationStructureGeometrySpheresDataNV::initialize(
+    const safe_VkAccelerationStructureGeometrySpheresDataNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    vertexFormat = copy_src->vertexFormat;
+    vertexData.initialize(&copy_src->vertexData);
+    vertexStride = copy_src->vertexStride;
+    radiusFormat = copy_src->radiusFormat;
+    radiusData.initialize(&copy_src->radiusData);
+    radiusStride = copy_src->radiusStride;
+    indexType = copy_src->indexType;
+    indexData.initialize(&copy_src->indexData);
+    indexStride = copy_src->indexStride;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV::safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
     const VkPhysicalDeviceLinearColorAttachmentFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType), linearColorAttachment(in_struct->linearColorAttachment) {
@@ -13289,6 +13555,352 @@ void safe_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV::initialize(
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkPhysicalDeviceCooperativeVectorPropertiesNV::safe_VkPhysicalDeviceCooperativeVectorPropertiesNV(
+    const VkPhysicalDeviceCooperativeVectorPropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      cooperativeVectorSupportedStages(in_struct->cooperativeVectorSupportedStages),
+      cooperativeVectorTrainingFloat16Accumulation(in_struct->cooperativeVectorTrainingFloat16Accumulation),
+      cooperativeVectorTrainingFloat32Accumulation(in_struct->cooperativeVectorTrainingFloat32Accumulation),
+      maxCooperativeVectorComponents(in_struct->maxCooperativeVectorComponents) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceCooperativeVectorPropertiesNV::safe_VkPhysicalDeviceCooperativeVectorPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV),
+      pNext(nullptr),
+      cooperativeVectorSupportedStages(),
+      cooperativeVectorTrainingFloat16Accumulation(),
+      cooperativeVectorTrainingFloat32Accumulation(),
+      maxCooperativeVectorComponents() {}
+
+safe_VkPhysicalDeviceCooperativeVectorPropertiesNV::safe_VkPhysicalDeviceCooperativeVectorPropertiesNV(
+    const safe_VkPhysicalDeviceCooperativeVectorPropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    cooperativeVectorSupportedStages = copy_src.cooperativeVectorSupportedStages;
+    cooperativeVectorTrainingFloat16Accumulation = copy_src.cooperativeVectorTrainingFloat16Accumulation;
+    cooperativeVectorTrainingFloat32Accumulation = copy_src.cooperativeVectorTrainingFloat32Accumulation;
+    maxCooperativeVectorComponents = copy_src.maxCooperativeVectorComponents;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceCooperativeVectorPropertiesNV& safe_VkPhysicalDeviceCooperativeVectorPropertiesNV::operator=(
+    const safe_VkPhysicalDeviceCooperativeVectorPropertiesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    cooperativeVectorSupportedStages = copy_src.cooperativeVectorSupportedStages;
+    cooperativeVectorTrainingFloat16Accumulation = copy_src.cooperativeVectorTrainingFloat16Accumulation;
+    cooperativeVectorTrainingFloat32Accumulation = copy_src.cooperativeVectorTrainingFloat32Accumulation;
+    maxCooperativeVectorComponents = copy_src.maxCooperativeVectorComponents;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceCooperativeVectorPropertiesNV::~safe_VkPhysicalDeviceCooperativeVectorPropertiesNV() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceCooperativeVectorPropertiesNV::initialize(const VkPhysicalDeviceCooperativeVectorPropertiesNV* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    cooperativeVectorSupportedStages = in_struct->cooperativeVectorSupportedStages;
+    cooperativeVectorTrainingFloat16Accumulation = in_struct->cooperativeVectorTrainingFloat16Accumulation;
+    cooperativeVectorTrainingFloat32Accumulation = in_struct->cooperativeVectorTrainingFloat32Accumulation;
+    maxCooperativeVectorComponents = in_struct->maxCooperativeVectorComponents;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceCooperativeVectorPropertiesNV::initialize(
+    const safe_VkPhysicalDeviceCooperativeVectorPropertiesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    cooperativeVectorSupportedStages = copy_src->cooperativeVectorSupportedStages;
+    cooperativeVectorTrainingFloat16Accumulation = copy_src->cooperativeVectorTrainingFloat16Accumulation;
+    cooperativeVectorTrainingFloat32Accumulation = copy_src->cooperativeVectorTrainingFloat32Accumulation;
+    maxCooperativeVectorComponents = copy_src->maxCooperativeVectorComponents;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceCooperativeVectorFeaturesNV::safe_VkPhysicalDeviceCooperativeVectorFeaturesNV(
+    const VkPhysicalDeviceCooperativeVectorFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      cooperativeVector(in_struct->cooperativeVector),
+      cooperativeVectorTraining(in_struct->cooperativeVectorTraining) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceCooperativeVectorFeaturesNV::safe_VkPhysicalDeviceCooperativeVectorFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV),
+      pNext(nullptr),
+      cooperativeVector(),
+      cooperativeVectorTraining() {}
+
+safe_VkPhysicalDeviceCooperativeVectorFeaturesNV::safe_VkPhysicalDeviceCooperativeVectorFeaturesNV(
+    const safe_VkPhysicalDeviceCooperativeVectorFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    cooperativeVector = copy_src.cooperativeVector;
+    cooperativeVectorTraining = copy_src.cooperativeVectorTraining;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceCooperativeVectorFeaturesNV& safe_VkPhysicalDeviceCooperativeVectorFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceCooperativeVectorFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    cooperativeVector = copy_src.cooperativeVector;
+    cooperativeVectorTraining = copy_src.cooperativeVectorTraining;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceCooperativeVectorFeaturesNV::~safe_VkPhysicalDeviceCooperativeVectorFeaturesNV() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceCooperativeVectorFeaturesNV::initialize(const VkPhysicalDeviceCooperativeVectorFeaturesNV* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    cooperativeVector = in_struct->cooperativeVector;
+    cooperativeVectorTraining = in_struct->cooperativeVectorTraining;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceCooperativeVectorFeaturesNV::initialize(const safe_VkPhysicalDeviceCooperativeVectorFeaturesNV* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    cooperativeVector = copy_src->cooperativeVector;
+    cooperativeVectorTraining = copy_src->cooperativeVectorTraining;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkCooperativeVectorPropertiesNV::safe_VkCooperativeVectorPropertiesNV(const VkCooperativeVectorPropertiesNV* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType),
+      inputType(in_struct->inputType),
+      inputInterpretation(in_struct->inputInterpretation),
+      matrixInterpretation(in_struct->matrixInterpretation),
+      biasInterpretation(in_struct->biasInterpretation),
+      resultType(in_struct->resultType),
+      transpose(in_struct->transpose) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkCooperativeVectorPropertiesNV::safe_VkCooperativeVectorPropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV),
+      pNext(nullptr),
+      inputType(),
+      inputInterpretation(),
+      matrixInterpretation(),
+      biasInterpretation(),
+      resultType(),
+      transpose() {}
+
+safe_VkCooperativeVectorPropertiesNV::safe_VkCooperativeVectorPropertiesNV(const safe_VkCooperativeVectorPropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    inputType = copy_src.inputType;
+    inputInterpretation = copy_src.inputInterpretation;
+    matrixInterpretation = copy_src.matrixInterpretation;
+    biasInterpretation = copy_src.biasInterpretation;
+    resultType = copy_src.resultType;
+    transpose = copy_src.transpose;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkCooperativeVectorPropertiesNV& safe_VkCooperativeVectorPropertiesNV::operator=(
+    const safe_VkCooperativeVectorPropertiesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    inputType = copy_src.inputType;
+    inputInterpretation = copy_src.inputInterpretation;
+    matrixInterpretation = copy_src.matrixInterpretation;
+    biasInterpretation = copy_src.biasInterpretation;
+    resultType = copy_src.resultType;
+    transpose = copy_src.transpose;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkCooperativeVectorPropertiesNV::~safe_VkCooperativeVectorPropertiesNV() { FreePnextChain(pNext); }
+
+void safe_VkCooperativeVectorPropertiesNV::initialize(const VkCooperativeVectorPropertiesNV* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    inputType = in_struct->inputType;
+    inputInterpretation = in_struct->inputInterpretation;
+    matrixInterpretation = in_struct->matrixInterpretation;
+    biasInterpretation = in_struct->biasInterpretation;
+    resultType = in_struct->resultType;
+    transpose = in_struct->transpose;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkCooperativeVectorPropertiesNV::initialize(const safe_VkCooperativeVectorPropertiesNV* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    inputType = copy_src->inputType;
+    inputInterpretation = copy_src->inputInterpretation;
+    matrixInterpretation = copy_src->matrixInterpretation;
+    biasInterpretation = copy_src->biasInterpretation;
+    resultType = copy_src->resultType;
+    transpose = copy_src->transpose;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkConvertCooperativeVectorMatrixInfoNV::safe_VkConvertCooperativeVectorMatrixInfoNV(
+    const VkConvertCooperativeVectorMatrixInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      srcSize(in_struct->srcSize),
+      srcData(&in_struct->srcData),
+      pDstSize(nullptr),
+      dstData(&in_struct->dstData),
+      srcComponentType(in_struct->srcComponentType),
+      dstComponentType(in_struct->dstComponentType),
+      numRows(in_struct->numRows),
+      numColumns(in_struct->numColumns),
+      srcLayout(in_struct->srcLayout),
+      srcStride(in_struct->srcStride),
+      dstLayout(in_struct->dstLayout),
+      dstStride(in_struct->dstStride) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pDstSize) {
+        pDstSize = new size_t(*in_struct->pDstSize);
+    }
+}
+
+safe_VkConvertCooperativeVectorMatrixInfoNV::safe_VkConvertCooperativeVectorMatrixInfoNV()
+    : sType(VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV),
+      pNext(nullptr),
+      srcSize(),
+      pDstSize(nullptr),
+      srcComponentType(),
+      dstComponentType(),
+      numRows(),
+      numColumns(),
+      srcLayout(),
+      srcStride(),
+      dstLayout(),
+      dstStride() {}
+
+safe_VkConvertCooperativeVectorMatrixInfoNV::safe_VkConvertCooperativeVectorMatrixInfoNV(
+    const safe_VkConvertCooperativeVectorMatrixInfoNV& copy_src) {
+    sType = copy_src.sType;
+    srcSize = copy_src.srcSize;
+    srcData.initialize(&copy_src.srcData);
+    pDstSize = nullptr;
+    dstData.initialize(&copy_src.dstData);
+    srcComponentType = copy_src.srcComponentType;
+    dstComponentType = copy_src.dstComponentType;
+    numRows = copy_src.numRows;
+    numColumns = copy_src.numColumns;
+    srcLayout = copy_src.srcLayout;
+    srcStride = copy_src.srcStride;
+    dstLayout = copy_src.dstLayout;
+    dstStride = copy_src.dstStride;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDstSize) {
+        pDstSize = new size_t(*copy_src.pDstSize);
+    }
+}
+
+safe_VkConvertCooperativeVectorMatrixInfoNV& safe_VkConvertCooperativeVectorMatrixInfoNV::operator=(
+    const safe_VkConvertCooperativeVectorMatrixInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pDstSize) delete pDstSize;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    srcSize = copy_src.srcSize;
+    srcData.initialize(&copy_src.srcData);
+    pDstSize = nullptr;
+    dstData.initialize(&copy_src.dstData);
+    srcComponentType = copy_src.srcComponentType;
+    dstComponentType = copy_src.dstComponentType;
+    numRows = copy_src.numRows;
+    numColumns = copy_src.numColumns;
+    srcLayout = copy_src.srcLayout;
+    srcStride = copy_src.srcStride;
+    dstLayout = copy_src.dstLayout;
+    dstStride = copy_src.dstStride;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDstSize) {
+        pDstSize = new size_t(*copy_src.pDstSize);
+    }
+
+    return *this;
+}
+
+safe_VkConvertCooperativeVectorMatrixInfoNV::~safe_VkConvertCooperativeVectorMatrixInfoNV() {
+    if (pDstSize) delete pDstSize;
+    FreePnextChain(pNext);
+}
+
+void safe_VkConvertCooperativeVectorMatrixInfoNV::initialize(const VkConvertCooperativeVectorMatrixInfoNV* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pDstSize) delete pDstSize;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    srcSize = in_struct->srcSize;
+    srcData.initialize(&in_struct->srcData);
+    pDstSize = nullptr;
+    dstData.initialize(&in_struct->dstData);
+    srcComponentType = in_struct->srcComponentType;
+    dstComponentType = in_struct->dstComponentType;
+    numRows = in_struct->numRows;
+    numColumns = in_struct->numColumns;
+    srcLayout = in_struct->srcLayout;
+    srcStride = in_struct->srcStride;
+    dstLayout = in_struct->dstLayout;
+    dstStride = in_struct->dstStride;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pDstSize) {
+        pDstSize = new size_t(*in_struct->pDstSize);
+    }
+}
+
+void safe_VkConvertCooperativeVectorMatrixInfoNV::initialize(const safe_VkConvertCooperativeVectorMatrixInfoNV* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    srcSize = copy_src->srcSize;
+    srcData.initialize(&copy_src->srcData);
+    pDstSize = nullptr;
+    dstData.initialize(&copy_src->dstData);
+    srcComponentType = copy_src->srcComponentType;
+    dstComponentType = copy_src->dstComponentType;
+    numRows = copy_src->numRows;
+    numColumns = copy_src->numColumns;
+    srcLayout = copy_src->srcLayout;
+    srcStride = copy_src->srcStride;
+    dstLayout = copy_src->dstLayout;
+    dstStride = copy_src->dstStride;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pDstSize) {
+        pDstSize = new size_t(*copy_src->pDstSize);
+    }
+}
+
 safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV::safe_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV(
     const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
     bool copy_pnext)
@@ -15458,6 +16070,1085 @@ void safe_VkPhysicalDeviceRayTracingValidationFeaturesNV::initialize(
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV::safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV(
+    const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), clusterAccelerationStructure(in_struct->clusterAccelerationStructure) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV::safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV),
+      pNext(nullptr),
+      clusterAccelerationStructure() {}
+
+safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV::safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV(
+    const safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    clusterAccelerationStructure = copy_src.clusterAccelerationStructure;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV& safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV::operator=(
+    const safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    clusterAccelerationStructure = copy_src.clusterAccelerationStructure;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV::~safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV::initialize(
+    const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    clusterAccelerationStructure = in_struct->clusterAccelerationStructure;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV::initialize(
+    const safe_VkPhysicalDeviceClusterAccelerationStructureFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    clusterAccelerationStructure = copy_src->clusterAccelerationStructure;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV::safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV(
+    const VkPhysicalDeviceClusterAccelerationStructurePropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      maxVerticesPerCluster(in_struct->maxVerticesPerCluster),
+      maxTrianglesPerCluster(in_struct->maxTrianglesPerCluster),
+      clusterScratchByteAlignment(in_struct->clusterScratchByteAlignment),
+      clusterByteAlignment(in_struct->clusterByteAlignment),
+      clusterTemplateByteAlignment(in_struct->clusterTemplateByteAlignment),
+      clusterBottomLevelByteAlignment(in_struct->clusterBottomLevelByteAlignment),
+      clusterTemplateBoundsByteAlignment(in_struct->clusterTemplateBoundsByteAlignment),
+      maxClusterGeometryIndex(in_struct->maxClusterGeometryIndex) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV::safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV),
+      pNext(nullptr),
+      maxVerticesPerCluster(),
+      maxTrianglesPerCluster(),
+      clusterScratchByteAlignment(),
+      clusterByteAlignment(),
+      clusterTemplateByteAlignment(),
+      clusterBottomLevelByteAlignment(),
+      clusterTemplateBoundsByteAlignment(),
+      maxClusterGeometryIndex() {}
+
+safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV::safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV(
+    const safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    maxVerticesPerCluster = copy_src.maxVerticesPerCluster;
+    maxTrianglesPerCluster = copy_src.maxTrianglesPerCluster;
+    clusterScratchByteAlignment = copy_src.clusterScratchByteAlignment;
+    clusterByteAlignment = copy_src.clusterByteAlignment;
+    clusterTemplateByteAlignment = copy_src.clusterTemplateByteAlignment;
+    clusterBottomLevelByteAlignment = copy_src.clusterBottomLevelByteAlignment;
+    clusterTemplateBoundsByteAlignment = copy_src.clusterTemplateBoundsByteAlignment;
+    maxClusterGeometryIndex = copy_src.maxClusterGeometryIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV&
+safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV::operator=(
+    const safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxVerticesPerCluster = copy_src.maxVerticesPerCluster;
+    maxTrianglesPerCluster = copy_src.maxTrianglesPerCluster;
+    clusterScratchByteAlignment = copy_src.clusterScratchByteAlignment;
+    clusterByteAlignment = copy_src.clusterByteAlignment;
+    clusterTemplateByteAlignment = copy_src.clusterTemplateByteAlignment;
+    clusterBottomLevelByteAlignment = copy_src.clusterBottomLevelByteAlignment;
+    clusterTemplateBoundsByteAlignment = copy_src.clusterTemplateBoundsByteAlignment;
+    maxClusterGeometryIndex = copy_src.maxClusterGeometryIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV::~safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV::initialize(
+    const VkPhysicalDeviceClusterAccelerationStructurePropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxVerticesPerCluster = in_struct->maxVerticesPerCluster;
+    maxTrianglesPerCluster = in_struct->maxTrianglesPerCluster;
+    clusterScratchByteAlignment = in_struct->clusterScratchByteAlignment;
+    clusterByteAlignment = in_struct->clusterByteAlignment;
+    clusterTemplateByteAlignment = in_struct->clusterTemplateByteAlignment;
+    clusterBottomLevelByteAlignment = in_struct->clusterBottomLevelByteAlignment;
+    clusterTemplateBoundsByteAlignment = in_struct->clusterTemplateBoundsByteAlignment;
+    maxClusterGeometryIndex = in_struct->maxClusterGeometryIndex;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV::initialize(
+    const safe_VkPhysicalDeviceClusterAccelerationStructurePropertiesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxVerticesPerCluster = copy_src->maxVerticesPerCluster;
+    maxTrianglesPerCluster = copy_src->maxTrianglesPerCluster;
+    clusterScratchByteAlignment = copy_src->clusterScratchByteAlignment;
+    clusterByteAlignment = copy_src->clusterByteAlignment;
+    clusterTemplateByteAlignment = copy_src->clusterTemplateByteAlignment;
+    clusterBottomLevelByteAlignment = copy_src->clusterBottomLevelByteAlignment;
+    clusterTemplateBoundsByteAlignment = copy_src->clusterTemplateBoundsByteAlignment;
+    maxClusterGeometryIndex = copy_src->maxClusterGeometryIndex;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkClusterAccelerationStructureClustersBottomLevelInputNV::safe_VkClusterAccelerationStructureClustersBottomLevelInputNV(
+    const VkClusterAccelerationStructureClustersBottomLevelInputNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      maxTotalClusterCount(in_struct->maxTotalClusterCount),
+      maxClusterCountPerAccelerationStructure(in_struct->maxClusterCountPerAccelerationStructure) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkClusterAccelerationStructureClustersBottomLevelInputNV::safe_VkClusterAccelerationStructureClustersBottomLevelInputNV()
+    : sType(VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV),
+      pNext(nullptr),
+      maxTotalClusterCount(),
+      maxClusterCountPerAccelerationStructure() {}
+
+safe_VkClusterAccelerationStructureClustersBottomLevelInputNV::safe_VkClusterAccelerationStructureClustersBottomLevelInputNV(
+    const safe_VkClusterAccelerationStructureClustersBottomLevelInputNV& copy_src) {
+    sType = copy_src.sType;
+    maxTotalClusterCount = copy_src.maxTotalClusterCount;
+    maxClusterCountPerAccelerationStructure = copy_src.maxClusterCountPerAccelerationStructure;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkClusterAccelerationStructureClustersBottomLevelInputNV&
+safe_VkClusterAccelerationStructureClustersBottomLevelInputNV::operator=(
+    const safe_VkClusterAccelerationStructureClustersBottomLevelInputNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxTotalClusterCount = copy_src.maxTotalClusterCount;
+    maxClusterCountPerAccelerationStructure = copy_src.maxClusterCountPerAccelerationStructure;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkClusterAccelerationStructureClustersBottomLevelInputNV::~safe_VkClusterAccelerationStructureClustersBottomLevelInputNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkClusterAccelerationStructureClustersBottomLevelInputNV::initialize(
+    const VkClusterAccelerationStructureClustersBottomLevelInputNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxTotalClusterCount = in_struct->maxTotalClusterCount;
+    maxClusterCountPerAccelerationStructure = in_struct->maxClusterCountPerAccelerationStructure;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkClusterAccelerationStructureClustersBottomLevelInputNV::initialize(
+    const safe_VkClusterAccelerationStructureClustersBottomLevelInputNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxTotalClusterCount = copy_src->maxTotalClusterCount;
+    maxClusterCountPerAccelerationStructure = copy_src->maxClusterCountPerAccelerationStructure;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkClusterAccelerationStructureTriangleClusterInputNV::safe_VkClusterAccelerationStructureTriangleClusterInputNV(
+    const VkClusterAccelerationStructureTriangleClusterInputNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      vertexFormat(in_struct->vertexFormat),
+      maxGeometryIndexValue(in_struct->maxGeometryIndexValue),
+      maxClusterUniqueGeometryCount(in_struct->maxClusterUniqueGeometryCount),
+      maxClusterTriangleCount(in_struct->maxClusterTriangleCount),
+      maxClusterVertexCount(in_struct->maxClusterVertexCount),
+      maxTotalTriangleCount(in_struct->maxTotalTriangleCount),
+      maxTotalVertexCount(in_struct->maxTotalVertexCount),
+      minPositionTruncateBitCount(in_struct->minPositionTruncateBitCount) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkClusterAccelerationStructureTriangleClusterInputNV::safe_VkClusterAccelerationStructureTriangleClusterInputNV()
+    : sType(VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV),
+      pNext(nullptr),
+      vertexFormat(),
+      maxGeometryIndexValue(),
+      maxClusterUniqueGeometryCount(),
+      maxClusterTriangleCount(),
+      maxClusterVertexCount(),
+      maxTotalTriangleCount(),
+      maxTotalVertexCount(),
+      minPositionTruncateBitCount() {}
+
+safe_VkClusterAccelerationStructureTriangleClusterInputNV::safe_VkClusterAccelerationStructureTriangleClusterInputNV(
+    const safe_VkClusterAccelerationStructureTriangleClusterInputNV& copy_src) {
+    sType = copy_src.sType;
+    vertexFormat = copy_src.vertexFormat;
+    maxGeometryIndexValue = copy_src.maxGeometryIndexValue;
+    maxClusterUniqueGeometryCount = copy_src.maxClusterUniqueGeometryCount;
+    maxClusterTriangleCount = copy_src.maxClusterTriangleCount;
+    maxClusterVertexCount = copy_src.maxClusterVertexCount;
+    maxTotalTriangleCount = copy_src.maxTotalTriangleCount;
+    maxTotalVertexCount = copy_src.maxTotalVertexCount;
+    minPositionTruncateBitCount = copy_src.minPositionTruncateBitCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkClusterAccelerationStructureTriangleClusterInputNV& safe_VkClusterAccelerationStructureTriangleClusterInputNV::operator=(
+    const safe_VkClusterAccelerationStructureTriangleClusterInputNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    vertexFormat = copy_src.vertexFormat;
+    maxGeometryIndexValue = copy_src.maxGeometryIndexValue;
+    maxClusterUniqueGeometryCount = copy_src.maxClusterUniqueGeometryCount;
+    maxClusterTriangleCount = copy_src.maxClusterTriangleCount;
+    maxClusterVertexCount = copy_src.maxClusterVertexCount;
+    maxTotalTriangleCount = copy_src.maxTotalTriangleCount;
+    maxTotalVertexCount = copy_src.maxTotalVertexCount;
+    minPositionTruncateBitCount = copy_src.minPositionTruncateBitCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkClusterAccelerationStructureTriangleClusterInputNV::~safe_VkClusterAccelerationStructureTriangleClusterInputNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkClusterAccelerationStructureTriangleClusterInputNV::initialize(
+    const VkClusterAccelerationStructureTriangleClusterInputNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    vertexFormat = in_struct->vertexFormat;
+    maxGeometryIndexValue = in_struct->maxGeometryIndexValue;
+    maxClusterUniqueGeometryCount = in_struct->maxClusterUniqueGeometryCount;
+    maxClusterTriangleCount = in_struct->maxClusterTriangleCount;
+    maxClusterVertexCount = in_struct->maxClusterVertexCount;
+    maxTotalTriangleCount = in_struct->maxTotalTriangleCount;
+    maxTotalVertexCount = in_struct->maxTotalVertexCount;
+    minPositionTruncateBitCount = in_struct->minPositionTruncateBitCount;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkClusterAccelerationStructureTriangleClusterInputNV::initialize(
+    const safe_VkClusterAccelerationStructureTriangleClusterInputNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    vertexFormat = copy_src->vertexFormat;
+    maxGeometryIndexValue = copy_src->maxGeometryIndexValue;
+    maxClusterUniqueGeometryCount = copy_src->maxClusterUniqueGeometryCount;
+    maxClusterTriangleCount = copy_src->maxClusterTriangleCount;
+    maxClusterVertexCount = copy_src->maxClusterVertexCount;
+    maxTotalTriangleCount = copy_src->maxTotalTriangleCount;
+    maxTotalVertexCount = copy_src->maxTotalVertexCount;
+    minPositionTruncateBitCount = copy_src->minPositionTruncateBitCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkClusterAccelerationStructureMoveObjectsInputNV::safe_VkClusterAccelerationStructureMoveObjectsInputNV(
+    const VkClusterAccelerationStructureMoveObjectsInputNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      type(in_struct->type),
+      noMoveOverlap(in_struct->noMoveOverlap),
+      maxMovedBytes(in_struct->maxMovedBytes) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkClusterAccelerationStructureMoveObjectsInputNV::safe_VkClusterAccelerationStructureMoveObjectsInputNV()
+    : sType(VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV),
+      pNext(nullptr),
+      type(),
+      noMoveOverlap(),
+      maxMovedBytes() {}
+
+safe_VkClusterAccelerationStructureMoveObjectsInputNV::safe_VkClusterAccelerationStructureMoveObjectsInputNV(
+    const safe_VkClusterAccelerationStructureMoveObjectsInputNV& copy_src) {
+    sType = copy_src.sType;
+    type = copy_src.type;
+    noMoveOverlap = copy_src.noMoveOverlap;
+    maxMovedBytes = copy_src.maxMovedBytes;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkClusterAccelerationStructureMoveObjectsInputNV& safe_VkClusterAccelerationStructureMoveObjectsInputNV::operator=(
+    const safe_VkClusterAccelerationStructureMoveObjectsInputNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    type = copy_src.type;
+    noMoveOverlap = copy_src.noMoveOverlap;
+    maxMovedBytes = copy_src.maxMovedBytes;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkClusterAccelerationStructureMoveObjectsInputNV::~safe_VkClusterAccelerationStructureMoveObjectsInputNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkClusterAccelerationStructureMoveObjectsInputNV::initialize(
+    const VkClusterAccelerationStructureMoveObjectsInputNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    type = in_struct->type;
+    noMoveOverlap = in_struct->noMoveOverlap;
+    maxMovedBytes = in_struct->maxMovedBytes;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkClusterAccelerationStructureMoveObjectsInputNV::initialize(
+    const safe_VkClusterAccelerationStructureMoveObjectsInputNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    type = copy_src->type;
+    noMoveOverlap = copy_src->noMoveOverlap;
+    maxMovedBytes = copy_src->maxMovedBytes;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkClusterAccelerationStructureOpInputNV::safe_VkClusterAccelerationStructureOpInputNV(
+    const VkClusterAccelerationStructureOpInputNV* in_struct, PNextCopyState*) {
+    initialize(in_struct);
+}
+
+safe_VkClusterAccelerationStructureOpInputNV::safe_VkClusterAccelerationStructureOpInputNV() : pClustersBottomLevel(nullptr) {}
+
+safe_VkClusterAccelerationStructureOpInputNV::safe_VkClusterAccelerationStructureOpInputNV(
+    const safe_VkClusterAccelerationStructureOpInputNV& copy_src) {
+    pClustersBottomLevel = nullptr;
+    pTriangleClusters = nullptr;
+    pMoveObjects = nullptr;
+    if (copy_src.pClustersBottomLevel)
+        pClustersBottomLevel = new safe_VkClusterAccelerationStructureClustersBottomLevelInputNV(*copy_src.pClustersBottomLevel);
+    if (copy_src.pTriangleClusters)
+        pTriangleClusters = new safe_VkClusterAccelerationStructureTriangleClusterInputNV(*copy_src.pTriangleClusters);
+    if (copy_src.pMoveObjects) pMoveObjects = new safe_VkClusterAccelerationStructureMoveObjectsInputNV(*copy_src.pMoveObjects);
+}
+
+safe_VkClusterAccelerationStructureOpInputNV& safe_VkClusterAccelerationStructureOpInputNV::operator=(
+    const safe_VkClusterAccelerationStructureOpInputNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pClustersBottomLevel) delete pClustersBottomLevel;
+    if (pTriangleClusters) delete pTriangleClusters;
+    if (pMoveObjects) delete pMoveObjects;
+
+    pClustersBottomLevel = nullptr;
+    pTriangleClusters = nullptr;
+    pMoveObjects = nullptr;
+    if (copy_src.pClustersBottomLevel)
+        pClustersBottomLevel = new safe_VkClusterAccelerationStructureClustersBottomLevelInputNV(*copy_src.pClustersBottomLevel);
+    if (copy_src.pTriangleClusters)
+        pTriangleClusters = new safe_VkClusterAccelerationStructureTriangleClusterInputNV(*copy_src.pTriangleClusters);
+    if (copy_src.pMoveObjects) pMoveObjects = new safe_VkClusterAccelerationStructureMoveObjectsInputNV(*copy_src.pMoveObjects);
+
+    return *this;
+}
+
+safe_VkClusterAccelerationStructureOpInputNV::~safe_VkClusterAccelerationStructureOpInputNV() {
+    if (pClustersBottomLevel) delete pClustersBottomLevel;
+    if (pTriangleClusters) delete pTriangleClusters;
+    if (pMoveObjects) delete pMoveObjects;
+}
+
+void safe_VkClusterAccelerationStructureOpInputNV::initialize(const VkClusterAccelerationStructureOpInputNV* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pClustersBottomLevel) delete pClustersBottomLevel;
+    if (pTriangleClusters) delete pTriangleClusters;
+    if (pMoveObjects) delete pMoveObjects;
+    pClustersBottomLevel = nullptr;
+    pTriangleClusters = nullptr;
+    pMoveObjects = nullptr;
+    if (in_struct->pClustersBottomLevel)
+        pClustersBottomLevel = new safe_VkClusterAccelerationStructureClustersBottomLevelInputNV(in_struct->pClustersBottomLevel);
+    if (in_struct->pTriangleClusters)
+        pTriangleClusters = new safe_VkClusterAccelerationStructureTriangleClusterInputNV(in_struct->pTriangleClusters);
+    if (in_struct->pMoveObjects) pMoveObjects = new safe_VkClusterAccelerationStructureMoveObjectsInputNV(in_struct->pMoveObjects);
+}
+
+void safe_VkClusterAccelerationStructureOpInputNV::initialize(const safe_VkClusterAccelerationStructureOpInputNV* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    pClustersBottomLevel = nullptr;
+    pTriangleClusters = nullptr;
+    pMoveObjects = nullptr;
+    if (copy_src->pClustersBottomLevel)
+        pClustersBottomLevel = new safe_VkClusterAccelerationStructureClustersBottomLevelInputNV(*copy_src->pClustersBottomLevel);
+    if (copy_src->pTriangleClusters)
+        pTriangleClusters = new safe_VkClusterAccelerationStructureTriangleClusterInputNV(*copy_src->pTriangleClusters);
+    if (copy_src->pMoveObjects) pMoveObjects = new safe_VkClusterAccelerationStructureMoveObjectsInputNV(*copy_src->pMoveObjects);
+}
+
+safe_VkClusterAccelerationStructureInputInfoNV::safe_VkClusterAccelerationStructureInputInfoNV(
+    const VkClusterAccelerationStructureInputInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      maxAccelerationStructureCount(in_struct->maxAccelerationStructureCount),
+      flags(in_struct->flags),
+      opType(in_struct->opType),
+      opMode(in_struct->opMode),
+      opInput(&in_struct->opInput) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkClusterAccelerationStructureInputInfoNV::safe_VkClusterAccelerationStructureInputInfoNV()
+    : sType(VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV),
+      pNext(nullptr),
+      maxAccelerationStructureCount(),
+      flags(),
+      opType(),
+      opMode() {}
+
+safe_VkClusterAccelerationStructureInputInfoNV::safe_VkClusterAccelerationStructureInputInfoNV(
+    const safe_VkClusterAccelerationStructureInputInfoNV& copy_src) {
+    sType = copy_src.sType;
+    maxAccelerationStructureCount = copy_src.maxAccelerationStructureCount;
+    flags = copy_src.flags;
+    opType = copy_src.opType;
+    opMode = copy_src.opMode;
+    opInput.initialize(&copy_src.opInput);
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkClusterAccelerationStructureInputInfoNV& safe_VkClusterAccelerationStructureInputInfoNV::operator=(
+    const safe_VkClusterAccelerationStructureInputInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxAccelerationStructureCount = copy_src.maxAccelerationStructureCount;
+    flags = copy_src.flags;
+    opType = copy_src.opType;
+    opMode = copy_src.opMode;
+    opInput.initialize(&copy_src.opInput);
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkClusterAccelerationStructureInputInfoNV::~safe_VkClusterAccelerationStructureInputInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkClusterAccelerationStructureInputInfoNV::initialize(const VkClusterAccelerationStructureInputInfoNV* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxAccelerationStructureCount = in_struct->maxAccelerationStructureCount;
+    flags = in_struct->flags;
+    opType = in_struct->opType;
+    opMode = in_struct->opMode;
+    opInput.initialize(&in_struct->opInput);
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkClusterAccelerationStructureInputInfoNV::initialize(const safe_VkClusterAccelerationStructureInputInfoNV* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxAccelerationStructureCount = copy_src->maxAccelerationStructureCount;
+    flags = copy_src->flags;
+    opType = copy_src->opType;
+    opMode = copy_src->opMode;
+    opInput.initialize(&copy_src->opInput);
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkClusterAccelerationStructureCommandsInfoNV::safe_VkClusterAccelerationStructureCommandsInfoNV(
+    const VkClusterAccelerationStructureCommandsInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      input(&in_struct->input),
+      dstImplicitData(in_struct->dstImplicitData),
+      scratchData(in_struct->scratchData),
+      dstAddressesArray(in_struct->dstAddressesArray),
+      dstSizesArray(in_struct->dstSizesArray),
+      srcInfosArray(in_struct->srcInfosArray),
+      srcInfosCount(in_struct->srcInfosCount),
+      addressResolutionFlags(in_struct->addressResolutionFlags) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkClusterAccelerationStructureCommandsInfoNV::safe_VkClusterAccelerationStructureCommandsInfoNV()
+    : sType(VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV),
+      pNext(nullptr),
+      dstImplicitData(),
+      scratchData(),
+      dstAddressesArray(),
+      dstSizesArray(),
+      srcInfosArray(),
+      srcInfosCount(),
+      addressResolutionFlags() {}
+
+safe_VkClusterAccelerationStructureCommandsInfoNV::safe_VkClusterAccelerationStructureCommandsInfoNV(
+    const safe_VkClusterAccelerationStructureCommandsInfoNV& copy_src) {
+    sType = copy_src.sType;
+    input.initialize(&copy_src.input);
+    dstImplicitData = copy_src.dstImplicitData;
+    scratchData = copy_src.scratchData;
+    dstAddressesArray = copy_src.dstAddressesArray;
+    dstSizesArray = copy_src.dstSizesArray;
+    srcInfosArray = copy_src.srcInfosArray;
+    srcInfosCount = copy_src.srcInfosCount;
+    addressResolutionFlags = copy_src.addressResolutionFlags;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkClusterAccelerationStructureCommandsInfoNV& safe_VkClusterAccelerationStructureCommandsInfoNV::operator=(
+    const safe_VkClusterAccelerationStructureCommandsInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    input.initialize(&copy_src.input);
+    dstImplicitData = copy_src.dstImplicitData;
+    scratchData = copy_src.scratchData;
+    dstAddressesArray = copy_src.dstAddressesArray;
+    dstSizesArray = copy_src.dstSizesArray;
+    srcInfosArray = copy_src.srcInfosArray;
+    srcInfosCount = copy_src.srcInfosCount;
+    addressResolutionFlags = copy_src.addressResolutionFlags;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkClusterAccelerationStructureCommandsInfoNV::~safe_VkClusterAccelerationStructureCommandsInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkClusterAccelerationStructureCommandsInfoNV::initialize(const VkClusterAccelerationStructureCommandsInfoNV* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    input.initialize(&in_struct->input);
+    dstImplicitData = in_struct->dstImplicitData;
+    scratchData = in_struct->scratchData;
+    dstAddressesArray = in_struct->dstAddressesArray;
+    dstSizesArray = in_struct->dstSizesArray;
+    srcInfosArray = in_struct->srcInfosArray;
+    srcInfosCount = in_struct->srcInfosCount;
+    addressResolutionFlags = in_struct->addressResolutionFlags;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkClusterAccelerationStructureCommandsInfoNV::initialize(
+    const safe_VkClusterAccelerationStructureCommandsInfoNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    input.initialize(&copy_src->input);
+    dstImplicitData = copy_src->dstImplicitData;
+    scratchData = copy_src->scratchData;
+    dstAddressesArray = copy_src->dstAddressesArray;
+    dstSizesArray = copy_src->dstSizesArray;
+    srcInfosArray = copy_src->srcInfosArray;
+    srcInfosCount = copy_src->srcInfosCount;
+    addressResolutionFlags = copy_src->addressResolutionFlags;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV::
+    safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV(
+        const VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+        bool copy_pnext)
+    : sType(in_struct->sType), allowClusterAccelerationStructure(in_struct->allowClusterAccelerationStructure) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV::
+    safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV),
+      pNext(nullptr),
+      allowClusterAccelerationStructure() {}
+
+safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV::
+    safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV(
+        const safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    allowClusterAccelerationStructure = copy_src.allowClusterAccelerationStructure;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV&
+safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV::operator=(
+    const safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    allowClusterAccelerationStructure = copy_src.allowClusterAccelerationStructure;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV::
+    ~safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV::initialize(
+    const VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    allowClusterAccelerationStructure = in_struct->allowClusterAccelerationStructure;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV::initialize(
+    const safe_VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV* copy_src,
+    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    allowClusterAccelerationStructure = copy_src->allowClusterAccelerationStructure;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV::safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV(
+    const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), partitionedAccelerationStructure(in_struct->partitionedAccelerationStructure) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV::safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV),
+      pNext(nullptr),
+      partitionedAccelerationStructure() {}
+
+safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV::safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV(
+    const safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    partitionedAccelerationStructure = copy_src.partitionedAccelerationStructure;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV&
+safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV::operator=(
+    const safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    partitionedAccelerationStructure = copy_src.partitionedAccelerationStructure;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV::
+    ~safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV::initialize(
+    const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    partitionedAccelerationStructure = in_struct->partitionedAccelerationStructure;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV::initialize(
+    const safe_VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    partitionedAccelerationStructure = copy_src->partitionedAccelerationStructure;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV::
+    safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV(
+        const VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+        bool copy_pnext)
+    : sType(in_struct->sType), maxPartitionCount(in_struct->maxPartitionCount) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV::
+    safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV),
+      pNext(nullptr),
+      maxPartitionCount() {}
+
+safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV::
+    safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV(
+        const safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    maxPartitionCount = copy_src.maxPartitionCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV&
+safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV::operator=(
+    const safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxPartitionCount = copy_src.maxPartitionCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV::
+    ~safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV::initialize(
+    const VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxPartitionCount = in_struct->maxPartitionCount;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV::initialize(
+    const safe_VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV* copy_src,
+    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxPartitionCount = copy_src->maxPartitionCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPartitionedAccelerationStructureFlagsNV::safe_VkPartitionedAccelerationStructureFlagsNV(
+    const VkPartitionedAccelerationStructureFlagsNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), enablePartitionTranslation(in_struct->enablePartitionTranslation) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPartitionedAccelerationStructureFlagsNV::safe_VkPartitionedAccelerationStructureFlagsNV()
+    : sType(VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV), pNext(nullptr), enablePartitionTranslation() {}
+
+safe_VkPartitionedAccelerationStructureFlagsNV::safe_VkPartitionedAccelerationStructureFlagsNV(
+    const safe_VkPartitionedAccelerationStructureFlagsNV& copy_src) {
+    sType = copy_src.sType;
+    enablePartitionTranslation = copy_src.enablePartitionTranslation;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPartitionedAccelerationStructureFlagsNV& safe_VkPartitionedAccelerationStructureFlagsNV::operator=(
+    const safe_VkPartitionedAccelerationStructureFlagsNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    enablePartitionTranslation = copy_src.enablePartitionTranslation;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPartitionedAccelerationStructureFlagsNV::~safe_VkPartitionedAccelerationStructureFlagsNV() { FreePnextChain(pNext); }
+
+void safe_VkPartitionedAccelerationStructureFlagsNV::initialize(const VkPartitionedAccelerationStructureFlagsNV* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    enablePartitionTranslation = in_struct->enablePartitionTranslation;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPartitionedAccelerationStructureFlagsNV::initialize(const safe_VkPartitionedAccelerationStructureFlagsNV* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    enablePartitionTranslation = copy_src->enablePartitionTranslation;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV::safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV(
+    const VkWriteDescriptorSetPartitionedAccelerationStructureNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), accelerationStructureCount(in_struct->accelerationStructureCount), pAccelerationStructures(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pAccelerationStructures) {
+        pAccelerationStructures = new VkDeviceAddress[in_struct->accelerationStructureCount];
+        memcpy((void*)pAccelerationStructures, (void*)in_struct->pAccelerationStructures,
+               sizeof(VkDeviceAddress) * in_struct->accelerationStructureCount);
+    }
+}
+
+safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV::safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV()
+    : sType(VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV),
+      pNext(nullptr),
+      accelerationStructureCount(),
+      pAccelerationStructures(nullptr) {}
+
+safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV::safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV(
+    const safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV& copy_src) {
+    sType = copy_src.sType;
+    accelerationStructureCount = copy_src.accelerationStructureCount;
+    pAccelerationStructures = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pAccelerationStructures) {
+        pAccelerationStructures = new VkDeviceAddress[copy_src.accelerationStructureCount];
+        memcpy((void*)pAccelerationStructures, (void*)copy_src.pAccelerationStructures,
+               sizeof(VkDeviceAddress) * copy_src.accelerationStructureCount);
+    }
+}
+
+safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV& safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV::operator=(
+    const safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pAccelerationStructures) delete[] pAccelerationStructures;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    accelerationStructureCount = copy_src.accelerationStructureCount;
+    pAccelerationStructures = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pAccelerationStructures) {
+        pAccelerationStructures = new VkDeviceAddress[copy_src.accelerationStructureCount];
+        memcpy((void*)pAccelerationStructures, (void*)copy_src.pAccelerationStructures,
+               sizeof(VkDeviceAddress) * copy_src.accelerationStructureCount);
+    }
+
+    return *this;
+}
+
+safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV::~safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV() {
+    if (pAccelerationStructures) delete[] pAccelerationStructures;
+    FreePnextChain(pNext);
+}
+
+void safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV::initialize(
+    const VkWriteDescriptorSetPartitionedAccelerationStructureNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pAccelerationStructures) delete[] pAccelerationStructures;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    accelerationStructureCount = in_struct->accelerationStructureCount;
+    pAccelerationStructures = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pAccelerationStructures) {
+        pAccelerationStructures = new VkDeviceAddress[in_struct->accelerationStructureCount];
+        memcpy((void*)pAccelerationStructures, (void*)in_struct->pAccelerationStructures,
+               sizeof(VkDeviceAddress) * in_struct->accelerationStructureCount);
+    }
+}
+
+void safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV::initialize(
+    const safe_VkWriteDescriptorSetPartitionedAccelerationStructureNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    accelerationStructureCount = copy_src->accelerationStructureCount;
+    pAccelerationStructures = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pAccelerationStructures) {
+        pAccelerationStructures = new VkDeviceAddress[copy_src->accelerationStructureCount];
+        memcpy((void*)pAccelerationStructures, (void*)copy_src->pAccelerationStructures,
+               sizeof(VkDeviceAddress) * copy_src->accelerationStructureCount);
+    }
+}
+
+safe_VkPartitionedAccelerationStructureInstancesInputNV::safe_VkPartitionedAccelerationStructureInstancesInputNV(
+    const VkPartitionedAccelerationStructureInstancesInputNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      instanceCount(in_struct->instanceCount),
+      maxInstancePerPartitionCount(in_struct->maxInstancePerPartitionCount),
+      partitionCount(in_struct->partitionCount),
+      maxInstanceInGlobalPartitionCount(in_struct->maxInstanceInGlobalPartitionCount) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPartitionedAccelerationStructureInstancesInputNV::safe_VkPartitionedAccelerationStructureInstancesInputNV()
+    : sType(VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV),
+      pNext(nullptr),
+      flags(),
+      instanceCount(),
+      maxInstancePerPartitionCount(),
+      partitionCount(),
+      maxInstanceInGlobalPartitionCount() {}
+
+safe_VkPartitionedAccelerationStructureInstancesInputNV::safe_VkPartitionedAccelerationStructureInstancesInputNV(
+    const safe_VkPartitionedAccelerationStructureInstancesInputNV& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    instanceCount = copy_src.instanceCount;
+    maxInstancePerPartitionCount = copy_src.maxInstancePerPartitionCount;
+    partitionCount = copy_src.partitionCount;
+    maxInstanceInGlobalPartitionCount = copy_src.maxInstanceInGlobalPartitionCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPartitionedAccelerationStructureInstancesInputNV& safe_VkPartitionedAccelerationStructureInstancesInputNV::operator=(
+    const safe_VkPartitionedAccelerationStructureInstancesInputNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    instanceCount = copy_src.instanceCount;
+    maxInstancePerPartitionCount = copy_src.maxInstancePerPartitionCount;
+    partitionCount = copy_src.partitionCount;
+    maxInstanceInGlobalPartitionCount = copy_src.maxInstanceInGlobalPartitionCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPartitionedAccelerationStructureInstancesInputNV::~safe_VkPartitionedAccelerationStructureInstancesInputNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPartitionedAccelerationStructureInstancesInputNV::initialize(
+    const VkPartitionedAccelerationStructureInstancesInputNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    instanceCount = in_struct->instanceCount;
+    maxInstancePerPartitionCount = in_struct->maxInstancePerPartitionCount;
+    partitionCount = in_struct->partitionCount;
+    maxInstanceInGlobalPartitionCount = in_struct->maxInstanceInGlobalPartitionCount;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPartitionedAccelerationStructureInstancesInputNV::initialize(
+    const safe_VkPartitionedAccelerationStructureInstancesInputNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    instanceCount = copy_src->instanceCount;
+    maxInstancePerPartitionCount = copy_src->maxInstancePerPartitionCount;
+    partitionCount = copy_src->partitionCount;
+    maxInstanceInGlobalPartitionCount = copy_src->maxInstanceInGlobalPartitionCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkBuildPartitionedAccelerationStructureInfoNV::safe_VkBuildPartitionedAccelerationStructureInfoNV(
+    const VkBuildPartitionedAccelerationStructureInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      input(&in_struct->input),
+      srcAccelerationStructureData(in_struct->srcAccelerationStructureData),
+      dstAccelerationStructureData(in_struct->dstAccelerationStructureData),
+      scratchData(in_struct->scratchData),
+      srcInfos(in_struct->srcInfos),
+      srcInfosCount(in_struct->srcInfosCount) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkBuildPartitionedAccelerationStructureInfoNV::safe_VkBuildPartitionedAccelerationStructureInfoNV()
+    : sType(VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV),
+      pNext(nullptr),
+      srcAccelerationStructureData(),
+      dstAccelerationStructureData(),
+      scratchData(),
+      srcInfos(),
+      srcInfosCount() {}
+
+safe_VkBuildPartitionedAccelerationStructureInfoNV::safe_VkBuildPartitionedAccelerationStructureInfoNV(
+    const safe_VkBuildPartitionedAccelerationStructureInfoNV& copy_src) {
+    sType = copy_src.sType;
+    input.initialize(&copy_src.input);
+    srcAccelerationStructureData = copy_src.srcAccelerationStructureData;
+    dstAccelerationStructureData = copy_src.dstAccelerationStructureData;
+    scratchData = copy_src.scratchData;
+    srcInfos = copy_src.srcInfos;
+    srcInfosCount = copy_src.srcInfosCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBuildPartitionedAccelerationStructureInfoNV& safe_VkBuildPartitionedAccelerationStructureInfoNV::operator=(
+    const safe_VkBuildPartitionedAccelerationStructureInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    input.initialize(&copy_src.input);
+    srcAccelerationStructureData = copy_src.srcAccelerationStructureData;
+    dstAccelerationStructureData = copy_src.dstAccelerationStructureData;
+    scratchData = copy_src.scratchData;
+    srcInfos = copy_src.srcInfos;
+    srcInfosCount = copy_src.srcInfosCount;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkBuildPartitionedAccelerationStructureInfoNV::~safe_VkBuildPartitionedAccelerationStructureInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkBuildPartitionedAccelerationStructureInfoNV::initialize(const VkBuildPartitionedAccelerationStructureInfoNV* in_struct,
+                                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    input.initialize(&in_struct->input);
+    srcAccelerationStructureData = in_struct->srcAccelerationStructureData;
+    dstAccelerationStructureData = in_struct->dstAccelerationStructureData;
+    scratchData = in_struct->scratchData;
+    srcInfos = in_struct->srcInfos;
+    srcInfosCount = in_struct->srcInfosCount;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkBuildPartitionedAccelerationStructureInfoNV::initialize(
+    const safe_VkBuildPartitionedAccelerationStructureInfoNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    input.initialize(&copy_src->input);
+    srcAccelerationStructureData = copy_src->srcAccelerationStructureData;
+    dstAccelerationStructureData = copy_src->dstAccelerationStructureData;
+    scratchData = copy_src->scratchData;
+    srcInfos = copy_src->srcInfos;
+    srcInfosCount = copy_src->srcInfosCount;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA::safe_VkPhysicalDeviceImageAlignmentControlFeaturesMESA(
     const VkPhysicalDeviceImageAlignmentControlFeaturesMESA* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
     bool copy_pnext)

From c4ede3c60031486d611d5f9073abac7901f1c69a Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Fri, 21 Feb 2025 08:20:49 -0800
Subject: [PATCH 082/106] build: Update to header 1.4.309

---
 .github/workflows/ci.yml                    |  2 +-
 BUILD.md                                    |  2 +-
 CMakeLists.txt                              |  2 +-
 include/vulkan/utility/vk_safe_struct.hpp   | 34 +++++++
 include/vulkan/utility/vk_struct_helper.hpp |  2 +
 include/vulkan/vk_enum_string_helper.h      |  6 ++
 scripts/known_good.json                     |  2 +-
 src/vulkan/vk_safe_struct_utils.cpp         | 24 +++++
 src/vulkan/vk_safe_struct_vendor.cpp        | 98 +++++++++++++++++++++
 9 files changed, 168 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 4d71374..2828f5a 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -38,7 +38,7 @@ jobs:
         if: matrix.os == 'ubuntu-20.04'
         uses: lukka/get-cmake@latest
         with:
-          cmakeVersion: 3.17.2
+          cmakeVersion: 3.22.1
       - run: cmake -S. -B build -D VUL_WERROR=ON -D BUILD_TESTS=ON -D CMAKE_BUILD_TYPE=${{matrix.config}} -D UPDATE_DEPS=ON
       - run: cmake --build build --config ${{matrix.config}} --verbose
       - run: ctest -C ${{matrix.config}} --output-on-failure
diff --git a/BUILD.md b/BUILD.md
index 85e420a..8b57327 100644
--- a/BUILD.md
+++ b/BUILD.md
@@ -16,7 +16,7 @@ This document contains the instructions for building this repository on Linux, m
 
 ## Requirements
 
-1. CMake >= 3.17.2
+1. CMake >= 3.22.1
 2. C++ >= c++17 compiler. See platform-specific sections below for supported compiler versions.
 3. Python >= 3.8
 
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 674dcfe..6dc4f23 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -3,7 +3,7 @@
 # Copyright 2023 LunarG, Inc.
 #
 # SPDX-License-Identifier: Apache-2.0
-cmake_minimum_required(VERSION 3.17.2)
+cmake_minimum_required(VERSION 3.22.1)
 
 project(VUL LANGUAGES CXX)
 
diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index 9f44f69..f569902 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -20291,6 +20291,40 @@ struct safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT {
         return reinterpret_cast<VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT const*>(this);
     }
 };
+struct safe_VkSetPresentConfigNV {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t numFramesPerBatch;
+    uint32_t presentConfigFeedback;
+
+    safe_VkSetPresentConfigNV(const VkSetPresentConfigNV* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSetPresentConfigNV(const safe_VkSetPresentConfigNV& copy_src);
+    safe_VkSetPresentConfigNV& operator=(const safe_VkSetPresentConfigNV& copy_src);
+    safe_VkSetPresentConfigNV();
+    ~safe_VkSetPresentConfigNV();
+    void initialize(const VkSetPresentConfigNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSetPresentConfigNV* copy_src, PNextCopyState* copy_state = {});
+    VkSetPresentConfigNV* ptr() { return reinterpret_cast<VkSetPresentConfigNV*>(this); }
+    VkSetPresentConfigNV const* ptr() const { return reinterpret_cast<VkSetPresentConfigNV const*>(this); }
+};
+struct safe_VkPhysicalDevicePresentMeteringFeaturesNV {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 presentMetering;
+
+    safe_VkPhysicalDevicePresentMeteringFeaturesNV(const VkPhysicalDevicePresentMeteringFeaturesNV* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDevicePresentMeteringFeaturesNV(const safe_VkPhysicalDevicePresentMeteringFeaturesNV& copy_src);
+    safe_VkPhysicalDevicePresentMeteringFeaturesNV& operator=(const safe_VkPhysicalDevicePresentMeteringFeaturesNV& copy_src);
+    safe_VkPhysicalDevicePresentMeteringFeaturesNV();
+    ~safe_VkPhysicalDevicePresentMeteringFeaturesNV();
+    void initialize(const VkPhysicalDevicePresentMeteringFeaturesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePresentMeteringFeaturesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePresentMeteringFeaturesNV* ptr() { return reinterpret_cast<VkPhysicalDevicePresentMeteringFeaturesNV*>(this); }
+    VkPhysicalDevicePresentMeteringFeaturesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePresentMeteringFeaturesNV const*>(this);
+    }
+};
 struct safe_VkAccelerationStructureGeometryTrianglesDataKHR {
     VkStructureType sType;
     const void* pNext{};
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index ea915c6..aed8928 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -1051,6 +1051,8 @@ template <> inline VkStructureType GetSType<VkMemoryMetalHandlePropertiesEXT>()
 template <> inline VkStructureType GetSType<VkMemoryGetMetalHandleInfoEXT>() { return VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT; }
 #endif  // VK_USE_PLATFORM_METAL_EXT
 template <> inline VkStructureType GetSType<VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT; }
+template <> inline VkStructureType GetSType<VkSetPresentConfigNV>() { return VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDevicePresentMeteringFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryTrianglesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryAabbsDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryInstancesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index 3e3b6bd..ece5b97 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -2128,6 +2128,12 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT";
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV:
+            return "VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV";
+#endif  // VK_ENABLE_BETA_EXTENSIONS
         default:
             return "Unhandled VkStructureType";
     }
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 9bed905..604ac77 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.4.307"
+            "commit": "v1.4.309"
         },
         {
             "name": "googletest",
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index 4790801..4dc27fe 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -1719,6 +1719,12 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV:
                 safe_pNext = new safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV(reinterpret_cast<const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV:
+                safe_pNext = new safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV(reinterpret_cast<const VkAccelerationStructureGeometryLinearSweptSpheresDataNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV:
+                safe_pNext = new safe_VkAccelerationStructureGeometrySpheresDataNV(reinterpret_cast<const VkAccelerationStructureGeometrySpheresDataNV *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
                 safe_pNext = new safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(reinterpret_cast<const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *>(pNext), copy_state, false);
                 break;
@@ -2019,6 +2025,12 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
                 safe_pNext = new safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV:
+                safe_pNext = new safe_VkSetPresentConfigNV(reinterpret_cast<const VkSetPresentConfigNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV:
+                safe_pNext = new safe_VkPhysicalDevicePresentMeteringFeaturesNV(reinterpret_cast<const VkPhysicalDevicePresentMeteringFeaturesNV *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
                 safe_pNext = new safe_VkWriteDescriptorSetAccelerationStructureKHR(reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR *>(pNext), copy_state, false);
                 break;
@@ -3754,6 +3766,12 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV:
             delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV *>(header);
             break;
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV:
+            delete reinterpret_cast<safe_VkAccelerationStructureGeometryLinearSweptSpheresDataNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV:
+            delete reinterpret_cast<safe_VkAccelerationStructureGeometrySpheresDataNV *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
             delete reinterpret_cast<safe_VkPhysicalDeviceLinearColorAttachmentFeaturesNV *>(header);
             break;
@@ -4054,6 +4072,12 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
             delete reinterpret_cast<safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *>(header);
             break;
+        case VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV:
+            delete reinterpret_cast<safe_VkSetPresentConfigNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV:
+            delete reinterpret_cast<safe_VkPhysicalDevicePresentMeteringFeaturesNV *>(header);
+            break;
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
             delete reinterpret_cast<safe_VkWriteDescriptorSetAccelerationStructureKHR *>(header);
             break;
diff --git a/src/vulkan/vk_safe_struct_vendor.cpp b/src/vulkan/vk_safe_struct_vendor.cpp
index 5d20575..6e7b5f6 100644
--- a/src/vulkan/vk_safe_struct_vendor.cpp
+++ b/src/vulkan/vk_safe_struct_vendor.cpp
@@ -17715,6 +17715,104 @@ void safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM::initialize(
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkSetPresentConfigNV::safe_VkSetPresentConfigNV(const VkSetPresentConfigNV* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      numFramesPerBatch(in_struct->numFramesPerBatch),
+      presentConfigFeedback(in_struct->presentConfigFeedback) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSetPresentConfigNV::safe_VkSetPresentConfigNV()
+    : sType(VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV), pNext(nullptr), numFramesPerBatch(), presentConfigFeedback() {}
+
+safe_VkSetPresentConfigNV::safe_VkSetPresentConfigNV(const safe_VkSetPresentConfigNV& copy_src) {
+    sType = copy_src.sType;
+    numFramesPerBatch = copy_src.numFramesPerBatch;
+    presentConfigFeedback = copy_src.presentConfigFeedback;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSetPresentConfigNV& safe_VkSetPresentConfigNV::operator=(const safe_VkSetPresentConfigNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    numFramesPerBatch = copy_src.numFramesPerBatch;
+    presentConfigFeedback = copy_src.presentConfigFeedback;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSetPresentConfigNV::~safe_VkSetPresentConfigNV() { FreePnextChain(pNext); }
+
+void safe_VkSetPresentConfigNV::initialize(const VkSetPresentConfigNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    numFramesPerBatch = in_struct->numFramesPerBatch;
+    presentConfigFeedback = in_struct->presentConfigFeedback;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSetPresentConfigNV::initialize(const safe_VkSetPresentConfigNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    numFramesPerBatch = copy_src->numFramesPerBatch;
+    presentConfigFeedback = copy_src->presentConfigFeedback;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDevicePresentMeteringFeaturesNV::safe_VkPhysicalDevicePresentMeteringFeaturesNV(
+    const VkPhysicalDevicePresentMeteringFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), presentMetering(in_struct->presentMetering) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePresentMeteringFeaturesNV::safe_VkPhysicalDevicePresentMeteringFeaturesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV), pNext(nullptr), presentMetering() {}
+
+safe_VkPhysicalDevicePresentMeteringFeaturesNV::safe_VkPhysicalDevicePresentMeteringFeaturesNV(
+    const safe_VkPhysicalDevicePresentMeteringFeaturesNV& copy_src) {
+    sType = copy_src.sType;
+    presentMetering = copy_src.presentMetering;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePresentMeteringFeaturesNV& safe_VkPhysicalDevicePresentMeteringFeaturesNV::operator=(
+    const safe_VkPhysicalDevicePresentMeteringFeaturesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    presentMetering = copy_src.presentMetering;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePresentMeteringFeaturesNV::~safe_VkPhysicalDevicePresentMeteringFeaturesNV() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDevicePresentMeteringFeaturesNV::initialize(const VkPhysicalDevicePresentMeteringFeaturesNV* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    presentMetering = in_struct->presentMetering;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePresentMeteringFeaturesNV::initialize(const safe_VkPhysicalDevicePresentMeteringFeaturesNV* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    presentMetering = copy_src->presentMetering;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 }  // namespace vku
 
 // NOLINTEND

From 42b34ac73eecc77adb585c0060be12560e4c8842 Mon Sep 17 00:00:00 2001
From: spencer-lunarg <spencer@lunarg.com>
Date: Fri, 21 Feb 2025 13:31:47 -0500
Subject: [PATCH 083/106] scripts: Use new VulkanObject from headers

---
 scripts/generate_source.py                    |   4 +-
 scripts/generators/base_generator.py          | 782 ------------------
 .../generators/dispatch_table_generator.py    |   2 +-
 .../enum_string_helper_generator.py           |   2 +-
 scripts/generators/format_utils_generator.py  |   4 +-
 scripts/generators/safe_struct_generator.py   |   4 +-
 scripts/generators/struct_helper_generator.py |   2 +-
 scripts/generators/vulkan_object.py           | 405 ---------
 8 files changed, 9 insertions(+), 1196 deletions(-)
 delete mode 100644 scripts/generators/base_generator.py
 delete mode 100644 scripts/generators/vulkan_object.py

diff --git a/scripts/generate_source.py b/scripts/generate_source.py
index 01cf652..b7216b9 100755
--- a/scripts/generate_source.py
+++ b/scripts/generate_source.py
@@ -33,7 +33,7 @@ def RunGenerators(api: str, registry: str, targetFilter: str) -> None:
         print("Inside Vulkan-Headers there is a registry/reg.py file that is used.")
         sys.exit(1) # Return without call stack so easy to spot error
 
-    from generators.base_generator import BaseGeneratorOptions
+    from base_generator import BaseGeneratorOptions
     from generators.dispatch_table_generator import DispatchTableOutputGenerator
     from generators.enum_string_helper_generator import EnumStringHelperOutputGenerator
     from generators.format_utils_generator import FormatUtilsOutputGenerator
@@ -42,7 +42,7 @@ def RunGenerators(api: str, registry: str, targetFilter: str) -> None:
 
     # These set fields that are needed by both OutputGenerator and BaseGenerator,
     # but are uniform and don't need to be set at a per-generated file level
-    from generators.base_generator import (SetTargetApiName, SetMergedApiNames)
+    from base_generator import (SetTargetApiName, SetMergedApiNames)
     SetTargetApiName(api)
 
     # Build up a list of all generators and custom options
diff --git a/scripts/generators/base_generator.py b/scripts/generators/base_generator.py
deleted file mode 100644
index 8d4ee06..0000000
--- a/scripts/generators/base_generator.py
+++ /dev/null
@@ -1,782 +0,0 @@
-#!/usr/bin/python3 -i
-#
-# Copyright (c) 2023-2025 Valve Corporation
-# Copyright (c) 2023-2025 LunarG, Inc.
-# Copyright (c) 2023-2025 RasterGrid Kft.
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import pickle
-import os
-import tempfile
-from generators.vulkan_object import (VulkanObject,
-    Extension, Version, Handle, Param, Queues, CommandScope, Command,
-    EnumField, Enum, Flag, Bitmask, Member, Struct,
-    FormatComponent, FormatPlane, Format,
-    SyncSupport, SyncEquivalent, SyncStage, SyncAccess, SyncPipelineStage, SyncPipeline,
-    SpirvEnables, Spirv)
-
-# These live in the Vulkan-Docs repo, but are pulled in via the
-# Vulkan-Headers/registry folder
-from generator import OutputGenerator, GeneratorOptions, write
-from vkconventions import VulkanConventions
-
-# An API style convention object
-vulkanConventions = VulkanConventions()
-
-# Helpers to keep things cleaner
-def splitIfGet(elem, name):
-    return elem.get(name).split(',') if elem.get(name) is not None and elem.get(name) != '' else None
-
-def textIfFind(elem, name):
-    return elem.find(name).text if elem.find(name) is not None else None
-
-def intIfGet(elem, name):
-    return None if elem.get(name) is None else int(elem.get(name), 0)
-
-def boolGet(elem, name) -> bool:
-    return elem.get(name) is not None and elem.get(name) == "true"
-
-def getQueues(elem) -> Queues:
-    queues = 0
-    queues_list = splitIfGet(elem, 'queues')
-    if queues_list is not None:
-        queues |= Queues.TRANSFER if 'transfer' in queues_list else 0
-        queues |= Queues.GRAPHICS if 'graphics' in queues_list else 0
-        queues |= Queues.COMPUTE if 'compute' in queues_list else 0
-        queues |= Queues.PROTECTED if 'protected' in queues_list else 0
-        queues |= Queues.SPARSE_BINDING if 'sparse_binding' in queues_list else 0
-        queues |= Queues.OPTICAL_FLOW if 'opticalflow' in queues_list else 0
-        queues |= Queues.DECODE if 'decode' in queues_list else 0
-        queues |= Queues.ENCODE if 'encode' in queues_list else 0
-    return queues
-
-# Shared object used by Sync elements that don't have ones
-maxSyncSupport = SyncSupport(None, None, True)
-maxSyncEquivalent = SyncEquivalent(None, None, True)
-
-# Helpers to set GeneratorOptions options globally
-def SetOutputFileName(fileName: str) -> None:
-    global globalFileName
-    globalFileName = fileName
-
-def SetOutputDirectory(directory: str) -> None:
-    global globalDirectory
-    globalDirectory = directory
-
-def SetTargetApiName(apiname: str) -> None:
-    global globalApiName
-    globalApiName = apiname
-
-def SetMergedApiNames(names: str) -> None:
-    global mergedApiNames
-    mergedApiNames = names
-
-cachingEnabled = False
-def EnableCaching() -> None:
-    global cachingEnabled
-    cachingEnabled = True
-
-# This class is a container for any source code, data, or other behavior that is necessary to
-# customize the generator script for a specific target API variant (e.g. Vulkan SC). As such,
-# all of these API-specific interfaces and their use in the generator script are part of the
-# contract between this repository and its downstream users. Changing or removing any of these
-# interfaces or their use in the generator script will have downstream effects and thus
-# should be avoided unless absolutely necessary.
-class APISpecific:
-    # Version object factory method
-    @staticmethod
-    def createApiVersion(targetApiName: str, name: str) -> Version:
-        match targetApiName:
-
-            # Vulkan specific API version creation
-            case 'vulkan':
-                nameApi = name.replace('VK_', 'VK_API_')
-                nameString = f'"{name}"'
-                return Version(name, nameString, nameApi)
-
-
-# This Generator Option is used across all generators.
-# After years of use, it has shown that most the options are unified across each generator (file)
-# as it is easier to modifiy things per-file that need the difference
-class BaseGeneratorOptions(GeneratorOptions):
-    def __init__(self,
-                 customFileName = None,
-                 customDirectory = None,
-                 customApiName = None):
-        GeneratorOptions.__init__(self,
-                conventions = vulkanConventions,
-                filename = customFileName if customFileName else globalFileName,
-                directory = customDirectory if customDirectory else globalDirectory,
-                apiname = customApiName if customApiName else globalApiName,
-                mergeApiNames = mergedApiNames,
-                defaultExtensions = customApiName if customApiName else globalApiName,
-                emitExtensions = '.*',
-                emitSpirv = '.*',
-                emitFormats = '.*')
-        # These are used by the generator.py script
-        self.apicall         = 'VKAPI_ATTR '
-        self.apientry        = 'VKAPI_CALL '
-        self.apientryp       = 'VKAPI_PTR *'
-        self.alignFuncParam  = 48
-
-#
-# This object handles all the parsing from reg.py generator scripts in the Vulkan-Headers
-# It will grab all the data and form it into a single object the rest of the generators will use
-class BaseGenerator(OutputGenerator):
-    def __init__(self):
-        OutputGenerator.__init__(self, None, None, None)
-        self.vk = VulkanObject()
-        self.targetApiName = globalApiName
-
-        # reg.py has a `self.featureName` but this is nicer because
-        # it will be either the Version or Extension object
-        self.currentExtension = None
-        self.currentVersion = None
-
-        # Will map alias to promoted name
-        #   ex. ['VK_FILTER_CUBIC_IMG' : 'VK_FILTER_CUBIC_EXT']
-        # When generating any code, there is no reason so use the old name
-        self.enumAliasMap = dict()
-        self.enumFieldAliasMap = dict()
-        self.bitmaskAliasMap = dict()
-        self.flagAliasMap = dict()
-        self.structAliasMap = dict()
-
-    def write(self, data):
-        # Prevents having to check before writting
-        if data is not None and data != "":
-            write(data, file=self.outFile)
-
-
-    def beginFile(self, genOpts):
-        OutputGenerator.beginFile(self, genOpts)
-        self.filename = genOpts.filename
-
-        # No gen*() command to get these, so do it manually
-        for platform in self.registry.tree.findall('platforms/platform'):
-            self.vk.platforms[platform.get('name')] = platform.get('protect')
-
-        for tags in self.registry.tree.findall('tags'):
-            for tag in tags.findall('tag'):
-                self.vk.vendorTags.append(tag.get('name'))
-
-        # No way known to get this from the XML
-        self.vk.queueBits[Queues.TRANSFER]       = 'VK_QUEUE_TRANSFER_BIT'
-        self.vk.queueBits[Queues.GRAPHICS]       = 'VK_QUEUE_GRAPHICS_BIT'
-        self.vk.queueBits[Queues.COMPUTE]        = 'VK_QUEUE_COMPUTE_BIT'
-        self.vk.queueBits[Queues.PROTECTED]      = 'VK_QUEUE_PROTECTED_BIT'
-        self.vk.queueBits[Queues.SPARSE_BINDING] = 'VK_QUEUE_SPARSE_BINDING_BIT'
-        self.vk.queueBits[Queues.OPTICAL_FLOW]   = 'VK_QUEUE_OPTICAL_FLOW_BIT_NV'
-        self.vk.queueBits[Queues.DECODE]         = 'VK_QUEUE_VIDEO_DECODE_BIT_KHR'
-        self.vk.queueBits[Queues.ENCODE]         = 'VK_QUEUE_VIDEO_ENCODE_BIT_KHR'
-
-    # This function should be overloaded
-    def generate(self):
-        print("WARNING: This should not be called from the child class")
-        return
-
-    # This function is dense, it does all the magic to set the right extensions dependencies!
-    #
-    # The issue is if 2 extension expose a command, genCmd() will only
-    # show one of the extension, at endFile() we can finally go through
-    # and update which things depend on which extensions
-    #
-    # self.featureDictionary is built for use in the reg.py framework
-    # Details found in Vulkan-Docs/scripts/scriptgenerator.py
-    def applyExtensionDependency(self):
-        for extension in self.vk.extensions.values():
-            # dict.key() can be None, so need to double loop
-            dict = self.featureDictionary[extension.name]['command']
-
-            # "required" == None
-            #         or
-            #  an additional feature dependency, which is a boolean expression of
-            #  one or more extension and/or core version names
-            for required in dict:
-                for commandName in dict[required]:
-                    # Skip commands removed in the target API
-                    # This check is needed because parts of the base generator code bypass the
-                    # dependency resolution logic in the registry tooling and thus the generator
-                    # may attempt to generate code for commands which are not supported in the
-                    # target API variant, thus this check needs to happen even if any specific
-                    # target API variant may not specifically need it
-                    if not commandName in self.vk.commands:
-                        continue
-
-                    command = self.vk.commands[commandName]
-                    # Make sure list is unique
-                    command.extensions.extend([extension] if extension not in command.extensions else [])
-                    extension.commands.extend([command] if command not in extension.commands else [])
-
-            # While genGroup() will call twice with aliased value, it doesn't provide all the information we need
-            dict = self.featureDictionary[extension.name]['enumconstant']
-            for required in dict:
-                # group can be a Enum or Bitmask
-                for group in dict[required]:
-                    if group in self.vk.enums:
-                        if group not in extension.enumFields:
-                            extension.enumFields[group] = [] # Dict needs init
-                        enum = self.vk.enums[group]
-                        # Need to convert all alias so they match what is in EnumField
-                        enumList = list(map(lambda x: x if x not in self.enumFieldAliasMap else self.enumFieldAliasMap[x], dict[required][group]))
-
-                        for enumField in [x for x in enum.fields if x.name in enumList]:
-                            # Make sure list is unique
-                            enum.fieldExtensions.extend([extension] if extension not in enum.fieldExtensions else [])
-                            enumField.extensions.extend([extension] if extension not in enumField.extensions else [])
-                            extension.enumFields[group].extend([enumField] if enumField not in extension.enumFields[group] else [])
-                    if group in self.vk.bitmasks:
-                        if group not in extension.flags:
-                            extension.flags[group] = [] # Dict needs init
-                        bitmask = self.vk.bitmasks[group]
-                        # Need to convert all alias so they match what is in Flags
-                        flagList = list(map(lambda x: x if x not in self.flagAliasMap else self.flagAliasMap[x], dict[required][group]))
-
-                        for flags in [x for x in bitmask.flags if x.name in flagList]:
-                            # Make sure list is unique
-                            bitmask.flagExtensions.extend([extension] if extension not in bitmask.flagExtensions else [])
-                            flags.extensions.extend([extension] if extension not in flags.extensions else [])
-                            extension.flags[group].extend([flags] if flags not in extension.flags[group] else [])
-
-        # Need to do 'enum'/'bitmask' after 'enumconstant' has applied everything so we can add implicit extensions
-        #
-        # Sometimes two extensions enable an Enum, but the newer extension version has extra flags allowed
-        # This information seems to be implicit, so need to update it here
-        # Go through each Flag and append the Enum extension to it
-        #
-        # ex. VkAccelerationStructureTypeKHR where GENERIC_KHR is not allowed with just VK_NV_ray_tracing
-        # This only works because the values are aliased as well, making the KHR a superset enum
-        for extension in self.vk.extensions.values():
-            dict = self.featureDictionary[extension.name]['enum']
-            for required in dict:
-                for group in dict[required]:
-                    for enumName in dict[required][group]:
-                        isAlias = enumName in self.enumAliasMap
-                        enumName = self.enumAliasMap[enumName] if isAlias else enumName
-                        if enumName in self.vk.enums:
-                            enum = self.vk.enums[enumName]
-                            enum.extensions.extend([extension] if extension not in enum.extensions else [])
-                            extension.enums.extend([enum] if enum not in extension.enums else [])
-                            # Update fields with implicit base extension
-                            if isAlias:
-                                continue
-                            enum.fieldExtensions.extend([extension] if extension not in enum.fieldExtensions else [])
-                            for enumField in [x for x in enum.fields if (not x.extensions or (x.extensions and all(e in enum.extensions for e in x.extensions)))]:
-                                enumField.extensions.extend([extension] if extension not in enumField.extensions else [])
-                                if enumName not in extension.enumFields:
-                                    extension.enumFields[enumName] = [] # Dict needs init
-                                extension.enumFields[enumName].extend([enumField] if enumField not in extension.enumFields[enumName] else [])
-
-            dict = self.featureDictionary[extension.name]['bitmask']
-            for required in dict:
-                for group in dict[required]:
-                    for bitmaskName in dict[required][group]:
-                        bitmaskName = bitmaskName.replace('Flags', 'FlagBits') # Works since Flags isn't repeated in name
-                        isAlias = bitmaskName in self.bitmaskAliasMap
-                        bitmaskName = self.bitmaskAliasMap[bitmaskName] if isAlias else bitmaskName
-                        if bitmaskName in self.vk.bitmasks:
-                            bitmask = self.vk.bitmasks[bitmaskName]
-                            bitmask.extensions.extend([extension] if extension not in bitmask.extensions else [])
-                            extension.bitmasks.extend([bitmask] if bitmask not in extension.bitmasks else [])
-                            # Update flags with implicit base extension
-                            if isAlias:
-                                continue
-                            bitmask.flagExtensions.extend([extension] if extension not in bitmask.flagExtensions else [])
-                            for flag in [x for x in bitmask.flags if (not x.extensions or (x.extensions and all(e in bitmask.extensions for e in x.extensions)))]:
-                                flag.extensions.extend([extension] if extension not in flag.extensions else [])
-                                if bitmaskName not in extension.flags:
-                                    extension.flags[bitmaskName] = [] # Dict needs init
-                                extension.flags[bitmaskName].extend([flag] if flag not in extension.flags[bitmaskName] else [])
-
-        # Some structs (ex VkAttachmentSampleCountInfoAMD) can have multiple alias pointing to same extension
-        for extension in self.vk.extensions.values():
-            dict = self.featureDictionary[extension.name]['struct']
-            for required in dict:
-                for group in dict[required]:
-                    for structName in dict[required][group]:
-                        isAlias = structName in self.structAliasMap
-                        structName = self.structAliasMap[structName] if isAlias else structName
-                        # An EXT struct can alias a KHR struct,
-                        # that in turns aliaes a core struct
-                        # => Try to propagate aliasing, it can safely result in a no-op
-                        isAlias = structName in self.structAliasMap
-                        structName = self.structAliasMap[structName] if isAlias else structName
-                        if structName in self.vk.structs:
-                            struct = self.vk.structs[structName]
-                            struct.extensions.extend([extension] if extension not in struct.extensions else [])
-
-        # While we update struct alias inside other structs, the command itself might have the struct as a first level param.
-        # We use this time to update params to have the promoted name
-        # Example - https://github.com/KhronosGroup/Vulkan-ValidationLayers/issues/9322
-        for command in self.vk.commands.values():
-            for member in command.params:
-                if member.type in self.structAliasMap:
-                    member.type = self.structAliasMap[member.type]
-
-    def endFile(self):
-        # This is the point were reg.py has ran, everything is collected
-        # We do some post processing now
-        self.applyExtensionDependency()
-
-        # Use structs and commands to find which things are returnedOnly
-        for struct in [x for x in self.vk.structs.values() if not x.returnedOnly]:
-            for enum in [self.vk.enums[x.type] for x in struct.members if x.type in self.vk.enums]:
-                enum.returnedOnly = False
-            for bitmask in [self.vk.bitmasks[x.type] for x in struct.members if x.type in self.vk.bitmasks]:
-                bitmask.returnedOnly = False
-            for bitmask in [self.vk.bitmasks[x.type.replace('Flags', 'FlagBits')] for x in struct.members if x.type.replace('Flags', 'FlagBits') in self.vk.bitmasks]:
-                bitmask.returnedOnly = False
-        for command in self.vk.commands.values():
-            for enum in [self.vk.enums[x.type] for x in command.params if x.type in self.vk.enums]:
-                enum.returnedOnly = False
-            for bitmask in [self.vk.bitmasks[x.type] for x in command.params if x.type in self.vk.bitmasks]:
-                bitmask.returnedOnly = False
-            for bitmask in [self.vk.bitmasks[x.type.replace('Flags', 'FlagBits')] for x in command.params if x.type.replace('Flags', 'FlagBits') in self.vk.bitmasks]:
-                bitmask.returnedOnly = False
-
-        # Turn handle parents into pointers to classess
-        for handle in [x for x in self.vk.handles.values() if x.parent is not None]:
-            handle.parent = self.vk.handles[handle.parent]
-        # search up parent chain to see if instance or device
-        for handle in [x for x in self.vk.handles.values()]:
-            next_parent = handle.parent
-            while (not handle.instance and not handle.device):
-                handle.instance = next_parent.name == 'VkInstance'
-                handle.device = next_parent.name == 'VkDevice'
-                next_parent = next_parent.parent
-
-        maxSyncSupport.queues = Queues.ALL
-        maxSyncSupport.stages = self.vk.bitmasks['VkPipelineStageFlagBits2'].flags
-        maxSyncEquivalent.accesses = self.vk.bitmasks['VkAccessFlagBits2'].flags
-        maxSyncEquivalent.stages = self.vk.bitmasks['VkPipelineStageFlagBits2'].flags
-
-        # All inherited generators should run from here
-        self.generate()
-
-        if cachingEnabled:
-            cachePath = os.path.join(tempfile.gettempdir(), f'vkobject_{os.getpid()}')
-            if not os.path.isfile(cachePath):
-                cacheFile = open(cachePath, 'wb')
-                pickle.dump(self.vk, cacheFile)
-                cacheFile.close()
-
-        # This should not have to do anything but call into OutputGenerator
-        OutputGenerator.endFile(self)
-
-    #
-    # Bypass the entire processing and load in the VkObject data
-    # Still need to handle the beingFile/endFile for reg.py
-    def generateFromCache(self, cacheVkObjectData, genOpts):
-        OutputGenerator.beginFile(self, genOpts)
-        self.filename = genOpts.filename
-        self.vk = cacheVkObjectData
-        self.generate()
-        OutputGenerator.endFile(self)
-
-    #
-    # Processing point at beginning of each extension definition
-    def beginFeature(self, interface, emit):
-        OutputGenerator.beginFeature(self, interface, emit)
-        platform = interface.get('platform')
-        self.featureExtraProtec = self.vk.platforms[platform] if platform in self.vk.platforms else None
-        protect = self.vk.platforms[platform] if platform in self.vk.platforms else None
-        name = interface.get('name')
-
-        if interface.tag == 'extension':
-            instance = interface.get('type') == 'instance'
-            device = not instance
-            depends = interface.get('depends')
-            vendorTag = interface.get('author')
-            platform = interface.get('platform')
-            provisional = boolGet(interface, 'provisional')
-            promotedto = interface.get('promotedto')
-            deprecatedby = interface.get('deprecatedby')
-            obsoletedby = interface.get('obsoletedby')
-            specialuse = splitIfGet(interface, 'specialuse')
-            # Not sure if better way to get this info
-            specVersion = self.featureDictionary[name]['enumconstant'][None][None][0]
-            nameString = self.featureDictionary[name]['enumconstant'][None][None][1]
-
-            self.currentExtension = Extension(name, nameString, specVersion, instance, device, depends, vendorTag,
-                                            platform, protect, provisional, promotedto, deprecatedby,
-                                            obsoletedby, specialuse)
-            self.vk.extensions[name] = self.currentExtension
-        else: # version
-            number = interface.get('number')
-            if number != '1.0':
-                self.currentVersion = APISpecific.createApiVersion(self.targetApiName, name)
-                self.vk.versions[name] = self.currentVersion
-
-    def endFeature(self):
-        OutputGenerator.endFeature(self)
-        self.currentExtension = None
-        self.currentVersion = None
-
-    #
-    # All <command> from XML
-    def genCmd(self, cmdinfo, name, alias):
-        OutputGenerator.genCmd(self, cmdinfo, name, alias)
-
-        params = []
-        for param in cmdinfo.elem.findall('param'):
-            paramName = param.find('name').text
-            paramType = textIfFind(param, 'type')
-            paramAlias = param.get('alias')
-
-            cdecl = self.makeCParamDecl(param, 0)
-            pointer = '*' in cdecl or paramType.startswith('PFN_')
-            paramConst = 'const' in cdecl
-            fixedSizeArray = [x[:-1] for x in cdecl.split('[') if x.endswith(']')]
-
-            paramNoautovalidity = boolGet(param, 'noautovalidity')
-
-            nullTerminated = False
-            length = param.get('altlen') if param.get('altlen') is not None else param.get('len')
-            if length:
-                # we will either find it like "null-terminated" or "enabledExtensionCount,null-terminated"
-                # This finds both
-                nullTerminated = 'null-terminated' in length
-                length = length.replace(',null-terminated', '') if 'null-terminated' in length else length
-                length = None if length == 'null-terminated' else length
-
-            if fixedSizeArray and not length:
-                length = ','.join(fixedSizeArray)
-
-            # See Member::optional code for details of this
-            optionalValues = splitIfGet(param, 'optional')
-            optional = optionalValues is not None and optionalValues[0].lower() == "true"
-            optionalPointer = optionalValues is not None and len(optionalValues) > 1 and optionalValues[1].lower() == "true"
-
-            # externsync will be 'true' or expression
-            # if expression, it should be same as 'true'
-            externSync = boolGet(param, 'externsync')
-            externSyncPointer = None if externSync else splitIfGet(param, 'externsync')
-            if not externSync and externSyncPointer is not None:
-                externSync = True
-
-            params.append(Param(paramName, paramAlias, paramType, paramNoautovalidity,
-                                paramConst, length, nullTerminated, pointer, fixedSizeArray,
-                                optional, optionalPointer,
-                                externSync, externSyncPointer, cdecl))
-
-        attrib = cmdinfo.elem.attrib
-        alias = attrib.get('alias')
-        tasks = splitIfGet(attrib, 'tasks')
-
-        queues = getQueues(attrib)
-        successcodes = splitIfGet(attrib, 'successcodes')
-        errorcodes = splitIfGet(attrib, 'errorcodes')
-        cmdbufferlevel = attrib.get('cmdbufferlevel')
-        primary = cmdbufferlevel is not None and 'primary' in cmdbufferlevel
-        secondary = cmdbufferlevel is not None and 'secondary' in cmdbufferlevel
-
-        renderpass = attrib.get('renderpass')
-        renderpass = CommandScope.NONE if renderpass is None else getattr(CommandScope, renderpass.upper())
-        videocoding = attrib.get('videocoding')
-        videocoding = CommandScope.NONE if videocoding is None else getattr(CommandScope, videocoding.upper())
-
-        protoElem = cmdinfo.elem.find('proto')
-        returnType = textIfFind(protoElem, 'type')
-
-        decls = self.makeCDecls(cmdinfo.elem)
-        cPrototype = decls[0]
-        cFunctionPointer = decls[1]
-
-        protect = self.currentExtension.protect if self.currentExtension is not None else None
-
-        # These coammds have no way from the XML to detect they would be an instance command
-        specialInstanceCommand = ['vkCreateInstance', 'vkEnumerateInstanceExtensionProperties','vkEnumerateInstanceLayerProperties', 'vkEnumerateInstanceVersion']
-        instance = len(params) > 0 and (params[0].type == 'VkInstance' or params[0].type == 'VkPhysicalDevice' or name in specialInstanceCommand)
-        device = not instance
-
-        implicitElem = cmdinfo.elem.find('implicitexternsyncparams')
-        implicitExternSyncParams = [x.text for x in implicitElem.findall('param')] if implicitElem else []
-
-        self.vk.commands[name] = Command(name, alias, protect, [], self.currentVersion,
-                                         returnType, params, instance, device,
-                                         tasks, queues, successcodes, errorcodes,
-                                         primary, secondary, renderpass, videocoding,
-                                         implicitExternSyncParams, cPrototype, cFunctionPointer)
-
-    #
-    # List the enum for the commands
-    # TODO - Seems empty groups like `VkDeviceDeviceMemoryReportCreateInfoEXT` don't show up in here
-    def genGroup(self, groupinfo, groupName, alias):
-        # There can be case where the Enum/Bitmask is in a protect, but the individual
-        # fields also have their own protect
-        groupProtect = self.currentExtension.protect if hasattr(self.currentExtension, 'protect') and self.currentExtension.protect is not None else None
-        enumElem = groupinfo.elem
-        bitwidth = 32 if enumElem.get('bitwidth') is None else int(enumElem.get('bitwidth'))
-        fields = []
-        if enumElem.get('type') == "enum":
-            if alias is not None:
-                self.enumAliasMap[groupName] = alias
-                return
-
-            for elem in enumElem.findall('enum'):
-                fieldName = elem.get('name')
-
-                if elem.get('alias') is not None:
-                    self.enumFieldAliasMap[fieldName] = elem.get('alias')
-                    continue
-
-                negative = elem.get('dir') is not None
-                protect = elem.get('protect')
-
-                # Some values have multiple extensions (ex VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR)
-                # genGroup() lists them twice
-                if next((x for x in fields if x.name == fieldName), None) is None:
-                    fields.append(EnumField(fieldName, negative, protect, []))
-
-            self.vk.enums[groupName] = Enum(groupName, groupProtect, bitwidth, True, fields, [], [])
-
-        else: # "bitmask"
-            if alias is not None:
-                self.bitmaskAliasMap[groupName] = alias
-                return
-
-            for elem in enumElem.findall('enum'):
-                flagName = elem.get('name')
-
-                if elem.get('alias') is not None:
-                    self.flagAliasMap[flagName] = elem.get('alias')
-                    continue
-
-                flagMultiBit = False
-                flagZero = False
-                flagValue = intIfGet(elem, 'bitpos')
-                if flagValue is None:
-                    flagValue = intIfGet(elem, 'value')
-                    flagMultiBit = flagValue != 0
-                    flagZero = flagValue == 0
-                protect = elem.get('protect')
-
-                # Some values have multiple extensions (ex VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT)
-                # genGroup() lists them twice
-                if next((x for x in fields if x.name == flagName), None) is None:
-                    fields.append(Flag(flagName, protect, flagValue, flagMultiBit, flagZero, []))
-
-            flagName = groupName.replace('FlagBits', 'Flags')
-            self.vk.bitmasks[groupName] = Bitmask(groupName, flagName, groupProtect, bitwidth, True, fields, [], [])
-
-    def genType(self, typeInfo, typeName, alias):
-        OutputGenerator.genType(self, typeInfo, typeName, alias)
-        typeElem = typeInfo.elem
-        protect = self.currentExtension.protect if hasattr(self.currentExtension, 'protect') and self.currentExtension.protect is not None else None
-        category = typeElem.get('category')
-        if (category == 'struct' or category == 'union'):
-            extension = [self.currentExtension] if self.currentExtension is not None else []
-            if alias is not None:
-                self.structAliasMap[typeName] = alias
-                return
-
-            union = category == 'union'
-
-            returnedOnly = boolGet(typeElem, 'returnedonly')
-            allowDuplicate = boolGet(typeElem, 'allowduplicate')
-
-            extends = splitIfGet(typeElem, 'structextends')
-            extendedBy = self.registry.validextensionstructs[typeName] if len(self.registry.validextensionstructs[typeName]) > 0 else None
-
-            membersElem = typeInfo.elem.findall('.//member')
-            members = []
-            sType = None
-
-            for member in membersElem:
-                for comment in member.findall('comment'):
-                    member.remove(comment)
-
-                name = textIfFind(member, 'name')
-                type = textIfFind(member, 'type')
-                sType = member.get('values') if member.get('values') is not None else sType
-                externSync = boolGet(member, 'externsync')
-                noautovalidity = boolGet(member, 'noautovalidity')
-                limittype = member.get('limittype')
-
-                nullTerminated = False
-                length = member.get('altlen') if member.get('altlen') is not None else member.get('len')
-                if length:
-                    # we will either find it like "null-terminated" or "enabledExtensionCount,null-terminated"
-                    # This finds both
-                    nullTerminated = 'null-terminated' in length
-                    length = length.replace(',null-terminated', '') if 'null-terminated' in length else length
-                    length = None if length == 'null-terminated' else length
-
-                cdecl = self.makeCParamDecl(member, 0)
-                pointer = '*' in cdecl or type.startswith('PFN_')
-                const = 'const' in cdecl
-                # Some structs like VkTransformMatrixKHR have a 2D array
-                fixedSizeArray = [x[:-1] for x in cdecl.split('[') if x.endswith(']')]
-
-                if fixedSizeArray and not length:
-                    length = ','.join(fixedSizeArray)
-
-                # if a pointer, this can be a something like:
-                #     optional="true,false" for ppGeometries
-                #     optional="false,true" for pPhysicalDeviceCount
-                # the first is if the variable itself is optional
-                # the second is the value of the pointer is optiona;
-                optionalValues = splitIfGet(member, 'optional')
-                optional = optionalValues is not None and optionalValues[0].lower() == "true"
-                optionalPointer = optionalValues is not None and len(optionalValues) > 1 and optionalValues[1].lower() == "true"
-
-                members.append(Member(name, type, noautovalidity, limittype,
-                                      const, length, nullTerminated, pointer, fixedSizeArray,
-                                      optional, optionalPointer,
-                                      externSync, cdecl))
-
-            self.vk.structs[typeName] = Struct(typeName, extension, self.currentVersion, protect, members,
-                                               union, returnedOnly, sType, allowDuplicate, extends, extendedBy)
-
-        elif category == 'handle':
-            if alias is not None:
-                return
-            type = typeElem.get('objtypeenum')
-
-            # will resolve these later, the VulkanObjectType doesn't list things in dependent order
-            parent = typeElem.get('parent')
-            instance = typeName == 'VkInstance'
-            device = typeName == 'VkDevice'
-
-            dispatchable = typeElem.find('type').text == 'VK_DEFINE_HANDLE'
-
-            self.vk.handles[typeName] = Handle(typeName, type, protect, parent, instance, device, dispatchable)
-
-        elif category == 'define':
-            if typeName == 'VK_HEADER_VERSION':
-                self.vk.headerVersion = typeElem.find('name').tail.strip()
-
-        else:
-            # not all categories are used
-            #   'group'/'enum'/'bitmask' are routed to genGroup instead
-            #   'basetype'/'include' are only for headers
-            #   'funcpointer` ingore until needed
-            return
-
-    def genSpirv(self, spirvinfo, spirvName, alias):
-        OutputGenerator.genSpirv(self, spirvinfo, spirvName, alias)
-        spirvElem = spirvinfo.elem
-        name = spirvElem.get('name')
-        extension = True if spirvElem.tag == 'spirvextension' else False
-        capability = not extension
-
-        enables = []
-        for elem in spirvElem:
-            version = elem.attrib.get('version')
-            extensionEnable = elem.attrib.get('extension')
-            struct = elem.attrib.get('struct')
-            feature = elem.attrib.get('feature')
-            requires = elem.attrib.get('requires')
-            propertyEnable = elem.attrib.get('property')
-            member = elem.attrib.get('member')
-            value = elem.attrib.get('value')
-            enables.append(SpirvEnables(version, extensionEnable, struct, feature,
-                                        requires, propertyEnable, member, value))
-
-        self.vk.spirv.append(Spirv(name, extension, capability, enables))
-
-    def genFormat(self, format, formatinfo, alias):
-        OutputGenerator.genFormat(self, format, formatinfo, alias)
-        formatElem = format.elem
-        name = formatElem.get('name')
-
-        components = []
-        for component in formatElem.iterfind('component'):
-            type = component.get('name')
-            bits = component.get('bits')
-            numericFormat = component.get('numericFormat')
-            planeIndex = intIfGet(component, 'planeIndex')
-            components.append(FormatComponent(type, bits, numericFormat, planeIndex))
-
-        planes = []
-        for plane in formatElem.iterfind('plane'):
-            index = int(plane.get('index'))
-            widthDivisor = int(plane.get('widthDivisor'))
-            heightDivisor = int(plane.get('heightDivisor'))
-            compatible = plane.get('compatible')
-            planes.append(FormatPlane(index, widthDivisor, heightDivisor, compatible))
-
-        className = formatElem.get('class')
-        blockSize = int(formatElem.get('blockSize'))
-        texelsPerBlock = int(formatElem.get('texelsPerBlock'))
-        blockExtent = splitIfGet(formatElem, 'blockExtent')
-        packed = intIfGet(formatElem, 'packed')
-        chroma = formatElem.get('chroma')
-        compressed = formatElem.get('compressed')
-        spirvImageFormat = formatElem.find('spirvimageformat')
-        if spirvImageFormat is not None:
-            spirvImageFormat = spirvImageFormat.get('name')
-
-        self.vk.formats[name] = Format(name, className, blockSize, texelsPerBlock,
-                                       blockExtent, packed, chroma, compressed,
-                                       components, planes, spirvImageFormat)
-
-    def genSyncStage(self, sync):
-        OutputGenerator.genSyncStage(self, sync)
-        syncElem = sync.elem
-
-        support = maxSyncSupport
-        supportElem = syncElem.find('syncsupport')
-        if supportElem is not None:
-            queues = getQueues(supportElem)
-            stageNames = splitIfGet(supportElem, 'stage')
-            stages = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name in stageNames] if stageNames is not None else None
-            support = SyncSupport(queues, stages, False)
-
-        equivalent = maxSyncEquivalent
-        equivalentElem = syncElem.find('syncequivalent')
-        if equivalentElem is not None:
-            stageNames = splitIfGet(equivalentElem, 'stage')
-            stages = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name in stageNames] if stageNames is not None else None
-            accessNames = splitIfGet(equivalentElem, 'access')
-            accesses = [x for x in self.vk.bitmasks['VkAccessFlagBits2'].flags if x.name in accessNames] if accessNames is not None else None
-            equivalent = SyncEquivalent(stages, accesses, False)
-
-        flagName = syncElem.get('name')
-        flag = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name == flagName]
-        # This check is needed because not all API variants have VK_KHR_synchronization2
-        if flag:
-            self.vk.syncStage.append(SyncStage(flag[0], support, equivalent))
-
-    def genSyncAccess(self, sync):
-        OutputGenerator.genSyncAccess(self, sync)
-        syncElem = sync.elem
-
-        support = maxSyncSupport
-        supportElem = syncElem.find('syncsupport')
-        if supportElem is not None:
-            queues = getQueues(supportElem)
-            stageNames = splitIfGet(supportElem, 'stage')
-            stages = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name in stageNames] if stageNames is not None else None
-            support = SyncSupport(queues, stages, False)
-
-        equivalent = maxSyncEquivalent
-        equivalentElem = syncElem.find('syncequivalent')
-        if equivalentElem is not None:
-            stageNames = splitIfGet(equivalentElem, 'stage')
-            stages = [x for x in self.vk.bitmasks['VkPipelineStageFlagBits2'].flags if x.name in stageNames] if stageNames is not None else None
-            accessNames = splitIfGet(equivalentElem, 'access')
-            accesses = [x for x in self.vk.bitmasks['VkAccessFlagBits2'].flags if x.name in accessNames] if accessNames is not None else None
-            equivalent = SyncEquivalent(stages, accesses, False)
-
-        flagName = syncElem.get('name')
-        flag = [x for x in self.vk.bitmasks['VkAccessFlagBits2'].flags if x.name == flagName]
-        # This check is needed because not all API variants have VK_KHR_synchronization2
-        if flag:
-            self.vk.syncAccess.append(SyncAccess(flag[0], support, equivalent))
-
-    def genSyncPipeline(self, sync):
-        OutputGenerator.genSyncPipeline(self, sync)
-        syncElem = sync.elem
-        name = syncElem.get('name')
-        depends = splitIfGet(syncElem, 'depends')
-        stages = []
-        for stageElem in syncElem.findall('syncpipelinestage'):
-            order = stageElem.get('order')
-            before = stageElem.get('before')
-            after = stageElem.get('after')
-            value = stageElem.text
-            stages.append(SyncPipelineStage(order, before, after, value))
-
-        self.vk.syncPipeline.append(SyncPipeline(name, depends, stages))
diff --git a/scripts/generators/dispatch_table_generator.py b/scripts/generators/dispatch_table_generator.py
index ebab6ea..f2dd57d 100644
--- a/scripts/generators/dispatch_table_generator.py
+++ b/scripts/generators/dispatch_table_generator.py
@@ -7,7 +7,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import os
-from generators.base_generator import BaseGenerator
+from base_generator import BaseGenerator
 from generators.generator_utils import PlatformGuardHelper
 
 class DispatchTableOutputGenerator(BaseGenerator):
diff --git a/scripts/generators/enum_string_helper_generator.py b/scripts/generators/enum_string_helper_generator.py
index 33a0a2a..28e7e54 100644
--- a/scripts/generators/enum_string_helper_generator.py
+++ b/scripts/generators/enum_string_helper_generator.py
@@ -7,7 +7,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import os
-from generators.base_generator import BaseGenerator
+from base_generator import BaseGenerator
 from generators.generator_utils import PlatformGuardHelper
 
 class EnumStringHelperOutputGenerator(BaseGenerator):
diff --git a/scripts/generators/format_utils_generator.py b/scripts/generators/format_utils_generator.py
index ee05230..ed2cdd8 100644
--- a/scripts/generators/format_utils_generator.py
+++ b/scripts/generators/format_utils_generator.py
@@ -7,8 +7,8 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import os
-from generators.vulkan_object import (Format)
-from generators.base_generator import BaseGenerator
+from vulkan_object import (Format)
+from base_generator import BaseGenerator
 
 # Make C name friendly class name
 def getClassName(className: str) -> str:
diff --git a/scripts/generators/safe_struct_generator.py b/scripts/generators/safe_struct_generator.py
index cb67ccb..0e415b3 100644
--- a/scripts/generators/safe_struct_generator.py
+++ b/scripts/generators/safe_struct_generator.py
@@ -10,8 +10,8 @@
 
 import os
 import re
-from generators.vulkan_object import Struct, Member
-from generators.base_generator import BaseGenerator
+from vulkan_object import Struct, Member
+from base_generator import BaseGenerator
 from generators.generator_utils import PlatformGuardHelper
 
 class SafeStructOutputGenerator(BaseGenerator):
diff --git a/scripts/generators/struct_helper_generator.py b/scripts/generators/struct_helper_generator.py
index f92a872..12cb231 100644
--- a/scripts/generators/struct_helper_generator.py
+++ b/scripts/generators/struct_helper_generator.py
@@ -19,7 +19,7 @@
 # limitations under the License.
 
 import os
-from generators.base_generator import BaseGenerator
+from base_generator import BaseGenerator
 from generators.generator_utils import PlatformGuardHelper
 
 class StructHelperOutputGenerator(BaseGenerator):
diff --git a/scripts/generators/vulkan_object.py b/scripts/generators/vulkan_object.py
deleted file mode 100644
index bb3bd24..0000000
--- a/scripts/generators/vulkan_object.py
+++ /dev/null
@@ -1,405 +0,0 @@
-#!/usr/bin/python3 -i
-#
-# Copyright (c) 2023-2024 Valve Corporation
-# Copyright (c) 2023-2024 LunarG, Inc.
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from dataclasses import dataclass, field
-from enum import IntFlag, Enum, auto
-
-@dataclass
-class Extension:
-    """<extension>"""
-    name: str # ex) VK_KHR_SURFACE
-    nameString: str # marco with string, ex) VK_KHR_SURFACE_EXTENSION_NAME
-    specVersion: str # marco with string, ex) VK_KHR_SURFACE_SPEC_VERSION
-
-    # Only one will be True, the other is False
-    instance: bool
-    device: bool
-
-    depends: (str | None)
-    vendorTag: (str | None)  # ex) EXT, KHR, etc
-    platform: (str | None)   # ex) android
-    protect: (str | None)    # ex) VK_USE_PLATFORM_ANDROID_KHR
-    provisional: bool
-    promotedTo: (str | None) # ex) VK_VERSION_1_1
-    deprecatedBy: (str | None)
-    obsoletedBy: (str | None)
-    specialUse: list[str]
-
-    # These are here to allow for easy reverse lookups
-    # Quotes allow us to forward declare the dataclass
-    commands: list['Command'] = field(default_factory=list, init=False)
-    enums:    list['Enum']    = field(default_factory=list, init=False)
-    bitmasks: list['Bitmask'] = field(default_factory=list, init=False)
-    # Use the Enum name to see what fields are extended
-    enumFields: dict[str, list['EnumField']] = field(default_factory=dict, init=False)
-    # Use the Bitmaks name to see what flags are extended
-    flags: dict[str, list['Flag']] = field(default_factory=dict, init=False)
-
-@dataclass
-class Version:
-    """
-    <feature> which represents a version
-    This will NEVER be Version 1.0, since having 'no version' is same as being 1.0
-    """
-    name: str       # ex) VK_VERSION_1_1
-    nameString: str # ex) "VK_VERSION_1_1" (no marco, so has quotes)
-    nameApi: str    # ex) VK_API_VERSION_1_1
-
-@dataclass
-class Handle:
-    """<type> which represents a dispatch handle"""
-    name: str # ex) VkBuffer
-    type: str # ex) VK_OBJECT_TYPE_BUFFER
-    protect: (str | None) # ex) VK_USE_PLATFORM_ANDROID_KHR
-
-    parent: 'Handle' # Chain of parent handles, can be None
-
-    # Only one will be True, the other is False
-    instance: bool
-    device: bool
-
-    dispatchable: bool
-
-    def __lt__(self, other):
-        return self.name < other.name
-
-@dataclass
-class Param:
-    """<command/param>"""
-    name: str
-    alias: str
-    type: str # ex) void, VkFormat, etc
-
-    noAutoValidity: bool
-
-    const: bool           # type contains 'const'
-    length:  (str | None) # the known length of pointer, will never be 'null-terminated'
-    nullTerminated: bool  # If a UTF-8 string, it will be null-terminated
-    pointer: bool         # type contains a pointer (include 'PFN' function pointers)
-    fixedSizeArray: list[str] # for VkTransformMatrixKHR:matrix this is [3, 4]
-
-    optional: bool
-    optionalPointer: bool # if type contains a pointer, is the pointer value optional
-
-    externSync: bool
-    externSyncPointer: list[str] # if type contains a pointer, might only specific members modified
-
-    # C string of member, example:
-    #   - const void* pNext
-    #   - VkFormat format
-    #   - VkStructureType sType
-    cDeclaration: str
-
-    def __lt__(self, other):
-        return self.name < other.name
-
-class Queues(IntFlag):
-    TRANSFER       = auto() # VK_QUEUE_TRANSFER_BIT
-    GRAPHICS       = auto() # VK_QUEUE_GRAPHICS_BIT
-    COMPUTE        = auto() # VK_QUEUE_COMPUTE_BIT
-    PROTECTED      = auto() # VK_QUEUE_PROTECTED_BIT
-    SPARSE_BINDING = auto() # VK_QUEUE_SPARSE_BINDING_BIT
-    OPTICAL_FLOW   = auto() # VK_QUEUE_OPTICAL_FLOW_BIT_NV
-    DECODE         = auto() # VK_QUEUE_VIDEO_DECODE_BIT_KHR
-    ENCODE         = auto() # VK_QUEUE_VIDEO_ENCODE_BIT_KHR
-    ALL = TRANSFER | GRAPHICS | COMPUTE | PROTECTED | SPARSE_BINDING | OPTICAL_FLOW | DECODE | ENCODE
-
-class CommandScope(Enum):
-    NONE    = auto()
-    INSIDE  = auto()
-    OUTSIDE = auto()
-    BOTH    = auto()
-
-@dataclass
-class Command:
-    """<command>"""
-    name: str # ex) vkCmdDraw
-    alias: str # Because commands are interfaces into layers/drivers, we need all command alias
-    protect: (str | None) # ex) 'VK_ENABLE_BETA_EXTENSIONS'
-
-    extensions: list[Extension] # All extensions that enable the struct
-    version: (Version | None) # None if Version 1.0
-
-    returnType: str # ex) void, VkResult, etc
-
-    params: list[Param] # Each parameter of the command
-
-    # Only one will be True, the other is False
-    instance: bool
-    device: bool
-
-    tasks: list[str]        # ex) [ action, state, synchronization ]
-    queues: Queues          # zero == No Queues found
-    successCodes: list[str] # ex) [ VK_SUCCESS, VK_INCOMPLETE ]
-    errorCodes: list[str]   # ex) [ VK_ERROR_OUT_OF_HOST_MEMORY ]
-
-    # Shows support if command can be in a primary and/or secondary command buffer
-    primary: bool
-    secondary: bool
-
-    renderPass: CommandScope
-    videoCoding: CommandScope
-
-    implicitExternSyncParams: list[str]
-
-    # C prototype string - ex:
-    # VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(
-    #   const VkInstanceCreateInfo* pCreateInfo,
-    #   const VkAllocationCallbacks* pAllocator,
-    #   VkInstance* pInstance);
-    cPrototype: str
-
-    # function pointer typedef  - ex:
-    # typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)
-    #   (const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
-    cFunctionPointer: str
-
-    def __lt__(self, other):
-        return self.name < other.name
-
-@dataclass
-class Member:
-    """<member>"""
-    name: str # ex) sharingMode
-    type: str # ex) VkSharingMode
-
-    noAutoValidity: bool
-    limitType: (str | None) # ex) 'max', 'bitmask', 'bits', 'min,mul'
-
-    const: bool           # type contains 'const'
-    length:  (str | None) # the known length of pointer, will never be 'null-terminated'
-    nullTerminated: bool  # If a UTF-8 string, it will be null-terminated
-    pointer: bool         # type contains a pointer (include 'PFN' function pointers)
-    fixedSizeArray: list[str] # for VkTransformMatrixKHR:matrix this is [3, 4]
-
-    optional: bool
-    optionalPointer: bool # if type contains a pointer, is the pointer value optional
-
-    externSync: bool
-
-    # C string of member, example:
-    #   - const void* pNext
-    #   - VkFormat format
-    #   - VkStructureType sType
-    cDeclaration: str
-
-    def __lt__(self, other):
-        return self.name < other.name
-
-@dataclass
-class Struct:
-    """<type category="struct"> or <type category="union">"""
-    name: str # ex. VkBufferCreateInfo
-    extensions: list[Extension] # All extensions that enable the struct
-    version: (Version | None) # None if Version 1.0
-    protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
-
-    members: list[Member]
-
-    union: bool # Unions are just a subset of a Structs
-    returnedOnly: bool
-
-    sType: (str | None) # ex) VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO
-    allowDuplicate: bool # can have a pNext point to itself
-
-    # These use to be list['Struct'] but some circular loops occur and cause
-    # pydevd warnings and made debugging slow (30 seconds to index a Struct)
-    extends: list[str] # Struct names that this struct extends
-    extendedBy: list[str] # Struct names that can be extended by this struct
-
-    def __lt__(self, other):
-        return self.name < other.name
-
-@dataclass
-class EnumField:
-    """<enum> of type enum"""
-    name: str # ex) VK_DYNAMIC_STATE_SCISSOR
-    negative: bool # True if negative values are allowed (ex. VkResult)
-    protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
-
-    # some fields are enabled from 2 extensions (ex) VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR)
-    extensions: list[Extension] # None if part of 1.0 core
-
-    def __lt__(self, other):
-        return self.name < other.name
-
-@dataclass
-class Enum:
-    """<enums> of type enum"""
-    name: str # ex) VkDynamicState
-    protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
-
-    bitWidth: int # 32 or 64
-    returnedOnly: bool
-
-    fields: list[EnumField]
-
-    extensions: list[Extension] # None if part of 1.0 core
-    # Unique list of all extension that are involved in 'fields' (superset of 'extensions')
-    fieldExtensions: list[Extension]
-
-    def __lt__(self, other):
-        return self.name < other.name
-
-@dataclass
-class Flag:
-    """<enum> of type bitmask"""
-    name: str # ex) VK_ACCESS_2_SHADER_READ_BIT
-    protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
-
-    value: int
-    multiBit: bool # if true, more than one bit is set (ex) VK_SHADER_STAGE_ALL_GRAPHICS)
-    zero: bool     # if true, the value is zero (ex) VK_PIPELINE_STAGE_NONE)
-
-    # some fields are enabled from 2 extensions (ex) VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT)
-    extensions: list[Extension] # None if part of 1.0 core
-
-    def __lt__(self, other):
-        return self.name < other.name
-
-@dataclass
-class Bitmask:
-    """<enums> of type bitmask"""
-    name: str     # ex) VkAccessFlagBits2
-    flagName: str # ex) VkAccessFlags2
-    protect: (str | None) # ex) VK_ENABLE_BETA_EXTENSIONS
-
-    bitWidth: int # 32 or 64
-    returnedOnly: bool
-
-    flags: list[Flag]
-
-    extensions: list[Extension] # None if part of 1.0 core
-    # Unique list of all extension that are involved in 'flag' (superset of 'extensions')
-    flagExtensions: list[Extension]
-
-    def __lt__(self, other):
-        return self.name < other.name
-
-@dataclass
-class FormatComponent:
-    """<format/component>"""
-    type: str # ex) R, G, B, A, D, S, etc
-    bits: str # will be an INT or 'compressed'
-    numericFormat: str # ex) UNORM, SINT, etc
-    planeIndex: (int | None) # None if no planeIndex in format
-
-@dataclass
-class FormatPlane:
-    """<format/plane>"""
-    index: int
-    widthDivisor: int
-    heightDivisor: int
-    compatible: str
-
-@dataclass
-class Format:
-    """<format>"""
-    name: str
-    className: str
-    blockSize: int
-    texelsPerBlock: int
-    blockExtent: list[str]
-    packed: (int | None) # None == not-packed
-    chroma: (str | None)
-    compressed: (str | None)
-    components: list[FormatComponent] # <format/component>
-    planes: list[FormatPlane]  # <format/plane>
-    spirvImageFormat: (str | None)
-
-@dataclass
-class SyncSupport:
-    """<syncsupport>"""
-    queues: Queues
-    stages: list[Flag] # VkPipelineStageFlagBits2
-    max: bool # If this supports max values
-
-@dataclass
-class SyncEquivalent:
-    """<syncequivalent>"""
-    stages: list[Flag] # VkPipelineStageFlagBits2
-    accesses: list[Flag] # VkAccessFlagBits2
-    max: bool # If this equivalent to everything
-
-@dataclass
-class SyncStage:
-    """<syncstage>"""
-    flag: Flag # VkPipelineStageFlagBits2
-    support: SyncSupport
-    equivalent: SyncEquivalent
-
-@dataclass
-class SyncAccess:
-    """<syncaccess>"""
-    flag: Flag # VkAccessFlagBits2
-    support: SyncSupport
-    equivalent: SyncEquivalent
-
-@dataclass
-class SyncPipelineStage:
-    """<syncpipelinestage>"""
-    order: (str | None)
-    before: (str | None)
-    after: (str | None)
-    value: str
-
-@dataclass
-class SyncPipeline:
-    """<syncpipeline>"""
-    name: str
-    depends: list[str]
-    stages: list[SyncPipelineStage]
-
-@dataclass
-class SpirvEnables:
-    """What is needed to enable the SPIR-V element"""
-    version: (str | None)
-    extension: (str | None)
-    struct: (str | None)
-    feature: (str | None)
-    requires: (str | None)
-    property: (str | None)
-    member: (str | None)
-    value: (str | None)
-
-@dataclass
-class Spirv:
-    """<spirvextension> and <spirvcapability>"""
-    name: str
-    # Only one will be True, the other is False
-    extension: bool
-    capability: bool
-    enable: list[SpirvEnables]
-
-# This is the global Vulkan Object that holds all the information from parsing the XML
-# This class is designed so all generator scripts can use this to obtain data
-@dataclass
-class VulkanObject():
-    headerVersion: int = 0 # value of VK_HEADER_VERSION
-
-    extensions: dict[str, Extension] = field(default_factory=dict, init=False)
-    versions:   dict[str, Version]   = field(default_factory=dict, init=False)
-
-    handles:  dict[str, Handle]      = field(default_factory=dict, init=False)
-    commands: dict[str, Command]     = field(default_factory=dict, init=False)
-    structs:  dict[str, Struct]      = field(default_factory=dict, init=False)
-    enums:    dict[str, Enum]        = field(default_factory=dict, init=False)
-    bitmasks: dict[str, Bitmask]     = field(default_factory=dict, init=False)
-    formats:  dict[str, Format]      = field(default_factory=dict, init=False)
-
-    syncStage:    list[SyncStage]    = field(default_factory=list, init=False)
-    syncAccess:   list[SyncAccess]   = field(default_factory=list, init=False)
-    syncPipeline: list[SyncPipeline] = field(default_factory=list, init=False)
-
-    spirv: list[Spirv]               = field(default_factory=list, init=False)
-
-    # ex) [ xlib : VK_USE_PLATFORM_XLIB_KHR ]
-    platforms: dict[str, str]        = field(default_factory=dict, init=False)
-    # list of all vendor Sufix names (KHR, EXT, etc. )
-    vendorTags: list[str]            = field(default_factory=list, init=False)
-    # ex) [ Queues.COMPUTE : VK_QUEUE_COMPUTE_BIT ]
-    queueBits: dict[IntFlag, str]    = field(default_factory=dict, init=False)

From 6be00ca9f51c714780cc1d6f537f8bc5650b6204 Mon Sep 17 00:00:00 2001
From: spencer-lunarg <spencer@lunarg.com>
Date: Fri, 21 Feb 2025 16:58:59 -0500
Subject: [PATCH 084/106] scripts: Manual VK_ENABLE_BETA_EXTENSIONS

---
 include/vulkan/utility/vk_safe_struct.hpp     | 4 ++++
 include/vulkan/utility/vk_struct_helper.hpp   | 4 ++++
 scripts/generators/safe_struct_generator.py   | 6 ++++++
 scripts/generators/struct_helper_generator.py | 6 ++++++
 src/vulkan/vk_safe_struct_utils.cpp           | 8 ++++++++
 src/vulkan/vk_safe_struct_vendor.cpp          | 4 ++++
 6 files changed, 32 insertions(+)

diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index f569902..5544a65 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -14108,6 +14108,7 @@ struct safe_VkDeviceDiagnosticsConfigCreateInfoNV {
         return reinterpret_cast<VkDeviceDiagnosticsConfigCreateInfoNV const*>(this);
     }
 };
+#ifdef VK_ENABLE_BETA_EXTENSIONS
 struct safe_VkCudaModuleCreateInfoNV {
     VkStructureType sType;
     const void* pNext{};
@@ -14209,6 +14210,7 @@ struct safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV {
         return reinterpret_cast<VkPhysicalDeviceCudaKernelLaunchPropertiesNV const*>(this);
     }
 };
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 struct safe_VkQueryLowLatencySupportNV {
     VkStructureType sType;
     const void* pNext{};
@@ -20291,6 +20293,7 @@ struct safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT {
         return reinterpret_cast<VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT const*>(this);
     }
 };
+#ifdef VK_ENABLE_BETA_EXTENSIONS
 struct safe_VkSetPresentConfigNV {
     VkStructureType sType;
     const void* pNext{};
@@ -20325,6 +20328,7 @@ struct safe_VkPhysicalDevicePresentMeteringFeaturesNV {
         return reinterpret_cast<VkPhysicalDevicePresentMeteringFeaturesNV const*>(this);
     }
 };
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 struct safe_VkAccelerationStructureGeometryTrianglesDataKHR {
     VkStructureType sType;
     const void* pNext{};
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index aed8928..55b949e 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -743,11 +743,13 @@ template <> inline VkStructureType GetSType<VkSurfaceCapabilitiesPresentBarrierN
 template <> inline VkStructureType GetSType<VkSwapchainPresentBarrierCreateInfoNV>() { return VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceDiagnosticsConfigFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkDeviceDiagnosticsConfigCreateInfoNV>() { return VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV; }
+#ifdef VK_ENABLE_BETA_EXTENSIONS
 template <> inline VkStructureType GetSType<VkCudaModuleCreateInfoNV>() { return VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV; }
 template <> inline VkStructureType GetSType<VkCudaFunctionCreateInfoNV>() { return VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV; }
 template <> inline VkStructureType GetSType<VkCudaLaunchInfoNV>() { return VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCudaKernelLaunchFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCudaKernelLaunchPropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV; }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 template <> inline VkStructureType GetSType<VkQueryLowLatencySupportNV>() { return VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV; }
 #ifdef VK_USE_PLATFORM_METAL_EXT
 template <> inline VkStructureType GetSType<VkExportMetalObjectCreateInfoEXT>() { return VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT; }
@@ -1051,8 +1053,10 @@ template <> inline VkStructureType GetSType<VkMemoryMetalHandlePropertiesEXT>()
 template <> inline VkStructureType GetSType<VkMemoryGetMetalHandleInfoEXT>() { return VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT; }
 #endif  // VK_USE_PLATFORM_METAL_EXT
 template <> inline VkStructureType GetSType<VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT; }
+#ifdef VK_ENABLE_BETA_EXTENSIONS
 template <> inline VkStructureType GetSType<VkSetPresentConfigNV>() { return VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDevicePresentMeteringFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV; }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryTrianglesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryAabbsDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryInstancesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR; }
diff --git a/scripts/generators/safe_struct_generator.py b/scripts/generators/safe_struct_generator.py
index 0e415b3..0792c6d 100644
--- a/scripts/generators/safe_struct_generator.py
+++ b/scripts/generators/safe_struct_generator.py
@@ -134,6 +134,12 @@ class SafeStructOutputGenerator(BaseGenerator):
         return False
 
     def generate(self):
+        # Should be fixed in 1.4.310 headers
+        # https://gitlab.khronos.org/vulkan/vulkan/-/merge_requests/7196
+        manual_protect = ["VkCudaModuleNV", "VkCudaFunctionNV", "VkCudaModuleCreateInfoNV", "VkCudaFunctionCreateInfoNV", "VkCudaLaunchInfoNV", "VkPhysicalDeviceCudaKernelLaunchFeaturesNV", "VkPhysicalDeviceCudaKernelLaunchPropertiesNV", "VkSetPresentConfigNV", "VkPhysicalDevicePresentMeteringFeaturesNV"]
+        for struct in [x for x in self.vk.structs.values() if x.name in manual_protect]:
+            struct.protect = "VK_ENABLE_BETA_EXTENSIONS"
+
         self.write(f'''// *** THIS FILE IS GENERATED - DO NOT EDIT ***
             // See {os.path.basename(__file__)} for modifications
 
diff --git a/scripts/generators/struct_helper_generator.py b/scripts/generators/struct_helper_generator.py
index 12cb231..2f8efd9 100644
--- a/scripts/generators/struct_helper_generator.py
+++ b/scripts/generators/struct_helper_generator.py
@@ -27,6 +27,12 @@ class StructHelperOutputGenerator(BaseGenerator):
         BaseGenerator.__init__(self)
 
     def generate(self):
+        # Should be fixed in 1.4.310 headers
+        # https://gitlab.khronos.org/vulkan/vulkan/-/merge_requests/7196
+        manual_protect = ["VkCudaModuleNV", "VkCudaFunctionNV", "VkCudaModuleCreateInfoNV", "VkCudaFunctionCreateInfoNV", "VkCudaLaunchInfoNV", "VkPhysicalDeviceCudaKernelLaunchFeaturesNV", "VkPhysicalDeviceCudaKernelLaunchPropertiesNV", "VkSetPresentConfigNV", "VkPhysicalDevicePresentMeteringFeaturesNV"]
+        for struct in [x for x in self.vk.structs.values() if x.name in manual_protect]:
+            struct.protect = "VK_ENABLE_BETA_EXTENSIONS"
+
         out = []
         out.append(f'''// *** THIS FILE IS GENERATED - DO NOT EDIT ***
 // See {os.path.basename(__file__)} for modifications
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index 4dc27fe..2571e43 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -1380,12 +1380,14 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
                 safe_pNext = new safe_VkDeviceDiagnosticsConfigCreateInfoNV(reinterpret_cast<const VkDeviceDiagnosticsConfigCreateInfoNV *>(pNext), copy_state, false);
                 break;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV:
                 safe_pNext = new safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV(reinterpret_cast<const VkPhysicalDeviceCudaKernelLaunchFeaturesNV *>(pNext), copy_state, false);
                 break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV:
                 safe_pNext = new safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV(reinterpret_cast<const VkPhysicalDeviceCudaKernelLaunchPropertiesNV *>(pNext), copy_state, false);
                 break;
+#endif  // VK_ENABLE_BETA_EXTENSIONS
             case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV:
                 safe_pNext = new safe_VkQueryLowLatencySupportNV(reinterpret_cast<const VkQueryLowLatencySupportNV *>(pNext), copy_state, false);
                 break;
@@ -2025,12 +2027,14 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
                 safe_pNext = new safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *>(pNext), copy_state, false);
                 break;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
             case VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV:
                 safe_pNext = new safe_VkSetPresentConfigNV(reinterpret_cast<const VkSetPresentConfigNV *>(pNext), copy_state, false);
                 break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV:
                 safe_pNext = new safe_VkPhysicalDevicePresentMeteringFeaturesNV(reinterpret_cast<const VkPhysicalDevicePresentMeteringFeaturesNV *>(pNext), copy_state, false);
                 break;
+#endif  // VK_ENABLE_BETA_EXTENSIONS
             case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
                 safe_pNext = new safe_VkWriteDescriptorSetAccelerationStructureKHR(reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR *>(pNext), copy_state, false);
                 break;
@@ -3427,12 +3431,14 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
             delete reinterpret_cast<safe_VkDeviceDiagnosticsConfigCreateInfoNV *>(header);
             break;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV:
             delete reinterpret_cast<safe_VkPhysicalDeviceCudaKernelLaunchFeaturesNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV:
             delete reinterpret_cast<safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV *>(header);
             break;
+#endif  // VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV:
             delete reinterpret_cast<safe_VkQueryLowLatencySupportNV *>(header);
             break;
@@ -4072,12 +4078,14 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
             delete reinterpret_cast<safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *>(header);
             break;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV:
             delete reinterpret_cast<safe_VkSetPresentConfigNV *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV:
             delete reinterpret_cast<safe_VkPhysicalDevicePresentMeteringFeaturesNV *>(header);
             break;
+#endif  // VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
             delete reinterpret_cast<safe_VkWriteDescriptorSetAccelerationStructureKHR *>(header);
             break;
diff --git a/src/vulkan/vk_safe_struct_vendor.cpp b/src/vulkan/vk_safe_struct_vendor.cpp
index 6e7b5f6..220a52a 100644
--- a/src/vulkan/vk_safe_struct_vendor.cpp
+++ b/src/vulkan/vk_safe_struct_vendor.cpp
@@ -7909,6 +7909,7 @@ void safe_VkDeviceDiagnosticsConfigCreateInfoNV::initialize(const safe_VkDeviceD
     flags = copy_src->flags;
     pNext = SafePnextCopy(copy_src->pNext);
 }
+#ifdef VK_ENABLE_BETA_EXTENSIONS
 
 safe_VkCudaModuleCreateInfoNV::safe_VkCudaModuleCreateInfoNV(const VkCudaModuleCreateInfoNV* in_struct,
                                                              [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
@@ -8272,6 +8273,7 @@ void safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV::initialize(
     computeCapabilityMajor = copy_src->computeCapabilityMajor;
     pNext = SafePnextCopy(copy_src->pNext);
 }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 
 safe_VkQueryLowLatencySupportNV::safe_VkQueryLowLatencySupportNV(const VkQueryLowLatencySupportNV* in_struct,
                                                                  [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
@@ -17714,6 +17716,7 @@ void safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM::initialize(
     pipelineOpacityMicromap = copy_src->pipelineOpacityMicromap;
     pNext = SafePnextCopy(copy_src->pNext);
 }
+#ifdef VK_ENABLE_BETA_EXTENSIONS
 
 safe_VkSetPresentConfigNV::safe_VkSetPresentConfigNV(const VkSetPresentConfigNV* in_struct,
                                                      [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
@@ -17812,6 +17815,7 @@ void safe_VkPhysicalDevicePresentMeteringFeaturesNV::initialize(const safe_VkPhy
     presentMetering = copy_src->presentMetering;
     pNext = SafePnextCopy(copy_src->pNext);
 }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 
 }  // namespace vku
 

From a091f92419756b053639b4786307db5e17c134d4 Mon Sep 17 00:00:00 2001
From: Charles Giessen <charles@lunarg.com>
Date: Fri, 21 Feb 2025 13:40:39 -0600
Subject: [PATCH 085/106] build: Use PROJECT_IS_TOP_LEVEL

---
 CMakeLists.txt | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6dc4f23..50940da 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -7,8 +7,6 @@ cmake_minimum_required(VERSION 3.22.1)
 
 project(VUL LANGUAGES CXX)
 
-string(COMPARE EQUAL ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_SOURCE_DIR} VUL_IS_TOP_LEVEL) # Remove when min is 3.21
-
 set_property(GLOBAL PROPERTY USE_FOLDERS ON) # Remove when min is 3.26, see CMP0143
 
 set(CMAKE_CXX_STANDARD 17)
@@ -30,7 +28,7 @@ find_package(VulkanHeaders CONFIG)
 add_subdirectory(src)
 add_subdirectory(include)
 
-if (VUL_IS_TOP_LEVEL)
+if (PROJECT_IS_TOP_LEVEL)
     option(BUILD_TESTS "Build tests")
     if (BUILD_TESTS)
         enable_testing()

From 57554d1f445c2555896e9822211ba68485f1457a Mon Sep 17 00:00:00 2001
From: Charles Giessen <charles@lunarg.com>
Date: Fri, 21 Feb 2025 13:50:59 -0600
Subject: [PATCH 086/106] build: Add VUL_ENABLE_INSTALL option

Allows users to selectively enable installing VUL components regardless
of how they are getting VUL.
---
 CMakeLists.txt | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 50940da..8e84121 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -34,6 +34,11 @@ if (PROJECT_IS_TOP_LEVEL)
         enable_testing()
         add_subdirectory(tests)
     endif()
+endif()
+
+option(VUL_ENABLE_INSTALL "Enable install" ${PROJECT_IS_TOP_LEVEL})
+
+if (VUL_ENABLE_INSTALL)
 
     include(GNUInstallDirs)
     include(CMakePackageConfigHelpers)

From 2d8f273ebd4b843c402d9ee881616895b854e42f Mon Sep 17 00:00:00 2001
From: Charles Giessen <charles@lunarg.com>
Date: Fri, 21 Feb 2025 10:33:00 -0600
Subject: [PATCH 087/106] ci: Update to Ubuntu 22.04 & 24.04

---
 .github/workflows/ci.yml | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 2828f5a..d9af915 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -20,14 +20,14 @@ jobs:
     strategy:
       matrix:
         config: [Debug, Release]
-        os: [ ubuntu-20.04, ubuntu-22.04, windows-latest, macos-latest ]
+        os: [ ubuntu-22.04, ubuntu-24.04, windows-latest, macos-latest ]
     steps:
       - uses: actions/checkout@v4
       - name: Set up Python 3.8
         if: matrix.os != 'macos-latest'
         uses: actions/setup-python@v5
         with:
-          python-version: '3.8'      
+          python-version: '3.8'
       # MacOS machine can run on arm64 and it doesn't support 3.8
       - name: Set up Python 3.10.11
         if: matrix.os == 'macos-latest'
@@ -35,7 +35,7 @@ jobs:
         with:
           python-version: '3.10.11'
       - name: Test CMake Minimum
-        if: matrix.os == 'ubuntu-20.04'
+        if: matrix.os == 'ubuntu-22.04'
         uses: lukka/get-cmake@latest
         with:
           cmakeVersion: 3.22.1
@@ -58,11 +58,11 @@ jobs:
       - run: cmake -S. -B build -D VUL_WERROR=ON -D CMAKE_BUILD_TYPE=Debug -D UPDATE_DEPS=ON
       - run: cmake --build build
       - run: cmake --install build --prefix build/install
- 
+
   android:
     # Use chromium as a test build, so don't run this job unless something simple works first
     needs: chromium
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-24.04
     strategy:
       matrix:
         abi: [ armeabi-v7a, arm64-v8a ]
@@ -97,7 +97,7 @@ jobs:
   # Test to ensure we don't accidentally break the Chromium build.
   chromium:
     needs: generate_source
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v5
@@ -109,7 +109,7 @@ jobs:
         run: python scripts/gn/gn.py
 
   generate_source:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v5

From 5f41f2a9bf3589dc5d1791d42ff46f1abe873f2b Mon Sep 17 00:00:00 2001
From: Alan Baker <alanbaker@google.com>
Date: Thu, 27 Feb 2025 10:44:31 -0500
Subject: [PATCH 088/106] Add additional Android NDK API guards

* As of r28, some unguarded calls now generate
  `-Wunguarded-availability`
  * Change class to be guarded by ifdefs
---
 src/layer/layer_settings_manager.cpp | 38 ++++++++++++++--------------
 1 file changed, 19 insertions(+), 19 deletions(-)

diff --git a/src/layer/layer_settings_manager.cpp b/src/layer/layer_settings_manager.cpp
index 391d339..5523ea4 100644
--- a/src/layer/layer_settings_manager.cpp
+++ b/src/layer/layer_settings_manager.cpp
@@ -38,31 +38,31 @@
  * Android API level 26. If not avaible use the old __system_property_get function.
  */
 
-// Weak function declaration, used only when not decalered in the Android headers
+// Weak function declaration, used only when not declared in the Android headers
 void __system_property_read_callback(const prop_info *info,
                                      void (*callback)(void *cookie, const char *name, const char *value, uint32_t serial),
                                      void *cookie) __attribute__((weak));
 static std::string GetAndroidProperty(const char *name) {
     std::string output;
-    if (__system_property_read_callback != nullptr) {
-        const prop_info *pi = __system_property_find(name);
-        if (pi) {
-            __system_property_read_callback(
-                pi,
-                [](void *cookie, const char *name, const char *value, uint32_t serial) {
-                    (void)name;
-                    (void)serial;
-                    reinterpret_cast<std::string *>(cookie)->assign(value);
-                },
-                reinterpret_cast<void *>(&output));
-        }
-    } else {
-        char value_buf[PROP_VALUE_MAX] = "";
-        size_t len = static_cast<size_t>(__system_property_get(name, value_buf));
-        if (len > 0 && len < sizeof(value_buf)) {
-            output.assign(value_buf, len);
-        }
+#if __ANDROID_API__ >= 26
+    const prop_info *pi = __system_property_find(name);
+    if (pi) {
+        __system_property_read_callback(
+            pi,
+            [](void *cookie, const char *name, const char *value, uint32_t serial) {
+                (void)name;
+                (void)serial;
+                reinterpret_cast<std::string *>(cookie)->assign(value);
+            },
+            reinterpret_cast<void *>(&output));
     }
+#else
+    char value_buf[PROP_VALUE_MAX] = "";
+    size_t len = static_cast<size_t>(__system_property_get(name, value_buf));
+    if (len > 0 && len < sizeof(value_buf)) {
+        output.assign(value_buf, len);
+    }
+#endif
     return output;
 }
 #endif

From 50563f48368d75281bc2fb1c3407dc531ce28910 Mon Sep 17 00:00:00 2001
From: spencer-lunarg <spencer@lunarg.com>
Date: Wed, 5 Mar 2025 23:22:24 -0500
Subject: [PATCH 089/106] format: Fix DepthStencil to Color compatible check

---
 include/vulkan/utility/vk_format_utils.h     | 42 +++++++++++---------
 scripts/generators/format_utils_generator.py | 42 +++++++++++---------
 tests/test_formats.cpp                       | 22 ++++++----
 3 files changed, 63 insertions(+), 43 deletions(-)

diff --git a/include/vulkan/utility/vk_format_utils.h b/include/vulkan/utility/vk_format_utils.h
index aa0bdbc..5d8a853 100644
--- a/include/vulkan/utility/vk_format_utils.h
+++ b/include/vulkan/utility/vk_format_utils.h
@@ -263,7 +263,7 @@ inline VkExtent2D vkuFindMultiplaneExtentDivisors(VkFormat mp_fmt, VkImageAspect
 
 // From table in spec vkspec.html#formats-compatible-zs-color
 // Introduced in VK_KHR_maintenance8 to allow copying between color and depth/stencil formats
-inline bool vkuFormatIsDepthStencilWithColorSizeCompatible(VkFormat color_format, VkFormat ds_format);
+inline bool vkuFormatIsDepthStencilWithColorSizeCompatible(VkFormat color_format, VkFormat ds_format, VkImageAspectFlags aspect_mask);
 
 // Returns the count of components in a VkFormat
 inline uint32_t vkuFormatComponentCount(VkFormat format);
@@ -2046,24 +2046,30 @@ inline VkExtent2D vkuFindMultiplaneExtentDivisors(VkFormat mp_fmt, VkImageAspect
 }
 
 // TODO - This should be generated, but will need updating the spec XML and table
-inline bool vkuFormatIsDepthStencilWithColorSizeCompatible(VkFormat color_format, VkFormat ds_format) {
-    switch (ds_format) {
-        case VK_FORMAT_D32_SFLOAT:
-        case VK_FORMAT_D32_SFLOAT_S8_UINT:
-            return color_format == VK_FORMAT_R32_SFLOAT || color_format == VK_FORMAT_R32_SINT || color_format == VK_FORMAT_R32_UINT;
-        case VK_FORMAT_X8_D24_UNORM_PACK32:
-        case VK_FORMAT_D24_UNORM_S8_UINT:
-            return color_format == VK_FORMAT_R32_SFLOAT || color_format == VK_FORMAT_R32_SINT || color_format == VK_FORMAT_R32_UINT;
-        case VK_FORMAT_D16_UNORM:
-        case VK_FORMAT_D16_UNORM_S8_UINT:
-            return color_format == VK_FORMAT_R16_SFLOAT || color_format == VK_FORMAT_R16_UNORM ||
-                   color_format == VK_FORMAT_R16_SNORM  || color_format == VK_FORMAT_R16_UINT || color_format == VK_FORMAT_R16_SINT;
-        case VK_FORMAT_S8_UINT:
-            return color_format == VK_FORMAT_R8_UINT || color_format == VK_FORMAT_R8_SINT ||
-                   color_format == VK_FORMAT_R8_UNORM || color_format == VK_FORMAT_R8_SNORM;
-        default:
-            return false;
+// Some few case don't have an aspect mask, so might need to check both the Depth and Stencil possiblity
+inline bool vkuFormatIsDepthStencilWithColorSizeCompatible(VkFormat color_format, VkFormat ds_format, VkImageAspectFlags aspect_mask) {
+    bool valid = false;
+
+    if (aspect_mask & VK_IMAGE_ASPECT_STENCIL_BIT) {
+        if (ds_format == VK_FORMAT_S8_UINT || ds_format == VK_FORMAT_D16_UNORM_S8_UINT ||
+            ds_format == VK_FORMAT_D24_UNORM_S8_UINT || ds_format == VK_FORMAT_D32_SFLOAT_S8_UINT) {
+            valid |= (color_format == VK_FORMAT_R8_UINT || color_format == VK_FORMAT_R8_SINT ||
+                      color_format == VK_FORMAT_R8_UNORM || color_format == VK_FORMAT_R8_SNORM);
+        }
     }
+
+    if (aspect_mask & VK_IMAGE_ASPECT_DEPTH_BIT) {
+        if (ds_format == VK_FORMAT_D32_SFLOAT || ds_format == VK_FORMAT_D32_SFLOAT_S8_UINT ||
+            ds_format == VK_FORMAT_X8_D24_UNORM_PACK32 || ds_format == VK_FORMAT_D24_UNORM_S8_UINT) {
+            valid |= (color_format == VK_FORMAT_R32_SFLOAT || color_format == VK_FORMAT_R32_SINT || color_format == VK_FORMAT_R32_UINT);
+        }
+        if (ds_format == VK_FORMAT_D16_UNORM || ds_format == VK_FORMAT_D16_UNORM_S8_UINT) {
+            valid |= (color_format == VK_FORMAT_R16_SFLOAT || color_format == VK_FORMAT_R16_UNORM ||
+                      color_format == VK_FORMAT_R16_SNORM  || color_format == VK_FORMAT_R16_UINT || color_format == VK_FORMAT_R16_SINT);
+        }
+    }
+
+    return valid;
 }
 
 inline uint32_t vkuFormatComponentCount(VkFormat format) { return vkuGetFormatInfo(format).component_count; }
diff --git a/scripts/generators/format_utils_generator.py b/scripts/generators/format_utils_generator.py
index ed2cdd8..bdf857d 100644
--- a/scripts/generators/format_utils_generator.py
+++ b/scripts/generators/format_utils_generator.py
@@ -209,7 +209,7 @@ inline VkExtent2D vkuFindMultiplaneExtentDivisors(VkFormat mp_fmt, VkImageAspect
 
 // From table in spec vkspec.html#formats-compatible-zs-color
 // Introduced in VK_KHR_maintenance8 to allow copying between color and depth/stencil formats
-inline bool vkuFormatIsDepthStencilWithColorSizeCompatible(VkFormat color_format, VkFormat ds_format);
+inline bool vkuFormatIsDepthStencilWithColorSizeCompatible(VkFormat color_format, VkFormat ds_format, VkImageAspectFlags aspect_mask);
 
 // Returns the count of components in a VkFormat
 inline uint32_t vkuFormatComponentCount(VkFormat format);
@@ -570,24 +570,30 @@ inline VkExtent2D vkuFindMultiplaneExtentDivisors(VkFormat mp_fmt, VkImageAspect
 }
 
 // TODO - This should be generated, but will need updating the spec XML and table
-inline bool vkuFormatIsDepthStencilWithColorSizeCompatible(VkFormat color_format, VkFormat ds_format) {
-    switch (ds_format) {
-        case VK_FORMAT_D32_SFLOAT:
-        case VK_FORMAT_D32_SFLOAT_S8_UINT:
-            return color_format == VK_FORMAT_R32_SFLOAT || color_format == VK_FORMAT_R32_SINT || color_format == VK_FORMAT_R32_UINT;
-        case VK_FORMAT_X8_D24_UNORM_PACK32:
-        case VK_FORMAT_D24_UNORM_S8_UINT:
-            return color_format == VK_FORMAT_R32_SFLOAT || color_format == VK_FORMAT_R32_SINT || color_format == VK_FORMAT_R32_UINT;
-        case VK_FORMAT_D16_UNORM:
-        case VK_FORMAT_D16_UNORM_S8_UINT:
-            return color_format == VK_FORMAT_R16_SFLOAT || color_format == VK_FORMAT_R16_UNORM ||
-                   color_format == VK_FORMAT_R16_SNORM  || color_format == VK_FORMAT_R16_UINT || color_format == VK_FORMAT_R16_SINT;
-        case VK_FORMAT_S8_UINT:
-            return color_format == VK_FORMAT_R8_UINT || color_format == VK_FORMAT_R8_SINT ||
-                   color_format == VK_FORMAT_R8_UNORM || color_format == VK_FORMAT_R8_SNORM;
-        default:
-            return false;
+// Some few case don't have an aspect mask, so might need to check both the Depth and Stencil possiblity
+inline bool vkuFormatIsDepthStencilWithColorSizeCompatible(VkFormat color_format, VkFormat ds_format, VkImageAspectFlags aspect_mask) {
+    bool valid = false;
+
+    if (aspect_mask & VK_IMAGE_ASPECT_STENCIL_BIT) {
+        if (ds_format == VK_FORMAT_S8_UINT || ds_format == VK_FORMAT_D16_UNORM_S8_UINT ||
+            ds_format == VK_FORMAT_D24_UNORM_S8_UINT || ds_format == VK_FORMAT_D32_SFLOAT_S8_UINT) {
+            valid |= (color_format == VK_FORMAT_R8_UINT || color_format == VK_FORMAT_R8_SINT ||
+                      color_format == VK_FORMAT_R8_UNORM || color_format == VK_FORMAT_R8_SNORM);
+        }
     }
+
+    if (aspect_mask & VK_IMAGE_ASPECT_DEPTH_BIT) {
+        if (ds_format == VK_FORMAT_D32_SFLOAT || ds_format == VK_FORMAT_D32_SFLOAT_S8_UINT ||
+            ds_format == VK_FORMAT_X8_D24_UNORM_PACK32 || ds_format == VK_FORMAT_D24_UNORM_S8_UINT) {
+            valid |= (color_format == VK_FORMAT_R32_SFLOAT || color_format == VK_FORMAT_R32_SINT || color_format == VK_FORMAT_R32_UINT);
+        }
+        if (ds_format == VK_FORMAT_D16_UNORM || ds_format == VK_FORMAT_D16_UNORM_S8_UINT) {
+            valid |= (color_format == VK_FORMAT_R16_SFLOAT || color_format == VK_FORMAT_R16_UNORM ||
+                      color_format == VK_FORMAT_R16_SNORM  || color_format == VK_FORMAT_R16_UINT || color_format == VK_FORMAT_R16_SINT);
+        }
+    }
+
+    return valid;
 }
 
 inline uint32_t vkuFormatComponentCount(VkFormat format) { return vkuGetFormatInfo(format).component_count; }
diff --git a/tests/test_formats.cpp b/tests/test_formats.cpp
index 2ec5a52..7fa66d1 100644
--- a/tests/test_formats.cpp
+++ b/tests/test_formats.cpp
@@ -413,15 +413,23 @@ TEST(format_utils, vkuFindMultiplaneExtentDivisors) {
 }
 
 TEST(format_utils, vkuFormatIsDepthStencilWithColorSizeCompatible) {
+    EXPECT_FALSE(vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16,
+                                                                VK_FORMAT_D16_UNORM, VK_IMAGE_ASPECT_DEPTH_BIT));
     EXPECT_FALSE(
-        vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, VK_FORMAT_D16_UNORM));
-    EXPECT_FALSE(vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_D16_UNORM, VK_FORMAT_R16_SFLOAT));
-    EXPECT_FALSE(vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_R8_UINT, VK_FORMAT_D16_UNORM_S8_UINT));
-    EXPECT_FALSE(vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_R16_UNORM, VK_FORMAT_S8_UINT));
+        vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_D16_UNORM, VK_FORMAT_R16_SFLOAT, VK_IMAGE_ASPECT_DEPTH_BIT));
+    EXPECT_FALSE(
+        vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_R8_UINT, VK_FORMAT_D16_UNORM_S8_UINT, VK_IMAGE_ASPECT_DEPTH_BIT));
+    EXPECT_FALSE(vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_R16_UNORM, VK_FORMAT_S8_UINT, VK_IMAGE_ASPECT_DEPTH_BIT));
 
-    EXPECT_TRUE(vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_R16_SFLOAT, VK_FORMAT_D16_UNORM));
-    EXPECT_TRUE(vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_R16_UNORM, VK_FORMAT_D16_UNORM_S8_UINT));
-    EXPECT_TRUE(vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_R8_UINT, VK_FORMAT_S8_UINT));
+    EXPECT_TRUE(
+        vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_R16_SFLOAT, VK_FORMAT_D16_UNORM, VK_IMAGE_ASPECT_DEPTH_BIT));
+    EXPECT_TRUE(vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_R8_UINT, VK_FORMAT_D16_UNORM_S8_UINT,
+                                                               VK_IMAGE_ASPECT_STENCIL_BIT));
+    EXPECT_TRUE(vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_R16_UNORM, VK_FORMAT_D16_UNORM_S8_UINT,
+                                                               VK_IMAGE_ASPECT_DEPTH_BIT));
+    EXPECT_TRUE(vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_R16_UNORM, VK_FORMAT_D16_UNORM_S8_UINT,
+                                                               VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT));
+    EXPECT_TRUE(vkuFormatIsDepthStencilWithColorSizeCompatible(VK_FORMAT_R8_UINT, VK_FORMAT_S8_UINT, VK_IMAGE_ASPECT_STENCIL_BIT));
 }
 
 TEST(format_utils, vkuFormatComponentCount) {

From 95044b623e30f07d42e163d2d2993b50d0a3fd97 Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Fri, 7 Mar 2025 10:28:11 -0800
Subject: [PATCH 090/106] build: Update to header 1.4.310

---
 include/vulkan/utility/vk_dispatch_table.h  |  4 ++++
 include/vulkan/utility/vk_struct_helper.hpp |  2 ++
 include/vulkan/vk_enum_string_helper.h      | 22 ++++++++++++---------
 scripts/known_good.json                     |  2 +-
 4 files changed, 20 insertions(+), 10 deletions(-)

diff --git a/include/vulkan/utility/vk_dispatch_table.h b/include/vulkan/utility/vk_dispatch_table.h
index 5772966..ed6ef7f 100644
--- a/include/vulkan/utility/vk_dispatch_table.h
+++ b/include/vulkan/utility/vk_dispatch_table.h
@@ -633,12 +633,14 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkDestroyPrivateDataSlotEXT DestroyPrivateDataSlotEXT;
     PFN_vkSetPrivateDataEXT SetPrivateDataEXT;
     PFN_vkGetPrivateDataEXT GetPrivateDataEXT;
+#ifdef VK_ENABLE_BETA_EXTENSIONS
     PFN_vkCreateCudaModuleNV CreateCudaModuleNV;
     PFN_vkGetCudaModuleCacheNV GetCudaModuleCacheNV;
     PFN_vkCreateCudaFunctionNV CreateCudaFunctionNV;
     PFN_vkDestroyCudaModuleNV DestroyCudaModuleNV;
     PFN_vkDestroyCudaFunctionNV DestroyCudaFunctionNV;
     PFN_vkCmdCudaLaunchKernelNV CmdCudaLaunchKernelNV;
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #ifdef VK_USE_PLATFORM_METAL_EXT
     PFN_vkExportMetalObjectsEXT ExportMetalObjectsEXT;
 #endif  // VK_USE_PLATFORM_METAL_EXT
@@ -1275,12 +1277,14 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
     table->DestroyPrivateDataSlotEXT = (PFN_vkDestroyPrivateDataSlotEXT)gdpa(device, "vkDestroyPrivateDataSlotEXT");
     table->SetPrivateDataEXT = (PFN_vkSetPrivateDataEXT)gdpa(device, "vkSetPrivateDataEXT");
     table->GetPrivateDataEXT = (PFN_vkGetPrivateDataEXT)gdpa(device, "vkGetPrivateDataEXT");
+#ifdef VK_ENABLE_BETA_EXTENSIONS
     table->CreateCudaModuleNV = (PFN_vkCreateCudaModuleNV)gdpa(device, "vkCreateCudaModuleNV");
     table->GetCudaModuleCacheNV = (PFN_vkGetCudaModuleCacheNV)gdpa(device, "vkGetCudaModuleCacheNV");
     table->CreateCudaFunctionNV = (PFN_vkCreateCudaFunctionNV)gdpa(device, "vkCreateCudaFunctionNV");
     table->DestroyCudaModuleNV = (PFN_vkDestroyCudaModuleNV)gdpa(device, "vkDestroyCudaModuleNV");
     table->DestroyCudaFunctionNV = (PFN_vkDestroyCudaFunctionNV)gdpa(device, "vkDestroyCudaFunctionNV");
     table->CmdCudaLaunchKernelNV = (PFN_vkCmdCudaLaunchKernelNV)gdpa(device, "vkCmdCudaLaunchKernelNV");
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #ifdef VK_USE_PLATFORM_METAL_EXT
     table->ExportMetalObjectsEXT = (PFN_vkExportMetalObjectsEXT)gdpa(device, "vkExportMetalObjectsEXT");
 #endif  // VK_USE_PLATFORM_METAL_EXT
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index 55b949e..3b6b45b 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -1196,8 +1196,10 @@ template<> inline VkObjectType GetObjectType<VkValidationCacheEXT>() { return VK
 template<> inline VkObjectType GetObjectType<VkAccelerationStructureNV>() { return VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV; }
 template<> inline VkObjectType GetObjectType<VkPerformanceConfigurationINTEL>() { return VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL; }
 template<> inline VkObjectType GetObjectType<VkIndirectCommandsLayoutNV>() { return VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV; }
+#ifdef VK_ENABLE_BETA_EXTENSIONS
 template<> inline VkObjectType GetObjectType<VkCudaModuleNV>() { return VK_OBJECT_TYPE_CUDA_MODULE_NV; }
 template<> inline VkObjectType GetObjectType<VkCudaFunctionNV>() { return VK_OBJECT_TYPE_CUDA_FUNCTION_NV; }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 template<> inline VkObjectType GetObjectType<VkAccelerationStructureKHR>() { return VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR; }
 #ifdef VK_USE_PLATFORM_FUCHSIA
 template<> inline VkObjectType GetObjectType<VkBufferCollectionFUCHSIA>() { return VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index ece5b97..c31867b 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -1408,6 +1408,7 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV";
         case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
             return "VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV";
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV:
             return "VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV";
         case VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV:
@@ -1418,6 +1419,7 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV";
+#endif  // VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV:
             return "VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV";
         case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT:
@@ -2304,10 +2306,12 @@ static inline const char* string_VkObjectType(VkObjectType input_value) {
             return "VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR";
         case VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV:
             return "VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV";
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_OBJECT_TYPE_CUDA_MODULE_NV:
             return "VK_OBJECT_TYPE_CUDA_MODULE_NV";
         case VK_OBJECT_TYPE_CUDA_FUNCTION_NV:
             return "VK_OBJECT_TYPE_CUDA_FUNCTION_NV";
+#endif  // VK_ENABLE_BETA_EXTENSIONS
         case VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA:
             return "VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA";
         case VK_OBJECT_TYPE_MICROMAP_EXT:
@@ -5311,10 +5315,10 @@ static inline const char* string_VkAccessFlagBits(VkAccessFlagBits input_value)
             return "VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT";
         case VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR:
             return "VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR";
-        case VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV:
-            return "VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV";
-        case VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV:
-            return "VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV";
+        case VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT:
+            return "VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT";
+        case VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT:
+            return "VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT";
         default:
             return "Unhandled VkAccessFlagBits";
     }
@@ -5844,12 +5848,12 @@ static inline const char* string_VkPipelineStageFlagBits(VkPipelineStageFlagBits
             return "VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT";
         case VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR:
             return "VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR";
-        case VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV:
-            return "VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV";
         case VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT:
             return "VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT";
         case VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT:
             return "VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT";
+        case VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_EXT:
+            return "VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_EXT";
         default:
             return "Unhandled VkPipelineStageFlagBits";
     }
@@ -7522,7 +7526,7 @@ static inline const char* string_VkPipelineStageFlagBits2(uint64_t input_value)
     if (input_value == VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR) return "VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR";
     if (input_value == VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT) return "VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT";
     if (input_value == VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT) return "VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT";
-    if (input_value == VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV) return "VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV";
+    if (input_value == VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_EXT) return "VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_EXT";
     if (input_value == VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR) return "VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR";
     if (input_value == VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR) return "VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR";
     if (input_value == VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR) return "VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR";
@@ -7585,8 +7589,8 @@ static inline const char* string_VkAccessFlagBits2(uint64_t input_value) {
     if (input_value == VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT) return "VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT";
     if (input_value == VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT) return "VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT";
     if (input_value == VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT) return "VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT";
-    if (input_value == VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV) return "VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV";
-    if (input_value == VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV) return "VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV";
+    if (input_value == VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_EXT) return "VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_EXT";
+    if (input_value == VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_EXT) return "VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_EXT";
     if (input_value == VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR) return "VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR";
     if (input_value == VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR) return "VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR";
     if (input_value == VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR) return "VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR";
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 604ac77..c5a59b8 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.4.309"
+            "commit": "v1.4.310"
         },
         {
             "name": "googletest",

From bc3a4d9fd9b46729651a3cec4f5226f6272b8684 Mon Sep 17 00:00:00 2001
From: spencer-lunarg <spencer@lunarg.com>
Date: Fri, 7 Mar 2025 16:29:34 -0500
Subject: [PATCH 091/106] scripts: Remove Protect workaround

---
 scripts/generators/struct_helper_generator.py | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/scripts/generators/struct_helper_generator.py b/scripts/generators/struct_helper_generator.py
index 2f8efd9..12cb231 100644
--- a/scripts/generators/struct_helper_generator.py
+++ b/scripts/generators/struct_helper_generator.py
@@ -27,12 +27,6 @@ class StructHelperOutputGenerator(BaseGenerator):
         BaseGenerator.__init__(self)
 
     def generate(self):
-        # Should be fixed in 1.4.310 headers
-        # https://gitlab.khronos.org/vulkan/vulkan/-/merge_requests/7196
-        manual_protect = ["VkCudaModuleNV", "VkCudaFunctionNV", "VkCudaModuleCreateInfoNV", "VkCudaFunctionCreateInfoNV", "VkCudaLaunchInfoNV", "VkPhysicalDeviceCudaKernelLaunchFeaturesNV", "VkPhysicalDeviceCudaKernelLaunchPropertiesNV", "VkSetPresentConfigNV", "VkPhysicalDevicePresentMeteringFeaturesNV"]
-        for struct in [x for x in self.vk.structs.values() if x.name in manual_protect]:
-            struct.protect = "VK_ENABLE_BETA_EXTENSIONS"
-
         out = []
         out.append(f'''// *** THIS FILE IS GENERATED - DO NOT EDIT ***
 // See {os.path.basename(__file__)} for modifications

From ccae111ac678adbc9c74be10c8384cd1af835710 Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Fri, 21 Mar 2025 07:46:59 -0700
Subject: [PATCH 092/106] build: Update to header 1.4.311

---
 include/vulkan/utility/vk_dispatch_table.h  |   2 +
 include/vulkan/utility/vk_safe_struct.hpp   | 121 ++++++----
 include/vulkan/utility/vk_struct_helper.hpp |   8 +-
 include/vulkan/vk_enum_string_helper.h      |  22 +-
 scripts/known_good.json                     |   2 +-
 src/vulkan/vk_safe_struct_ext.cpp           | 235 ++++++++++++++++++++
 src/vulkan/vk_safe_struct_khr.cpp           |  63 ++++++
 src/vulkan/vk_safe_struct_utils.cpp         |  30 ++-
 src/vulkan/vk_safe_struct_vendor.cpp        | 195 ----------------
 9 files changed, 416 insertions(+), 262 deletions(-)

diff --git a/include/vulkan/utility/vk_dispatch_table.h b/include/vulkan/utility/vk_dispatch_table.h
index ed6ef7f..d68b79a 100644
--- a/include/vulkan/utility/vk_dispatch_table.h
+++ b/include/vulkan/utility/vk_dispatch_table.h
@@ -781,6 +781,7 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkGetMemoryMetalHandleEXT GetMemoryMetalHandleEXT;
     PFN_vkGetMemoryMetalHandlePropertiesEXT GetMemoryMetalHandlePropertiesEXT;
 #endif  // VK_USE_PLATFORM_METAL_EXT
+    PFN_vkCmdEndRendering2EXT CmdEndRendering2EXT;
     PFN_vkCreateAccelerationStructureKHR CreateAccelerationStructureKHR;
     PFN_vkDestroyAccelerationStructureKHR DestroyAccelerationStructureKHR;
     PFN_vkCmdBuildAccelerationStructuresKHR CmdBuildAccelerationStructuresKHR;
@@ -1425,6 +1426,7 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
     table->GetMemoryMetalHandleEXT = (PFN_vkGetMemoryMetalHandleEXT)gdpa(device, "vkGetMemoryMetalHandleEXT");
     table->GetMemoryMetalHandlePropertiesEXT = (PFN_vkGetMemoryMetalHandlePropertiesEXT)gdpa(device, "vkGetMemoryMetalHandlePropertiesEXT");
 #endif  // VK_USE_PLATFORM_METAL_EXT
+    table->CmdEndRendering2EXT = (PFN_vkCmdEndRendering2EXT)gdpa(device, "vkCmdEndRendering2EXT");
     table->CreateAccelerationStructureKHR = (PFN_vkCreateAccelerationStructureKHR)gdpa(device, "vkCreateAccelerationStructureKHR");
     table->DestroyAccelerationStructureKHR = (PFN_vkDestroyAccelerationStructureKHR)gdpa(device, "vkDestroyAccelerationStructureKHR");
     table->CmdBuildAccelerationStructuresKHR = (PFN_vkCmdBuildAccelerationStructuresKHR)gdpa(device, "vkCmdBuildAccelerationStructuresKHR");
diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index 5544a65..42bdb85 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -7546,6 +7546,26 @@ struct safe_VkDisplayPlaneCapabilities2KHR {
     VkDisplayPlaneCapabilities2KHR* ptr() { return reinterpret_cast<VkDisplayPlaneCapabilities2KHR*>(this); }
     VkDisplayPlaneCapabilities2KHR const* ptr() const { return reinterpret_cast<VkDisplayPlaneCapabilities2KHR const*>(this); }
 };
+struct safe_VkPhysicalDeviceShaderBfloat16FeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderBFloat16Type;
+    VkBool32 shaderBFloat16DotProduct;
+    VkBool32 shaderBFloat16CooperativeMatrix;
+
+    safe_VkPhysicalDeviceShaderBfloat16FeaturesKHR(const VkPhysicalDeviceShaderBfloat16FeaturesKHR* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderBfloat16FeaturesKHR(const safe_VkPhysicalDeviceShaderBfloat16FeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceShaderBfloat16FeaturesKHR& operator=(const safe_VkPhysicalDeviceShaderBfloat16FeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceShaderBfloat16FeaturesKHR();
+    ~safe_VkPhysicalDeviceShaderBfloat16FeaturesKHR();
+    void initialize(const VkPhysicalDeviceShaderBfloat16FeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderBfloat16FeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderBfloat16FeaturesKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceShaderBfloat16FeaturesKHR*>(this); }
+    VkPhysicalDeviceShaderBfloat16FeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderBfloat16FeaturesKHR const*>(this);
+    }
+};
 #ifdef VK_ENABLE_BETA_EXTENSIONS
 struct safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR {
     VkStructureType sType;
@@ -17054,70 +17074,71 @@ struct safe_VkRenderPassStripeSubmitInfoARM {
     VkRenderPassStripeSubmitInfoARM* ptr() { return reinterpret_cast<VkRenderPassStripeSubmitInfoARM*>(this); }
     VkRenderPassStripeSubmitInfoARM const* ptr() const { return reinterpret_cast<VkRenderPassStripeSubmitInfoARM const*>(this); }
 };
-struct safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
+struct safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT {
     VkStructureType sType;
     void* pNext{};
     VkBool32 fragmentDensityMapOffset;
 
-    safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* in_struct,
-                                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
-        const safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& copy_src);
-    safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& operator=(
-        const safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& copy_src);
-    safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM();
-    ~safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM();
-    void initialize(const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* copy_src, PNextCopyState* copy_state = {});
-    VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* ptr() {
-        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM*>(this);
+    safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT(const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT* in_struct,
+                                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT(
+        const safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT();
+    ~safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT();
+    void initialize(const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT*>(this);
     }
-    VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const* ptr() const {
-        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const*>(this);
+    VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const*>(this);
     }
 };
-struct safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
+struct safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT {
     VkStructureType sType;
     void* pNext{};
     VkExtent2D fragmentDensityOffsetGranularity;
 
-    safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
-        const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* in_struct, PNextCopyState* copy_state = {},
+    safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT(
+        const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT* in_struct, PNextCopyState* copy_state = {},
         bool copy_pnext = true);
-    safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
-        const safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM& copy_src);
-    safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM& operator=(
-        const safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM& copy_src);
-    safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM();
-    ~safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM();
-    void initialize(const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* copy_src, PNextCopyState* copy_state = {});
-    VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* ptr() {
-        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM*>(this);
+    safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT(
+        const safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT& operator=(
+        const safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT& copy_src);
+    safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT();
+    ~safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT();
+    void initialize(const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT*>(this);
     }
-    VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const* ptr() const {
-        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const*>(this);
+    VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const*>(this);
     }
 };
-struct safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM {
+struct safe_VkRenderPassFragmentDensityMapOffsetEndInfoEXT {
     VkStructureType sType;
     const void* pNext{};
     uint32_t fragmentDensityOffsetCount;
     const VkOffset2D* pFragmentDensityOffsets{};
 
-    safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(const VkSubpassFragmentDensityMapOffsetEndInfoQCOM* in_struct,
-                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(const safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM& copy_src);
-    safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM& operator=(const safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM& copy_src);
-    safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM();
-    ~safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM();
-    void initialize(const VkSubpassFragmentDensityMapOffsetEndInfoQCOM* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM* copy_src, PNextCopyState* copy_state = {});
-    VkSubpassFragmentDensityMapOffsetEndInfoQCOM* ptr() {
-        return reinterpret_cast<VkSubpassFragmentDensityMapOffsetEndInfoQCOM*>(this);
+    safe_VkRenderPassFragmentDensityMapOffsetEndInfoEXT(const VkRenderPassFragmentDensityMapOffsetEndInfoEXT* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkRenderPassFragmentDensityMapOffsetEndInfoEXT(const safe_VkRenderPassFragmentDensityMapOffsetEndInfoEXT& copy_src);
+    safe_VkRenderPassFragmentDensityMapOffsetEndInfoEXT& operator=(
+        const safe_VkRenderPassFragmentDensityMapOffsetEndInfoEXT& copy_src);
+    safe_VkRenderPassFragmentDensityMapOffsetEndInfoEXT();
+    ~safe_VkRenderPassFragmentDensityMapOffsetEndInfoEXT();
+    void initialize(const VkRenderPassFragmentDensityMapOffsetEndInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderPassFragmentDensityMapOffsetEndInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassFragmentDensityMapOffsetEndInfoEXT* ptr() {
+        return reinterpret_cast<VkRenderPassFragmentDensityMapOffsetEndInfoEXT*>(this);
     }
-    VkSubpassFragmentDensityMapOffsetEndInfoQCOM const* ptr() const {
-        return reinterpret_cast<VkSubpassFragmentDensityMapOffsetEndInfoQCOM const*>(this);
+    VkRenderPassFragmentDensityMapOffsetEndInfoEXT const* ptr() const {
+        return reinterpret_cast<VkRenderPassFragmentDensityMapOffsetEndInfoEXT const*>(this);
     }
 };
 struct safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV {
@@ -20329,6 +20350,20 @@ struct safe_VkPhysicalDevicePresentMeteringFeaturesNV {
     }
 };
 #endif  // VK_ENABLE_BETA_EXTENSIONS
+struct safe_VkRenderingEndInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+
+    safe_VkRenderingEndInfoEXT(const VkRenderingEndInfoEXT* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkRenderingEndInfoEXT(const safe_VkRenderingEndInfoEXT& copy_src);
+    safe_VkRenderingEndInfoEXT& operator=(const safe_VkRenderingEndInfoEXT& copy_src);
+    safe_VkRenderingEndInfoEXT();
+    ~safe_VkRenderingEndInfoEXT();
+    void initialize(const VkRenderingEndInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderingEndInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkRenderingEndInfoEXT* ptr() { return reinterpret_cast<VkRenderingEndInfoEXT*>(this); }
+    VkRenderingEndInfoEXT const* ptr() const { return reinterpret_cast<VkRenderingEndInfoEXT const*>(this); }
+};
 struct safe_VkAccelerationStructureGeometryTrianglesDataKHR {
     VkStructureType sType;
     const void* pNext{};
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index 3b6b45b..b9dc50e 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -404,6 +404,7 @@ template <> inline VkStructureType GetSType<VkDisplayPlaneProperties2KHR>() { re
 template <> inline VkStructureType GetSType<VkDisplayModeProperties2KHR>() { return VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR; }
 template <> inline VkStructureType GetSType<VkDisplayPlaneInfo2KHR>() { return VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR; }
 template <> inline VkStructureType GetSType<VkDisplayPlaneCapabilities2KHR>() { return VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderBfloat16FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR; }
 #ifdef VK_ENABLE_BETA_EXTENSIONS
 template <> inline VkStructureType GetSType<VkPhysicalDevicePortabilitySubsetFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDevicePortabilitySubsetPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR; }
@@ -897,9 +898,9 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceRenderPassStripedPro
 template <> inline VkStructureType GetSType<VkRenderPassStripeInfoARM>() { return VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM; }
 template <> inline VkStructureType GetSType<VkRenderPassStripeBeginInfoARM>() { return VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM; }
 template <> inline VkStructureType GetSType<VkRenderPassStripeSubmitInfoARM>() { return VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM; }
-template <> inline VkStructureType GetSType<VkSubpassFragmentDensityMapOffsetEndInfoQCOM>() { return VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT; }
+template <> inline VkStructureType GetSType<VkRenderPassFragmentDensityMapOffsetEndInfoEXT>() { return VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCopyMemoryIndirectFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCopyMemoryIndirectPropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceMemoryDecompressionFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV; }
@@ -1057,6 +1058,7 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceVertexAttributeRobus
 template <> inline VkStructureType GetSType<VkSetPresentConfigNV>() { return VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDevicePresentMeteringFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV; }
 #endif  // VK_ENABLE_BETA_EXTENSIONS
+template <> inline VkStructureType GetSType<VkRenderingEndInfoEXT>() { return VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryTrianglesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryAabbsDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryInstancesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index c31867b..3c30dd4 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -1006,6 +1006,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
 #endif  // VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
             return "VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR";
         case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
             return "VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT";
         case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
@@ -1704,12 +1706,6 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM";
         case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM:
             return "VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM";
-        case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM:
-            return "VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV:
@@ -2136,6 +2132,14 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV";
 #endif  // VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT";
+        case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT:
+            return "VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT";
+        case VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT:
+            return "VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT";
         default:
             return "Unhandled VkStructureType";
     }
@@ -4060,6 +4064,8 @@ static inline const char* string_VkComponentTypeKHR(VkComponentTypeKHR input_val
             return "VK_COMPONENT_TYPE_UINT32_KHR";
         case VK_COMPONENT_TYPE_UINT64_KHR:
             return "VK_COMPONENT_TYPE_UINT64_KHR";
+        case VK_COMPONENT_TYPE_BFLOAT16_KHR:
+            return "VK_COMPONENT_TYPE_BFLOAT16_KHR";
         case VK_COMPONENT_TYPE_SINT8_PACKED_NV:
             return "VK_COMPONENT_TYPE_SINT8_PACKED_NV";
         case VK_COMPONENT_TYPE_UINT8_PACKED_NV:
@@ -5510,10 +5516,10 @@ static inline const char* string_VkImageCreateFlagBits(VkImageCreateFlagBits inp
             return "VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT";
         case VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT:
             return "VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT";
-        case VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM:
-            return "VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM";
         case VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR:
             return "VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR";
+        case VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT:
+            return "VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT";
         default:
             return "Unhandled VkImageCreateFlagBits";
     }
diff --git a/scripts/known_good.json b/scripts/known_good.json
index c5a59b8..9f83ed8 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.4.310"
+            "commit": "v1.4.311"
         },
         {
             "name": "googletest",
diff --git a/src/vulkan/vk_safe_struct_ext.cpp b/src/vulkan/vk_safe_struct_ext.cpp
index 2a7e197..8ae56bc 100644
--- a/src/vulkan/vk_safe_struct_ext.cpp
+++ b/src/vulkan/vk_safe_struct_ext.cpp
@@ -12387,6 +12387,201 @@ void safe_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT::initialize(
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT::safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT(
+    const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), fragmentDensityMapOffset(in_struct->fragmentDensityMapOffset) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT::safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT),
+      pNext(nullptr),
+      fragmentDensityMapOffset() {}
+
+safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT::safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT(
+    const safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    fragmentDensityMapOffset = copy_src.fragmentDensityMapOffset;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT& safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    fragmentDensityMapOffset = copy_src.fragmentDensityMapOffset;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT::~safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT::initialize(
+    const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    fragmentDensityMapOffset = in_struct->fragmentDensityMapOffset;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    fragmentDensityMapOffset = copy_src->fragmentDensityMapOffset;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT::safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT(
+    const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), fragmentDensityOffsetGranularity(in_struct->fragmentDensityOffsetGranularity) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT::safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT),
+      pNext(nullptr),
+      fragmentDensityOffsetGranularity() {}
+
+safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT::safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT(
+    const safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT& copy_src) {
+    sType = copy_src.sType;
+    fragmentDensityOffsetGranularity = copy_src.fragmentDensityOffsetGranularity;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT& safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT::operator=(
+    const safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    fragmentDensityOffsetGranularity = copy_src.fragmentDensityOffsetGranularity;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT::~safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT::initialize(
+    const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    fragmentDensityOffsetGranularity = in_struct->fragmentDensityOffsetGranularity;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT::initialize(
+    const safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    fragmentDensityOffsetGranularity = copy_src->fragmentDensityOffsetGranularity;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkRenderPassFragmentDensityMapOffsetEndInfoEXT::safe_VkRenderPassFragmentDensityMapOffsetEndInfoEXT(
+    const VkRenderPassFragmentDensityMapOffsetEndInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), fragmentDensityOffsetCount(in_struct->fragmentDensityOffsetCount), pFragmentDensityOffsets(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pFragmentDensityOffsets) {
+        pFragmentDensityOffsets = new VkOffset2D[in_struct->fragmentDensityOffsetCount];
+        memcpy((void*)pFragmentDensityOffsets, (void*)in_struct->pFragmentDensityOffsets,
+               sizeof(VkOffset2D) * in_struct->fragmentDensityOffsetCount);
+    }
+}
+
+safe_VkRenderPassFragmentDensityMapOffsetEndInfoEXT::safe_VkRenderPassFragmentDensityMapOffsetEndInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT),
+      pNext(nullptr),
+      fragmentDensityOffsetCount(),
+      pFragmentDensityOffsets(nullptr) {}
+
+safe_VkRenderPassFragmentDensityMapOffsetEndInfoEXT::safe_VkRenderPassFragmentDensityMapOffsetEndInfoEXT(
+    const safe_VkRenderPassFragmentDensityMapOffsetEndInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    fragmentDensityOffsetCount = copy_src.fragmentDensityOffsetCount;
+    pFragmentDensityOffsets = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pFragmentDensityOffsets) {
+        pFragmentDensityOffsets = new VkOffset2D[copy_src.fragmentDensityOffsetCount];
+        memcpy((void*)pFragmentDensityOffsets, (void*)copy_src.pFragmentDensityOffsets,
+               sizeof(VkOffset2D) * copy_src.fragmentDensityOffsetCount);
+    }
+}
+
+safe_VkRenderPassFragmentDensityMapOffsetEndInfoEXT& safe_VkRenderPassFragmentDensityMapOffsetEndInfoEXT::operator=(
+    const safe_VkRenderPassFragmentDensityMapOffsetEndInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pFragmentDensityOffsets) delete[] pFragmentDensityOffsets;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    fragmentDensityOffsetCount = copy_src.fragmentDensityOffsetCount;
+    pFragmentDensityOffsets = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pFragmentDensityOffsets) {
+        pFragmentDensityOffsets = new VkOffset2D[copy_src.fragmentDensityOffsetCount];
+        memcpy((void*)pFragmentDensityOffsets, (void*)copy_src.pFragmentDensityOffsets,
+               sizeof(VkOffset2D) * copy_src.fragmentDensityOffsetCount);
+    }
+
+    return *this;
+}
+
+safe_VkRenderPassFragmentDensityMapOffsetEndInfoEXT::~safe_VkRenderPassFragmentDensityMapOffsetEndInfoEXT() {
+    if (pFragmentDensityOffsets) delete[] pFragmentDensityOffsets;
+    FreePnextChain(pNext);
+}
+
+void safe_VkRenderPassFragmentDensityMapOffsetEndInfoEXT::initialize(
+    const VkRenderPassFragmentDensityMapOffsetEndInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pFragmentDensityOffsets) delete[] pFragmentDensityOffsets;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    fragmentDensityOffsetCount = in_struct->fragmentDensityOffsetCount;
+    pFragmentDensityOffsets = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pFragmentDensityOffsets) {
+        pFragmentDensityOffsets = new VkOffset2D[in_struct->fragmentDensityOffsetCount];
+        memcpy((void*)pFragmentDensityOffsets, (void*)in_struct->pFragmentDensityOffsets,
+               sizeof(VkOffset2D) * in_struct->fragmentDensityOffsetCount);
+    }
+}
+
+void safe_VkRenderPassFragmentDensityMapOffsetEndInfoEXT::initialize(
+    const safe_VkRenderPassFragmentDensityMapOffsetEndInfoEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    fragmentDensityOffsetCount = copy_src->fragmentDensityOffsetCount;
+    pFragmentDensityOffsets = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pFragmentDensityOffsets) {
+        pFragmentDensityOffsets = new VkOffset2D[copy_src->fragmentDensityOffsetCount];
+        memcpy((void*)pFragmentDensityOffsets, (void*)copy_src->pFragmentDensityOffsets,
+               sizeof(VkOffset2D) * copy_src->fragmentDensityOffsetCount);
+    }
+}
+
 safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT::safe_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
     const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
     bool copy_pnext)
@@ -15702,6 +15897,46 @@ void safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT::initialize(
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkRenderingEndInfoEXT::safe_VkRenderingEndInfoEXT(const VkRenderingEndInfoEXT* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkRenderingEndInfoEXT::safe_VkRenderingEndInfoEXT() : sType(VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT), pNext(nullptr) {}
+
+safe_VkRenderingEndInfoEXT::safe_VkRenderingEndInfoEXT(const safe_VkRenderingEndInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkRenderingEndInfoEXT& safe_VkRenderingEndInfoEXT::operator=(const safe_VkRenderingEndInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkRenderingEndInfoEXT::~safe_VkRenderingEndInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkRenderingEndInfoEXT::initialize(const VkRenderingEndInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkRenderingEndInfoEXT::initialize(const safe_VkRenderingEndInfoEXT* copy_src,
+                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkPhysicalDeviceMeshShaderFeaturesEXT::safe_VkPhysicalDeviceMeshShaderFeaturesEXT(
     const VkPhysicalDeviceMeshShaderFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType),
diff --git a/src/vulkan/vk_safe_struct_khr.cpp b/src/vulkan/vk_safe_struct_khr.cpp
index 303938a..2ad1936 100644
--- a/src/vulkan/vk_safe_struct_khr.cpp
+++ b/src/vulkan/vk_safe_struct_khr.cpp
@@ -7740,6 +7740,69 @@ void safe_VkDisplayPlaneCapabilities2KHR::initialize(const safe_VkDisplayPlaneCa
     capabilities = copy_src->capabilities;
     pNext = SafePnextCopy(copy_src->pNext);
 }
+
+safe_VkPhysicalDeviceShaderBfloat16FeaturesKHR::safe_VkPhysicalDeviceShaderBfloat16FeaturesKHR(
+    const VkPhysicalDeviceShaderBfloat16FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      shaderBFloat16Type(in_struct->shaderBFloat16Type),
+      shaderBFloat16DotProduct(in_struct->shaderBFloat16DotProduct),
+      shaderBFloat16CooperativeMatrix(in_struct->shaderBFloat16CooperativeMatrix) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderBfloat16FeaturesKHR::safe_VkPhysicalDeviceShaderBfloat16FeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR),
+      pNext(nullptr),
+      shaderBFloat16Type(),
+      shaderBFloat16DotProduct(),
+      shaderBFloat16CooperativeMatrix() {}
+
+safe_VkPhysicalDeviceShaderBfloat16FeaturesKHR::safe_VkPhysicalDeviceShaderBfloat16FeaturesKHR(
+    const safe_VkPhysicalDeviceShaderBfloat16FeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    shaderBFloat16Type = copy_src.shaderBFloat16Type;
+    shaderBFloat16DotProduct = copy_src.shaderBFloat16DotProduct;
+    shaderBFloat16CooperativeMatrix = copy_src.shaderBFloat16CooperativeMatrix;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderBfloat16FeaturesKHR& safe_VkPhysicalDeviceShaderBfloat16FeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceShaderBfloat16FeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderBFloat16Type = copy_src.shaderBFloat16Type;
+    shaderBFloat16DotProduct = copy_src.shaderBFloat16DotProduct;
+    shaderBFloat16CooperativeMatrix = copy_src.shaderBFloat16CooperativeMatrix;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderBfloat16FeaturesKHR::~safe_VkPhysicalDeviceShaderBfloat16FeaturesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceShaderBfloat16FeaturesKHR::initialize(const VkPhysicalDeviceShaderBfloat16FeaturesKHR* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderBFloat16Type = in_struct->shaderBFloat16Type;
+    shaderBFloat16DotProduct = in_struct->shaderBFloat16DotProduct;
+    shaderBFloat16CooperativeMatrix = in_struct->shaderBFloat16CooperativeMatrix;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderBfloat16FeaturesKHR::initialize(const safe_VkPhysicalDeviceShaderBfloat16FeaturesKHR* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderBFloat16Type = copy_src->shaderBFloat16Type;
+    shaderBFloat16DotProduct = copy_src->shaderBFloat16DotProduct;
+    shaderBFloat16CooperativeMatrix = copy_src->shaderBFloat16CooperativeMatrix;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
 #ifdef VK_ENABLE_BETA_EXTENSIONS
 
 safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR::safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index 2571e43..cdcfb69 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -663,6 +663,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
                 safe_pNext = new safe_VkPerformanceQuerySubmitInfoKHR(reinterpret_cast<const VkPerformanceQuerySubmitInfoKHR *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceShaderBfloat16FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceShaderBfloat16FeaturesKHR *>(pNext), copy_state, false);
+                break;
 #ifdef VK_ENABLE_BETA_EXTENSIONS
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR:
                 safe_pNext = new safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR(reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR *>(pNext), copy_state, false);
@@ -1691,14 +1694,14 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM:
                 safe_pNext = new safe_VkRenderPassStripeSubmitInfoARM(reinterpret_cast<const VkRenderPassStripeSubmitInfoARM *>(pNext), copy_state, false);
                 break;
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
-                safe_pNext = new safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *>(pNext), copy_state, false);
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *>(pNext), copy_state, false);
                 break;
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM:
-                safe_pNext = new safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *>(pNext), copy_state, false);
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT *>(pNext), copy_state, false);
                 break;
-            case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM:
-                safe_pNext = new safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(reinterpret_cast<const VkSubpassFragmentDensityMapOffsetEndInfoQCOM *>(pNext), copy_state, false);
+            case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT:
+                safe_pNext = new safe_VkRenderPassFragmentDensityMapOffsetEndInfoEXT(reinterpret_cast<const VkRenderPassFragmentDensityMapOffsetEndInfoEXT *>(pNext), copy_state, false);
                 break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
                 safe_pNext = new safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *>(pNext), copy_state, false);
@@ -2714,6 +2717,9 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
             delete reinterpret_cast<safe_VkPerformanceQuerySubmitInfoKHR *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR:
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderBfloat16FeaturesKHR *>(header);
+            break;
 #ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR:
             delete reinterpret_cast<safe_VkPhysicalDevicePortabilitySubsetFeaturesKHR *>(header);
@@ -3742,14 +3748,14 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM:
             delete reinterpret_cast<safe_VkRenderPassStripeSubmitInfoARM *>(header);
             break;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM:
-            delete reinterpret_cast<safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *>(header);
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT:
+            delete reinterpret_cast<safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *>(header);
             break;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM:
-            delete reinterpret_cast<safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *>(header);
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT:
+            delete reinterpret_cast<safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT *>(header);
             break;
-        case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM:
-            delete reinterpret_cast<safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM *>(header);
+        case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT:
+            delete reinterpret_cast<safe_VkRenderPassFragmentDensityMapOffsetEndInfoEXT *>(header);
             break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
             delete reinterpret_cast<safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *>(header);
diff --git a/src/vulkan/vk_safe_struct_vendor.cpp b/src/vulkan/vk_safe_struct_vendor.cpp
index 220a52a..e12547c 100644
--- a/src/vulkan/vk_safe_struct_vendor.cpp
+++ b/src/vulkan/vk_safe_struct_vendor.cpp
@@ -11132,201 +11132,6 @@ void safe_VkRenderPassStripeSubmitInfoARM::initialize(const safe_VkRenderPassStr
     }
 }
 
-safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM::safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
-    const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
-    bool copy_pnext)
-    : sType(in_struct->sType), fragmentDensityMapOffset(in_struct->fragmentDensityMapOffset) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM::safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM()
-    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM),
-      pNext(nullptr),
-      fragmentDensityMapOffset() {}
-
-safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM::safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
-    const safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& copy_src) {
-    sType = copy_src.sType;
-    fragmentDensityMapOffset = copy_src.fragmentDensityMapOffset;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM::operator=(
-    const safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    fragmentDensityMapOffset = copy_src.fragmentDensityMapOffset;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM::~safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM() {
-    FreePnextChain(pNext);
-}
-
-void safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM::initialize(
-    const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    fragmentDensityMapOffset = in_struct->fragmentDensityMapOffset;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM::initialize(
-    const safe_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    fragmentDensityMapOffset = copy_src->fragmentDensityMapOffset;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM::safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
-    const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
-    bool copy_pnext)
-    : sType(in_struct->sType), fragmentDensityOffsetGranularity(in_struct->fragmentDensityOffsetGranularity) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM::safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM()
-    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM),
-      pNext(nullptr),
-      fragmentDensityOffsetGranularity() {}
-
-safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM::safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
-    const safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM& copy_src) {
-    sType = copy_src.sType;
-    fragmentDensityOffsetGranularity = copy_src.fragmentDensityOffsetGranularity;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM& safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM::operator=(
-    const safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    fragmentDensityOffsetGranularity = copy_src.fragmentDensityOffsetGranularity;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM::~safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM() {
-    FreePnextChain(pNext);
-}
-
-void safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM::initialize(
-    const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    fragmentDensityOffsetGranularity = in_struct->fragmentDensityOffsetGranularity;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM::initialize(
-    const safe_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    fragmentDensityOffsetGranularity = copy_src->fragmentDensityOffsetGranularity;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM::safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
-    const VkSubpassFragmentDensityMapOffsetEndInfoQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType), fragmentDensityOffsetCount(in_struct->fragmentDensityOffsetCount), pFragmentDensityOffsets(nullptr) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-    if (in_struct->pFragmentDensityOffsets) {
-        pFragmentDensityOffsets = new VkOffset2D[in_struct->fragmentDensityOffsetCount];
-        memcpy((void*)pFragmentDensityOffsets, (void*)in_struct->pFragmentDensityOffsets,
-               sizeof(VkOffset2D) * in_struct->fragmentDensityOffsetCount);
-    }
-}
-
-safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM::safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM()
-    : sType(VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM),
-      pNext(nullptr),
-      fragmentDensityOffsetCount(),
-      pFragmentDensityOffsets(nullptr) {}
-
-safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM::safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
-    const safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM& copy_src) {
-    sType = copy_src.sType;
-    fragmentDensityOffsetCount = copy_src.fragmentDensityOffsetCount;
-    pFragmentDensityOffsets = nullptr;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    if (copy_src.pFragmentDensityOffsets) {
-        pFragmentDensityOffsets = new VkOffset2D[copy_src.fragmentDensityOffsetCount];
-        memcpy((void*)pFragmentDensityOffsets, (void*)copy_src.pFragmentDensityOffsets,
-               sizeof(VkOffset2D) * copy_src.fragmentDensityOffsetCount);
-    }
-}
-
-safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM& safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM::operator=(
-    const safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM& copy_src) {
-    if (&copy_src == this) return *this;
-
-    if (pFragmentDensityOffsets) delete[] pFragmentDensityOffsets;
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    fragmentDensityOffsetCount = copy_src.fragmentDensityOffsetCount;
-    pFragmentDensityOffsets = nullptr;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    if (copy_src.pFragmentDensityOffsets) {
-        pFragmentDensityOffsets = new VkOffset2D[copy_src.fragmentDensityOffsetCount];
-        memcpy((void*)pFragmentDensityOffsets, (void*)copy_src.pFragmentDensityOffsets,
-               sizeof(VkOffset2D) * copy_src.fragmentDensityOffsetCount);
-    }
-
-    return *this;
-}
-
-safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM::~safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM() {
-    if (pFragmentDensityOffsets) delete[] pFragmentDensityOffsets;
-    FreePnextChain(pNext);
-}
-
-void safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM::initialize(const VkSubpassFragmentDensityMapOffsetEndInfoQCOM* in_struct,
-                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
-    if (pFragmentDensityOffsets) delete[] pFragmentDensityOffsets;
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    fragmentDensityOffsetCount = in_struct->fragmentDensityOffsetCount;
-    pFragmentDensityOffsets = nullptr;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-
-    if (in_struct->pFragmentDensityOffsets) {
-        pFragmentDensityOffsets = new VkOffset2D[in_struct->fragmentDensityOffsetCount];
-        memcpy((void*)pFragmentDensityOffsets, (void*)in_struct->pFragmentDensityOffsets,
-               sizeof(VkOffset2D) * in_struct->fragmentDensityOffsetCount);
-    }
-}
-
-void safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM::initialize(
-    const safe_VkSubpassFragmentDensityMapOffsetEndInfoQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    fragmentDensityOffsetCount = copy_src->fragmentDensityOffsetCount;
-    pFragmentDensityOffsets = nullptr;
-    pNext = SafePnextCopy(copy_src->pNext);
-
-    if (copy_src->pFragmentDensityOffsets) {
-        pFragmentDensityOffsets = new VkOffset2D[copy_src->fragmentDensityOffsetCount];
-        memcpy((void*)pFragmentDensityOffsets, (void*)copy_src->pFragmentDensityOffsets,
-               sizeof(VkOffset2D) * copy_src->fragmentDensityOffsetCount);
-    }
-}
-
 safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV::safe_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
     const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType), indirectCopy(in_struct->indirectCopy) {

From 04e2efb904a224bd7014cd4b0a8539bdc85e4658 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 24 Mar 2025 17:28:11 +0000
Subject: [PATCH 093/106] build(deps): Bump jidicula/clang-format-action from
 4.14.0 to 4.15.0

Bumps [jidicula/clang-format-action](https://github.com/jidicula/clang-format-action) from 4.14.0 to 4.15.0.
- [Release notes](https://github.com/jidicula/clang-format-action/releases)
- [Commits](https://github.com/jidicula/clang-format-action/compare/v4.14.0...v4.15.0)

---
updated-dependencies:
- dependency-name: jidicula/clang-format-action
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 .github/workflows/format.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/format.yml b/.github/workflows/format.yml
index 0837768..892f1be 100644
--- a/.github/workflows/format.yml
+++ b/.github/workflows/format.yml
@@ -28,7 +28,7 @@ jobs:
     steps:
     - uses: actions/checkout@v4
     - name: Run clang-format
-      uses: jidicula/clang-format-action@v4.14.0
+      uses: jidicula/clang-format-action@v4.15.0
       with:
         clang-format-version: '14'
         check-path: ${{ matrix.path }}

From 0d5b49b80f17bca25e7f9321ad4e671a56f70887 Mon Sep 17 00:00:00 2001
From: Charles Giessen <charles@lunarg.com>
Date: Wed, 5 Mar 2025 12:15:59 -0600
Subject: [PATCH 094/106] formats: vkuGetFormatInfo to use array

Puts the contents of a switch in a big array, then rewrites
vkuGetFormatInfo() to index into it based on the formats enum value.

This was done because the switch statement was large enough that
compilers wouldn't inline the function, leading to performance bubbles.

The logic for generating the logic of vkuGetFormatInfo is complex but
boils down to finding the groups of consecutive VkFormats, where the
end of a group has a value that is more than 1 away from the next format
value.

To follow C const initializer rules, VKU_FORMAT_COMPRESSED_COMPONENT
had to be turned into a macro.
---
 include/vulkan/utility/vk_format_utils.h     | 1021 +++++-------------
 scripts/generators/format_utils_generator.py |   61 +-
 2 files changed, 311 insertions(+), 771 deletions(-)

diff --git a/include/vulkan/utility/vk_format_utils.h b/include/vulkan/utility/vk_format_utils.h
index 5d8a853..0bdefc5 100644
--- a/include/vulkan/utility/vk_format_utils.h
+++ b/include/vulkan/utility/vk_format_utils.h
@@ -353,7 +353,7 @@ enum VKU_FORMAT_COMPONENT_TYPE {
 };
 
 // Compressed formats don't have a defined component size
-const uint32_t VKU_FORMAT_COMPRESSED_COMPONENT = 0xFFFFFFFF;
+#define VKU_FORMAT_COMPRESSED_COMPONENT 0xFFFFFFFF
 
 struct VKU_FORMAT_COMPONENT_INFO {
     enum VKU_FORMAT_COMPONENT_TYPE type;
@@ -369,762 +369,271 @@ struct VKU_FORMAT_INFO {
     uint32_t component_count;
     struct VKU_FORMAT_COMPONENT_INFO components[VKU_FORMAT_MAX_COMPONENTS];
 };
+const struct VKU_FORMAT_INFO vku_formats[250] = {
+    { VKU_FORMAT_COMPATIBILITY_CLASS_NONE, 0, 0, {0, 0, 0}, 0, {} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_8BIT, 1, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 4}, {VKU_FORMAT_COMPONENT_TYPE_G, 4}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 4}, {VKU_FORMAT_COMPONENT_TYPE_G, 4}, {VKU_FORMAT_COMPONENT_TYPE_B, 4}, {VKU_FORMAT_COMPONENT_TYPE_A, 4}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_B, 4}, {VKU_FORMAT_COMPONENT_TYPE_G, 4}, {VKU_FORMAT_COMPONENT_TYPE_R, 4}, {VKU_FORMAT_COMPONENT_TYPE_A, 4}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 5}, {VKU_FORMAT_COMPONENT_TYPE_G, 6}, {VKU_FORMAT_COMPONENT_TYPE_B, 5}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_B, 5}, {VKU_FORMAT_COMPONENT_TYPE_G, 6}, {VKU_FORMAT_COMPONENT_TYPE_R, 5}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 5}, {VKU_FORMAT_COMPONENT_TYPE_G, 5}, {VKU_FORMAT_COMPONENT_TYPE_B, 5}, {VKU_FORMAT_COMPONENT_TYPE_A, 1}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_B, 5}, {VKU_FORMAT_COMPONENT_TYPE_G, 5}, {VKU_FORMAT_COMPONENT_TYPE_R, 5}, {VKU_FORMAT_COMPONENT_TYPE_A, 1}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 1}, {VKU_FORMAT_COMPONENT_TYPE_R, 5}, {VKU_FORMAT_COMPONENT_TYPE_G, 5}, {VKU_FORMAT_COMPONENT_TYPE_B, 5}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_8BIT, 1, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_8BIT, 1, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_8BIT, 1, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_8BIT, 1, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_8BIT, 1, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_8BIT, 1, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_8BIT, 1, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_24BIT, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_24BIT, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_24BIT, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_24BIT, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_24BIT, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_24BIT, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_24BIT, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_24BIT, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_24BIT, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_24BIT, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_24BIT, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_24BIT, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_24BIT, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_24BIT, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_A, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_A, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_A, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_A, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_A, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_A, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_A, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_A, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_A, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_A, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_A, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_A, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_A, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_A, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 2}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 2}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 2}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 2}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 2}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 2}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 2}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 2}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 2}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 2}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 2}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 2}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_48BIT, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_48BIT, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_48BIT, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_48BIT, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_48BIT, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_48BIT, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_48BIT, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_64BIT, 8, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_A, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_64BIT, 8, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_A, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_64BIT, 8, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_A, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_64BIT, 8, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_A, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_64BIT, 8, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_A, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_64BIT, 8, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_A, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_64BIT, 8, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_A, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 32}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 32}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 32}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_64BIT, 8, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 32}, {VKU_FORMAT_COMPONENT_TYPE_G, 32}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_64BIT, 8, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 32}, {VKU_FORMAT_COMPONENT_TYPE_G, 32}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_64BIT, 8, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 32}, {VKU_FORMAT_COMPONENT_TYPE_G, 32}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_96BIT, 12, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 32}, {VKU_FORMAT_COMPONENT_TYPE_G, 32}, {VKU_FORMAT_COMPONENT_TYPE_B, 32}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_96BIT, 12, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 32}, {VKU_FORMAT_COMPONENT_TYPE_G, 32}, {VKU_FORMAT_COMPONENT_TYPE_B, 32}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_96BIT, 12, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 32}, {VKU_FORMAT_COMPONENT_TYPE_G, 32}, {VKU_FORMAT_COMPONENT_TYPE_B, 32}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_128BIT, 16, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 32}, {VKU_FORMAT_COMPONENT_TYPE_G, 32}, {VKU_FORMAT_COMPONENT_TYPE_B, 32}, {VKU_FORMAT_COMPONENT_TYPE_A, 32}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_128BIT, 16, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 32}, {VKU_FORMAT_COMPONENT_TYPE_G, 32}, {VKU_FORMAT_COMPONENT_TYPE_B, 32}, {VKU_FORMAT_COMPONENT_TYPE_A, 32}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_128BIT, 16, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 32}, {VKU_FORMAT_COMPONENT_TYPE_G, 32}, {VKU_FORMAT_COMPONENT_TYPE_B, 32}, {VKU_FORMAT_COMPONENT_TYPE_A, 32}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_64BIT, 8, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 64}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_64BIT, 8, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 64}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_64BIT, 8, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 64}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_128BIT, 16, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 64}, {VKU_FORMAT_COMPONENT_TYPE_G, 64}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_128BIT, 16, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 64}, {VKU_FORMAT_COMPONENT_TYPE_G, 64}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_128BIT, 16, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 64}, {VKU_FORMAT_COMPONENT_TYPE_G, 64}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_192BIT, 24, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 64}, {VKU_FORMAT_COMPONENT_TYPE_G, 64}, {VKU_FORMAT_COMPONENT_TYPE_B, 64}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_192BIT, 24, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 64}, {VKU_FORMAT_COMPONENT_TYPE_G, 64}, {VKU_FORMAT_COMPONENT_TYPE_B, 64}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_192BIT, 24, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 64}, {VKU_FORMAT_COMPONENT_TYPE_G, 64}, {VKU_FORMAT_COMPONENT_TYPE_B, 64}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_256BIT, 32, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 64}, {VKU_FORMAT_COMPONENT_TYPE_G, 64}, {VKU_FORMAT_COMPONENT_TYPE_B, 64}, {VKU_FORMAT_COMPONENT_TYPE_A, 64}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_256BIT, 32, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 64}, {VKU_FORMAT_COMPONENT_TYPE_G, 64}, {VKU_FORMAT_COMPONENT_TYPE_B, 64}, {VKU_FORMAT_COMPONENT_TYPE_A, 64}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_256BIT, 32, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 64}, {VKU_FORMAT_COMPONENT_TYPE_G, 64}, {VKU_FORMAT_COMPONENT_TYPE_B, 64}, {VKU_FORMAT_COMPONENT_TYPE_A, 64}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 11}, {VKU_FORMAT_COMPONENT_TYPE_R, 11}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_B, 9}, {VKU_FORMAT_COMPONENT_TYPE_G, 9}, {VKU_FORMAT_COMPONENT_TYPE_R, 9}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_D16, 2, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_D, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_D24, 4, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_D, 24}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_D32, 4, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_D, 32}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_S8, 1, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_S, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_D16S8, 3, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_D, 16}, {VKU_FORMAT_COMPONENT_TYPE_S, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_D24S8, 4, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_D, 24}, {VKU_FORMAT_COMPONENT_TYPE_S, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_D32S8, 5, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_D, 32}, {VKU_FORMAT_COMPONENT_TYPE_S, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_BC1_RGB, 8, 16, {4, 4, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_BC1_RGB, 8, 16, {4, 4, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_BC1_RGBA, 8, 16, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_BC1_RGBA, 8, 16, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_BC2, 16, 16, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_BC2, 16, 16, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_BC3, 16, 16, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_BC3, 16, 16, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_BC4, 8, 16, {4, 4, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_BC4, 8, 16, {4, 4, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_BC5, 16, 16, {4, 4, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_BC5, 16, 16, {4, 4, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_BC6H, 16, 16, {4, 4, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_BC6H, 16, 16, {4, 4, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_BC7, 16, 16, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_BC7, 16, 16, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ETC2_RGB, 8, 16, {4, 4, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ETC2_RGB, 8, 16, {4, 4, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ETC2_RGBA, 8, 16, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ETC2_RGBA, 8, 16, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ETC2_EAC_RGBA, 16, 16, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ETC2_EAC_RGBA, 16, 16, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_EAC_R, 8, 16, {4, 4, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 11}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_EAC_R, 8, 16, {4, 4, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 11}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_EAC_RG, 16, 16, {4, 4, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 11}, {VKU_FORMAT_COMPONENT_TYPE_G, 11}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_EAC_RG, 16, 16, {4, 4, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 11}, {VKU_FORMAT_COMPONENT_TYPE_G, 11}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_4X4, 16, 16, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_4X4, 16, 16, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_5X4, 16, 20, {5, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_5X4, 16, 20, {5, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_5X5, 16, 25, {5, 5, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_5X5, 16, 25, {5, 5, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_6X5, 16, 30, {6, 5, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_6X5, 16, 30, {6, 5, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_6X6, 16, 36, {6, 6, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_6X6, 16, 36, {6, 6, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_8X5, 16, 40, {8, 5, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_8X5, 16, 40, {8, 5, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_8X6, 16, 48, {8, 6, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_8X6, 16, 48, {8, 6, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_8X8, 16, 64, {8, 8, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_8X8, 16, 64, {8, 8, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_10X5, 16, 50, {10, 5, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_10X5, 16, 50, {10, 5, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_10X6, 16, 60, {10, 6, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_10X6, 16, 60, {10, 6, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_10X8, 16, 80, {10, 8, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_10X8, 16, 80, {10, 8, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_10X10, 16, 100, {10, 10, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_10X10, 16, 100, {10, 10, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_12X10, 16, 120, {12, 10, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_12X10, 16, 120, {12, 10, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_12X12, 16, 144, {12, 12, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_12X12, 16, 144, {12, 12, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_PVRTC1_2BPP, 8, 1, {8, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_PVRTC1_4BPP, 8, 1, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_PVRTC2_2BPP, 8, 1, {8, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_PVRTC2_4BPP, 8, 1, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_PVRTC1_2BPP, 8, 1, {8, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_PVRTC1_4BPP, 8, 1, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_PVRTC2_2BPP, 8, 1, {8, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_PVRTC2_4BPP, 8, 1, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_4X4, 16, 16, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_5X4, 16, 20, {5, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_5X5, 16, 25, {5, 5, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_6X5, 16, 30, {6, 5, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_6X6, 16, 36, {6, 6, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_8X5, 16, 40, {8, 5, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_8X6, 16, 48, {8, 6, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_8X8, 16, 64, {8, 8, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_10X5, 16, 50, {10, 5, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_10X6, 16, 60, {10, 6, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_10X8, 16, 80, {10, 8, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_10X10, 16, 100, {10, 10, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_12X10, 16, 120, {12, 10, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_12X12, 16, 144, {12, 12, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT_G8B8G8R8, 4, 1, {2, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT_B8G8R8G8, 4, 1, {2, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_8BIT_3PLANE_420, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_8BIT_2PLANE_420, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_8BIT_3PLANE_422, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_8BIT_2PLANE_422, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_8BIT_3PLANE_444, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 10}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_64BIT_R10G10B10A10, 8, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_A, 10}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_64BIT_G10B10G10R10, 8, 1, {2, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_64BIT_B10G10R10G10, 8, 1, {2, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_10BIT_3PLANE_420, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_10BIT_2PLANE_420, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_10BIT_3PLANE_422, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_10BIT_2PLANE_422, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_10BIT_3PLANE_444, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 12}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 12}, {VKU_FORMAT_COMPONENT_TYPE_G, 12}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_64BIT_R12G12B12A12, 8, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 12}, {VKU_FORMAT_COMPONENT_TYPE_G, 12}, {VKU_FORMAT_COMPONENT_TYPE_B, 12}, {VKU_FORMAT_COMPONENT_TYPE_A, 12}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_64BIT_G12B12G12R12, 8, 1, {2, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_G, 12}, {VKU_FORMAT_COMPONENT_TYPE_B, 12}, {VKU_FORMAT_COMPONENT_TYPE_G, 12}, {VKU_FORMAT_COMPONENT_TYPE_R, 12}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_64BIT_B12G12R12G12, 8, 1, {2, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_B, 12}, {VKU_FORMAT_COMPONENT_TYPE_G, 12}, {VKU_FORMAT_COMPONENT_TYPE_R, 12}, {VKU_FORMAT_COMPONENT_TYPE_G, 12}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_12BIT_3PLANE_420, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 12}, {VKU_FORMAT_COMPONENT_TYPE_B, 12}, {VKU_FORMAT_COMPONENT_TYPE_R, 12}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_12BIT_2PLANE_420, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 12}, {VKU_FORMAT_COMPONENT_TYPE_B, 12}, {VKU_FORMAT_COMPONENT_TYPE_R, 12}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_12BIT_3PLANE_422, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 12}, {VKU_FORMAT_COMPONENT_TYPE_B, 12}, {VKU_FORMAT_COMPONENT_TYPE_R, 12}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_12BIT_2PLANE_422, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 12}, {VKU_FORMAT_COMPONENT_TYPE_B, 12}, {VKU_FORMAT_COMPONENT_TYPE_R, 12}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_12BIT_3PLANE_444, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 12}, {VKU_FORMAT_COMPONENT_TYPE_B, 12}, {VKU_FORMAT_COMPONENT_TYPE_R, 12}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_64BIT_G16B16G16R16, 8, 1, {2, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_R, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_64BIT_B16G16R16G16, 8, 1, {2, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT_3PLANE_420, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_R, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT_2PLANE_420, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_R, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT_3PLANE_422, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_R, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT_2PLANE_422, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_R, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT_3PLANE_444, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_R, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_8BIT_2PLANE_444, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_10BIT_2PLANE_444, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_12BIT_2PLANE_444, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 12}, {VKU_FORMAT_COMPONENT_TYPE_B, 12}, {VKU_FORMAT_COMPONENT_TYPE_R, 12}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT_2PLANE_444, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_R, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 4}, {VKU_FORMAT_COMPONENT_TYPE_R, 4}, {VKU_FORMAT_COMPONENT_TYPE_G, 4}, {VKU_FORMAT_COMPONENT_TYPE_B, 4}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 4}, {VKU_FORMAT_COMPONENT_TYPE_B, 4}, {VKU_FORMAT_COMPONENT_TYPE_G, 4}, {VKU_FORMAT_COMPONENT_TYPE_R, 4}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 1}, {VKU_FORMAT_COMPONENT_TYPE_B, 5}, {VKU_FORMAT_COMPONENT_TYPE_G, 5}, {VKU_FORMAT_COMPONENT_TYPE_R, 5}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_8BIT_ALPHA, 1, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_A, 8}} },
+};
 inline const struct VKU_FORMAT_INFO vkuGetFormatInfo(VkFormat format) {
-    switch (format) {
-        case VK_FORMAT_R4G4_UNORM_PACK8: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_8BIT, 1, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 4}, {VKU_FORMAT_COMPONENT_TYPE_G, 4}}};
-            return out; }
-        case VK_FORMAT_R4G4B4A4_UNORM_PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 4}, {VKU_FORMAT_COMPONENT_TYPE_G, 4}, {VKU_FORMAT_COMPONENT_TYPE_B, 4}, {VKU_FORMAT_COMPONENT_TYPE_A, 4}}};
-            return out; }
-        case VK_FORMAT_B4G4R4A4_UNORM_PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_B, 4}, {VKU_FORMAT_COMPONENT_TYPE_G, 4}, {VKU_FORMAT_COMPONENT_TYPE_R, 4}, {VKU_FORMAT_COMPONENT_TYPE_A, 4}}};
-            return out; }
-        case VK_FORMAT_R5G6B5_UNORM_PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 5}, {VKU_FORMAT_COMPONENT_TYPE_G, 6}, {VKU_FORMAT_COMPONENT_TYPE_B, 5}}};
-            return out; }
-        case VK_FORMAT_B5G6R5_UNORM_PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_B, 5}, {VKU_FORMAT_COMPONENT_TYPE_G, 6}, {VKU_FORMAT_COMPONENT_TYPE_R, 5}}};
-            return out; }
-        case VK_FORMAT_R5G5B5A1_UNORM_PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 5}, {VKU_FORMAT_COMPONENT_TYPE_G, 5}, {VKU_FORMAT_COMPONENT_TYPE_B, 5}, {VKU_FORMAT_COMPONENT_TYPE_A, 1}}};
-            return out; }
-        case VK_FORMAT_B5G5R5A1_UNORM_PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_B, 5}, {VKU_FORMAT_COMPONENT_TYPE_G, 5}, {VKU_FORMAT_COMPONENT_TYPE_R, 5}, {VKU_FORMAT_COMPONENT_TYPE_A, 1}}};
-            return out; }
-        case VK_FORMAT_A1R5G5B5_UNORM_PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 1}, {VKU_FORMAT_COMPONENT_TYPE_R, 5}, {VKU_FORMAT_COMPONENT_TYPE_G, 5}, {VKU_FORMAT_COMPONENT_TYPE_B, 5}}};
-            return out; }
-        case VK_FORMAT_A1B5G5R5_UNORM_PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 1}, {VKU_FORMAT_COMPONENT_TYPE_B, 5}, {VKU_FORMAT_COMPONENT_TYPE_G, 5}, {VKU_FORMAT_COMPONENT_TYPE_R, 5}}};
-            return out; }
-        case VK_FORMAT_A8_UNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_8BIT_ALPHA, 1, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_A, 8}}};
-            return out; }
-        case VK_FORMAT_R8_UNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_8BIT, 1, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}}};
-            return out; }
-        case VK_FORMAT_R8_SNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_8BIT, 1, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}}};
-            return out; }
-        case VK_FORMAT_R8_USCALED: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_8BIT, 1, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}}};
-            return out; }
-        case VK_FORMAT_R8_SSCALED: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_8BIT, 1, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}}};
-            return out; }
-        case VK_FORMAT_R8_UINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_8BIT, 1, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}}};
-            return out; }
-        case VK_FORMAT_R8_SINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_8BIT, 1, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}}};
-            return out; }
-        case VK_FORMAT_R8_SRGB: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_8BIT, 1, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}}};
-            return out; }
-        case VK_FORMAT_R8G8_UNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}}};
-            return out; }
-        case VK_FORMAT_R8G8_SNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}}};
-            return out; }
-        case VK_FORMAT_R8G8_USCALED: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}}};
-            return out; }
-        case VK_FORMAT_R8G8_SSCALED: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}}};
-            return out; }
-        case VK_FORMAT_R8G8_UINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}}};
-            return out; }
-        case VK_FORMAT_R8G8_SINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}}};
-            return out; }
-        case VK_FORMAT_R8G8_SRGB: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}}};
-            return out; }
-        case VK_FORMAT_R8G8B8_UNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_24BIT, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}}};
-            return out; }
-        case VK_FORMAT_R8G8B8_SNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_24BIT, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}}};
-            return out; }
-        case VK_FORMAT_R8G8B8_USCALED: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_24BIT, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}}};
-            return out; }
-        case VK_FORMAT_R8G8B8_SSCALED: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_24BIT, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}}};
-            return out; }
-        case VK_FORMAT_R8G8B8_UINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_24BIT, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}}};
-            return out; }
-        case VK_FORMAT_R8G8B8_SINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_24BIT, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}}};
-            return out; }
-        case VK_FORMAT_R8G8B8_SRGB: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_24BIT, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}}};
-            return out; }
-        case VK_FORMAT_B8G8R8_UNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_24BIT, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}}};
-            return out; }
-        case VK_FORMAT_B8G8R8_SNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_24BIT, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}}};
-            return out; }
-        case VK_FORMAT_B8G8R8_USCALED: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_24BIT, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}}};
-            return out; }
-        case VK_FORMAT_B8G8R8_SSCALED: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_24BIT, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}}};
-            return out; }
-        case VK_FORMAT_B8G8R8_UINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_24BIT, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}}};
-            return out; }
-        case VK_FORMAT_B8G8R8_SINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_24BIT, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}}};
-            return out; }
-        case VK_FORMAT_B8G8R8_SRGB: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_24BIT, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}}};
-            return out; }
-        case VK_FORMAT_R8G8B8A8_UNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_A, 8}}};
-            return out; }
-        case VK_FORMAT_R8G8B8A8_SNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_A, 8}}};
-            return out; }
-        case VK_FORMAT_R8G8B8A8_USCALED: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_A, 8}}};
-            return out; }
-        case VK_FORMAT_R8G8B8A8_SSCALED: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_A, 8}}};
-            return out; }
-        case VK_FORMAT_R8G8B8A8_UINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_A, 8}}};
-            return out; }
-        case VK_FORMAT_R8G8B8A8_SINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_A, 8}}};
-            return out; }
-        case VK_FORMAT_R8G8B8A8_SRGB: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_A, 8}}};
-            return out; }
-        case VK_FORMAT_B8G8R8A8_UNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_A, 8}}};
-            return out; }
-        case VK_FORMAT_B8G8R8A8_SNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_A, 8}}};
-            return out; }
-        case VK_FORMAT_B8G8R8A8_USCALED: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_A, 8}}};
-            return out; }
-        case VK_FORMAT_B8G8R8A8_SSCALED: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_A, 8}}};
-            return out; }
-        case VK_FORMAT_B8G8R8A8_UINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_A, 8}}};
-            return out; }
-        case VK_FORMAT_B8G8R8A8_SINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_A, 8}}};
-            return out; }
-        case VK_FORMAT_B8G8R8A8_SRGB: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_A, 8}}};
-            return out; }
-        case VK_FORMAT_A8B8G8R8_UNORM_PACK32: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}}};
-            return out; }
-        case VK_FORMAT_A8B8G8R8_SNORM_PACK32: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}}};
-            return out; }
-        case VK_FORMAT_A8B8G8R8_USCALED_PACK32: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}}};
-            return out; }
-        case VK_FORMAT_A8B8G8R8_SSCALED_PACK32: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}}};
-            return out; }
-        case VK_FORMAT_A8B8G8R8_UINT_PACK32: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}}};
-            return out; }
-        case VK_FORMAT_A8B8G8R8_SINT_PACK32: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}}};
-            return out; }
-        case VK_FORMAT_A8B8G8R8_SRGB_PACK32: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}}};
-            return out; }
-        case VK_FORMAT_A2R10G10B10_UNORM_PACK32: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 2}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}}};
-            return out; }
-        case VK_FORMAT_A2R10G10B10_SNORM_PACK32: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 2}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}}};
-            return out; }
-        case VK_FORMAT_A2R10G10B10_USCALED_PACK32: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 2}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}}};
-            return out; }
-        case VK_FORMAT_A2R10G10B10_SSCALED_PACK32: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 2}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}}};
-            return out; }
-        case VK_FORMAT_A2R10G10B10_UINT_PACK32: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 2}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}}};
-            return out; }
-        case VK_FORMAT_A2R10G10B10_SINT_PACK32: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 2}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}}};
-            return out; }
-        case VK_FORMAT_A2B10G10R10_UNORM_PACK32: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 2}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}}};
-            return out; }
-        case VK_FORMAT_A2B10G10R10_SNORM_PACK32: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 2}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}}};
-            return out; }
-        case VK_FORMAT_A2B10G10R10_USCALED_PACK32: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 2}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}}};
-            return out; }
-        case VK_FORMAT_A2B10G10R10_SSCALED_PACK32: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 2}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}}};
-            return out; }
-        case VK_FORMAT_A2B10G10R10_UINT_PACK32: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 2}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}}};
-            return out; }
-        case VK_FORMAT_A2B10G10R10_SINT_PACK32: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 2}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}}};
-            return out; }
-        case VK_FORMAT_R16_UNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}}};
-            return out; }
-        case VK_FORMAT_R16_SNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}}};
-            return out; }
-        case VK_FORMAT_R16_USCALED: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}}};
-            return out; }
-        case VK_FORMAT_R16_SSCALED: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}}};
-            return out; }
-        case VK_FORMAT_R16_UINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}}};
-            return out; }
-        case VK_FORMAT_R16_SINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}}};
-            return out; }
-        case VK_FORMAT_R16_SFLOAT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}}};
-            return out; }
-        case VK_FORMAT_R16G16_UNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}}};
-            return out; }
-        case VK_FORMAT_R16G16_SNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}}};
-            return out; }
-        case VK_FORMAT_R16G16_USCALED: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}}};
-            return out; }
-        case VK_FORMAT_R16G16_SSCALED: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}}};
-            return out; }
-        case VK_FORMAT_R16G16_UINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}}};
-            return out; }
-        case VK_FORMAT_R16G16_SINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}}};
-            return out; }
-        case VK_FORMAT_R16G16_SFLOAT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}}};
-            return out; }
-        case VK_FORMAT_R16G16B16_UNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_48BIT, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}}};
-            return out; }
-        case VK_FORMAT_R16G16B16_SNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_48BIT, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}}};
-            return out; }
-        case VK_FORMAT_R16G16B16_USCALED: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_48BIT, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}}};
-            return out; }
-        case VK_FORMAT_R16G16B16_SSCALED: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_48BIT, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}}};
-            return out; }
-        case VK_FORMAT_R16G16B16_UINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_48BIT, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}}};
-            return out; }
-        case VK_FORMAT_R16G16B16_SINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_48BIT, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}}};
-            return out; }
-        case VK_FORMAT_R16G16B16_SFLOAT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_48BIT, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}}};
-            return out; }
-        case VK_FORMAT_R16G16B16A16_UNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_64BIT, 8, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_A, 16}}};
-            return out; }
-        case VK_FORMAT_R16G16B16A16_SNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_64BIT, 8, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_A, 16}}};
-            return out; }
-        case VK_FORMAT_R16G16B16A16_USCALED: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_64BIT, 8, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_A, 16}}};
-            return out; }
-        case VK_FORMAT_R16G16B16A16_SSCALED: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_64BIT, 8, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_A, 16}}};
-            return out; }
-        case VK_FORMAT_R16G16B16A16_UINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_64BIT, 8, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_A, 16}}};
-            return out; }
-        case VK_FORMAT_R16G16B16A16_SINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_64BIT, 8, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_A, 16}}};
-            return out; }
-        case VK_FORMAT_R16G16B16A16_SFLOAT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_64BIT, 8, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_A, 16}}};
-            return out; }
-        case VK_FORMAT_R32_UINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 32}}};
-            return out; }
-        case VK_FORMAT_R32_SINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 32}}};
-            return out; }
-        case VK_FORMAT_R32_SFLOAT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 32}}};
-            return out; }
-        case VK_FORMAT_R32G32_UINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_64BIT, 8, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 32}, {VKU_FORMAT_COMPONENT_TYPE_G, 32}}};
-            return out; }
-        case VK_FORMAT_R32G32_SINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_64BIT, 8, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 32}, {VKU_FORMAT_COMPONENT_TYPE_G, 32}}};
-            return out; }
-        case VK_FORMAT_R32G32_SFLOAT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_64BIT, 8, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 32}, {VKU_FORMAT_COMPONENT_TYPE_G, 32}}};
-            return out; }
-        case VK_FORMAT_R32G32B32_UINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_96BIT, 12, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 32}, {VKU_FORMAT_COMPONENT_TYPE_G, 32}, {VKU_FORMAT_COMPONENT_TYPE_B, 32}}};
-            return out; }
-        case VK_FORMAT_R32G32B32_SINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_96BIT, 12, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 32}, {VKU_FORMAT_COMPONENT_TYPE_G, 32}, {VKU_FORMAT_COMPONENT_TYPE_B, 32}}};
-            return out; }
-        case VK_FORMAT_R32G32B32_SFLOAT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_96BIT, 12, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 32}, {VKU_FORMAT_COMPONENT_TYPE_G, 32}, {VKU_FORMAT_COMPONENT_TYPE_B, 32}}};
-            return out; }
-        case VK_FORMAT_R32G32B32A32_UINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_128BIT, 16, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 32}, {VKU_FORMAT_COMPONENT_TYPE_G, 32}, {VKU_FORMAT_COMPONENT_TYPE_B, 32}, {VKU_FORMAT_COMPONENT_TYPE_A, 32}}};
-            return out; }
-        case VK_FORMAT_R32G32B32A32_SINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_128BIT, 16, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 32}, {VKU_FORMAT_COMPONENT_TYPE_G, 32}, {VKU_FORMAT_COMPONENT_TYPE_B, 32}, {VKU_FORMAT_COMPONENT_TYPE_A, 32}}};
-            return out; }
-        case VK_FORMAT_R32G32B32A32_SFLOAT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_128BIT, 16, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 32}, {VKU_FORMAT_COMPONENT_TYPE_G, 32}, {VKU_FORMAT_COMPONENT_TYPE_B, 32}, {VKU_FORMAT_COMPONENT_TYPE_A, 32}}};
-            return out; }
-        case VK_FORMAT_R64_UINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_64BIT, 8, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 64}}};
-            return out; }
-        case VK_FORMAT_R64_SINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_64BIT, 8, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 64}}};
-            return out; }
-        case VK_FORMAT_R64_SFLOAT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_64BIT, 8, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 64}}};
-            return out; }
-        case VK_FORMAT_R64G64_UINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_128BIT, 16, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 64}, {VKU_FORMAT_COMPONENT_TYPE_G, 64}}};
-            return out; }
-        case VK_FORMAT_R64G64_SINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_128BIT, 16, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 64}, {VKU_FORMAT_COMPONENT_TYPE_G, 64}}};
-            return out; }
-        case VK_FORMAT_R64G64_SFLOAT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_128BIT, 16, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 64}, {VKU_FORMAT_COMPONENT_TYPE_G, 64}}};
-            return out; }
-        case VK_FORMAT_R64G64B64_UINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_192BIT, 24, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 64}, {VKU_FORMAT_COMPONENT_TYPE_G, 64}, {VKU_FORMAT_COMPONENT_TYPE_B, 64}}};
-            return out; }
-        case VK_FORMAT_R64G64B64_SINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_192BIT, 24, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 64}, {VKU_FORMAT_COMPONENT_TYPE_G, 64}, {VKU_FORMAT_COMPONENT_TYPE_B, 64}}};
-            return out; }
-        case VK_FORMAT_R64G64B64_SFLOAT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_192BIT, 24, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, 64}, {VKU_FORMAT_COMPONENT_TYPE_G, 64}, {VKU_FORMAT_COMPONENT_TYPE_B, 64}}};
-            return out; }
-        case VK_FORMAT_R64G64B64A64_UINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_256BIT, 32, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 64}, {VKU_FORMAT_COMPONENT_TYPE_G, 64}, {VKU_FORMAT_COMPONENT_TYPE_B, 64}, {VKU_FORMAT_COMPONENT_TYPE_A, 64}}};
-            return out; }
-        case VK_FORMAT_R64G64B64A64_SINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_256BIT, 32, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 64}, {VKU_FORMAT_COMPONENT_TYPE_G, 64}, {VKU_FORMAT_COMPONENT_TYPE_B, 64}, {VKU_FORMAT_COMPONENT_TYPE_A, 64}}};
-            return out; }
-        case VK_FORMAT_R64G64B64A64_SFLOAT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_256BIT, 32, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 64}, {VKU_FORMAT_COMPONENT_TYPE_G, 64}, {VKU_FORMAT_COMPONENT_TYPE_B, 64}, {VKU_FORMAT_COMPONENT_TYPE_A, 64}}};
-            return out; }
-        case VK_FORMAT_B10G11R11_UFLOAT_PACK32: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 11}, {VKU_FORMAT_COMPONENT_TYPE_R, 11}}};
-            return out; }
-        case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_B, 9}, {VKU_FORMAT_COMPONENT_TYPE_G, 9}, {VKU_FORMAT_COMPONENT_TYPE_R, 9}}};
-            return out; }
-        case VK_FORMAT_D16_UNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_D16, 2, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_D, 16}}};
-            return out; }
-        case VK_FORMAT_X8_D24_UNORM_PACK32: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_D24, 4, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_D, 24}}};
-            return out; }
-        case VK_FORMAT_D32_SFLOAT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_D32, 4, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_D, 32}}};
-            return out; }
-        case VK_FORMAT_S8_UINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_S8, 1, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_S, 8}}};
-            return out; }
-        case VK_FORMAT_D16_UNORM_S8_UINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_D16S8, 3, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_D, 16}, {VKU_FORMAT_COMPONENT_TYPE_S, 8}}};
-            return out; }
-        case VK_FORMAT_D24_UNORM_S8_UINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_D24S8, 4, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_D, 24}, {VKU_FORMAT_COMPONENT_TYPE_S, 8}}};
-            return out; }
-        case VK_FORMAT_D32_SFLOAT_S8_UINT: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_D32S8, 5, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_D, 32}, {VKU_FORMAT_COMPONENT_TYPE_S, 8}}};
-            return out; }
-        case VK_FORMAT_BC1_RGB_UNORM_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_BC1_RGB, 8, 16, {4, 4, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_BC1_RGB_SRGB_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_BC1_RGB, 8, 16, {4, 4, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_BC1_RGBA_UNORM_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_BC1_RGBA, 8, 16, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_BC1_RGBA_SRGB_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_BC1_RGBA, 8, 16, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_BC2_UNORM_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_BC2, 16, 16, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_BC2_SRGB_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_BC2, 16, 16, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_BC3_UNORM_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_BC3, 16, 16, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_BC3_SRGB_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_BC3, 16, 16, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_BC4_UNORM_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_BC4, 8, 16, {4, 4, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_BC4_SNORM_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_BC4, 8, 16, {4, 4, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_BC5_UNORM_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_BC5, 16, 16, {4, 4, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_BC5_SNORM_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_BC5, 16, 16, {4, 4, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_BC6H_UFLOAT_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_BC6H, 16, 16, {4, 4, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_BC6H_SFLOAT_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_BC6H, 16, 16, {4, 4, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_BC7_UNORM_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_BC7, 16, 16, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_BC7_SRGB_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_BC7, 16, 16, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ETC2_RGB, 8, 16, {4, 4, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ETC2_RGB, 8, 16, {4, 4, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ETC2_RGBA, 8, 16, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ETC2_RGBA, 8, 16, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ETC2_EAC_RGBA, 16, 16, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ETC2_EAC_RGBA, 16, 16, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_EAC_R11_UNORM_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_EAC_R, 8, 16, {4, 4, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 11}}};
-            return out; }
-        case VK_FORMAT_EAC_R11_SNORM_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_EAC_R, 8, 16, {4, 4, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 11}}};
-            return out; }
-        case VK_FORMAT_EAC_R11G11_UNORM_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_EAC_RG, 16, 16, {4, 4, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 11}, {VKU_FORMAT_COMPONENT_TYPE_G, 11}}};
-            return out; }
-        case VK_FORMAT_EAC_R11G11_SNORM_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_EAC_RG, 16, 16, {4, 4, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 11}, {VKU_FORMAT_COMPONENT_TYPE_G, 11}}};
-            return out; }
-        case VK_FORMAT_ASTC_4x4_UNORM_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_4X4, 16, 16, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_4x4_SRGB_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_4X4, 16, 16, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_5x4_UNORM_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_5X4, 16, 20, {5, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_5x4_SRGB_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_5X4, 16, 20, {5, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_5x5_UNORM_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_5X5, 16, 25, {5, 5, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_5x5_SRGB_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_5X5, 16, 25, {5, 5, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_6x5_UNORM_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_6X5, 16, 30, {6, 5, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_6x5_SRGB_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_6X5, 16, 30, {6, 5, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_6x6_UNORM_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_6X6, 16, 36, {6, 6, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_6x6_SRGB_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_6X6, 16, 36, {6, 6, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_8x5_UNORM_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_8X5, 16, 40, {8, 5, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_8x5_SRGB_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_8X5, 16, 40, {8, 5, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_8x6_UNORM_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_8X6, 16, 48, {8, 6, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_8x6_SRGB_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_8X6, 16, 48, {8, 6, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_8x8_UNORM_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_8X8, 16, 64, {8, 8, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_8x8_SRGB_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_8X8, 16, 64, {8, 8, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_10x5_UNORM_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_10X5, 16, 50, {10, 5, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_10x5_SRGB_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_10X5, 16, 50, {10, 5, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_10x6_UNORM_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_10X6, 16, 60, {10, 6, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_10x6_SRGB_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_10X6, 16, 60, {10, 6, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_10x8_UNORM_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_10X8, 16, 80, {10, 8, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_10x8_SRGB_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_10X8, 16, 80, {10, 8, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_10x10_UNORM_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_10X10, 16, 100, {10, 10, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_10x10_SRGB_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_10X10, 16, 100, {10, 10, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_12x10_UNORM_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_12X10, 16, 120, {12, 10, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_12x10_SRGB_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_12X10, 16, 120, {12, 10, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_12x12_UNORM_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_12X12, 16, 144, {12, 12, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_12x12_SRGB_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_12X12, 16, 144, {12, 12, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_G8B8G8R8_422_UNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT_G8B8G8R8, 4, 1, {2, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}}};
-            return out; }
-        case VK_FORMAT_B8G8R8G8_422_UNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT_B8G8R8G8, 4, 1, {2, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}, {VKU_FORMAT_COMPONENT_TYPE_G, 8}}};
-            return out; }
-        case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_8BIT_3PLANE_420, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}}};
-            return out; }
-        case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_8BIT_2PLANE_420, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}}};
-            return out; }
-        case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_8BIT_3PLANE_422, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}}};
-            return out; }
-        case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_8BIT_2PLANE_422, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}}};
-            return out; }
-        case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_8BIT_3PLANE_444, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}}};
-            return out; }
-        case VK_FORMAT_R10X6_UNORM_PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 10}}};
-            return out; }
-        case VK_FORMAT_R10X6G10X6_UNORM_2PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}}};
-            return out; }
-        case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_64BIT_R10G10B10A10, 8, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_A, 10}}};
-            return out; }
-        case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_64BIT_G10B10G10R10, 8, 1, {2, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}}};
-            return out; }
-        case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_64BIT_B10G10R10G10, 8, 1, {2, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}}};
-            return out; }
-        case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_10BIT_3PLANE_420, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}}};
-            return out; }
-        case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_10BIT_2PLANE_420, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}}};
-            return out; }
-        case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_10BIT_3PLANE_422, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}}};
-            return out; }
-        case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_10BIT_2PLANE_422, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}}};
-            return out; }
-        case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_10BIT_3PLANE_444, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}}};
-            return out; }
-        case VK_FORMAT_R12X4_UNORM_PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 12}}};
-            return out; }
-        case VK_FORMAT_R12X4G12X4_UNORM_2PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 12}, {VKU_FORMAT_COMPONENT_TYPE_G, 12}}};
-            return out; }
-        case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_64BIT_R12G12B12A12, 8, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 12}, {VKU_FORMAT_COMPONENT_TYPE_G, 12}, {VKU_FORMAT_COMPONENT_TYPE_B, 12}, {VKU_FORMAT_COMPONENT_TYPE_A, 12}}};
-            return out; }
-        case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_64BIT_G12B12G12R12, 8, 1, {2, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_G, 12}, {VKU_FORMAT_COMPONENT_TYPE_B, 12}, {VKU_FORMAT_COMPONENT_TYPE_G, 12}, {VKU_FORMAT_COMPONENT_TYPE_R, 12}}};
-            return out; }
-        case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_64BIT_B12G12R12G12, 8, 1, {2, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_B, 12}, {VKU_FORMAT_COMPONENT_TYPE_G, 12}, {VKU_FORMAT_COMPONENT_TYPE_R, 12}, {VKU_FORMAT_COMPONENT_TYPE_G, 12}}};
-            return out; }
-        case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_12BIT_3PLANE_420, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 12}, {VKU_FORMAT_COMPONENT_TYPE_B, 12}, {VKU_FORMAT_COMPONENT_TYPE_R, 12}}};
-            return out; }
-        case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_12BIT_2PLANE_420, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 12}, {VKU_FORMAT_COMPONENT_TYPE_B, 12}, {VKU_FORMAT_COMPONENT_TYPE_R, 12}}};
-            return out; }
-        case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_12BIT_3PLANE_422, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 12}, {VKU_FORMAT_COMPONENT_TYPE_B, 12}, {VKU_FORMAT_COMPONENT_TYPE_R, 12}}};
-            return out; }
-        case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_12BIT_2PLANE_422, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 12}, {VKU_FORMAT_COMPONENT_TYPE_B, 12}, {VKU_FORMAT_COMPONENT_TYPE_R, 12}}};
-            return out; }
-        case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_12BIT_3PLANE_444, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 12}, {VKU_FORMAT_COMPONENT_TYPE_B, 12}, {VKU_FORMAT_COMPONENT_TYPE_R, 12}}};
-            return out; }
-        case VK_FORMAT_G16B16G16R16_422_UNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_64BIT_G16B16G16R16, 8, 1, {2, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_R, 16}}};
-            return out; }
-        case VK_FORMAT_B16G16R16G16_422_UNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_64BIT_B16G16R16G16, 8, 1, {2, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}}};
-            return out; }
-        case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT_3PLANE_420, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_R, 16}}};
-            return out; }
-        case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT_2PLANE_420, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_R, 16}}};
-            return out; }
-        case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT_3PLANE_422, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_R, 16}}};
-            return out; }
-        case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT_2PLANE_422, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_R, 16}}};
-            return out; }
-        case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT_3PLANE_444, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_R, 16}}};
-            return out; }
-        case VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_PVRTC1_2BPP, 8, 1, {8, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_PVRTC1_4BPP, 8, 1, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_PVRTC2_2BPP, 8, 1, {8, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_PVRTC2_4BPP, 8, 1, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_PVRTC1_2BPP, 8, 1, {8, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_PVRTC1_4BPP, 8, 1, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_PVRTC2_2BPP, 8, 1, {8, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_PVRTC2_4BPP, 8, 1, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_4X4, 16, 16, {4, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_5X4, 16, 20, {5, 4, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_5X5, 16, 25, {5, 5, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_6X5, 16, 30, {6, 5, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_6X6, 16, 36, {6, 6, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_8X5, 16, 40, {8, 5, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_8X6, 16, 48, {8, 6, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_8X8, 16, 64, {8, 8, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_10X5, 16, 50, {10, 5, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_10X6, 16, 60, {10, 6, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_10X8, 16, 80, {10, 8, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_10X10, 16, 100, {10, 10, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_12X10, 16, 120, {12, 10, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_ASTC_12X12, 16, 144, {12, 12, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_G, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_B, VKU_FORMAT_COMPRESSED_COMPONENT}, {VKU_FORMAT_COMPONENT_TYPE_A, VKU_FORMAT_COMPRESSED_COMPONENT}}};
-            return out; }
-        case VK_FORMAT_G8_B8R8_2PLANE_444_UNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_8BIT_2PLANE_444, 3, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 8}, {VKU_FORMAT_COMPONENT_TYPE_B, 8}, {VKU_FORMAT_COMPONENT_TYPE_R, 8}}};
-            return out; }
-        case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_10BIT_2PLANE_444, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_R, 10}}};
-            return out; }
-        case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_12BIT_2PLANE_444, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 12}, {VKU_FORMAT_COMPONENT_TYPE_B, 12}, {VKU_FORMAT_COMPONENT_TYPE_R, 12}}};
-            return out; }
-        case VK_FORMAT_G16_B16R16_2PLANE_444_UNORM: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT_2PLANE_444, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_R, 16}}};
-            return out; }
-        case VK_FORMAT_A4R4G4B4_UNORM_PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 4}, {VKU_FORMAT_COMPONENT_TYPE_R, 4}, {VKU_FORMAT_COMPONENT_TYPE_G, 4}, {VKU_FORMAT_COMPONENT_TYPE_B, 4}}};
-            return out; }
-        case VK_FORMAT_A4B4G4R4_UNORM_PACK16: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 4}, {VKU_FORMAT_COMPONENT_TYPE_B, 4}, {VKU_FORMAT_COMPONENT_TYPE_G, 4}, {VKU_FORMAT_COMPONENT_TYPE_R, 4}}};
-            return out; }
-        case VK_FORMAT_R16G16_SFIXED5_NV: {
-            struct VKU_FORMAT_INFO out = {VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}}};
-            return out; }
-
-        default: {
-            // return values for VK_FORMAT_UNDEFINED
-            struct VKU_FORMAT_INFO out = { VKU_FORMAT_COMPATIBILITY_CLASS_NONE, 0, 0, {0, 0, 0}, 0, {{VKU_FORMAT_COMPONENT_TYPE_NONE, 0}, {VKU_FORMAT_COMPONENT_TYPE_NONE, 0}, {VKU_FORMAT_COMPONENT_TYPE_NONE, 0}, {VKU_FORMAT_COMPONENT_TYPE_NONE, 0}} };
-            return out;
-        }
-    };
+    if (VK_FORMAT_UNDEFINED <= format && format <= VK_FORMAT_ASTC_12x12_SRGB_BLOCK ) { return vku_formats[format - VK_FORMAT_UNDEFINED + 0]; }
+    else if (VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG <= format && format <= VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG ) { return vku_formats[format - VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG + 185]; }
+    else if (VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK <= format && format <= VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK ) { return vku_formats[format - VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK + 193]; }
+    else if (VK_FORMAT_G8B8G8R8_422_UNORM <= format && format <= VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM ) { return vku_formats[format - VK_FORMAT_G8B8G8R8_422_UNORM + 207]; }
+    else if (VK_FORMAT_G8_B8R8_2PLANE_444_UNORM <= format && format <= VK_FORMAT_G16_B16R16_2PLANE_444_UNORM ) { return vku_formats[format - VK_FORMAT_G8_B8R8_2PLANE_444_UNORM + 241]; }
+    else if (VK_FORMAT_A4R4G4B4_UNORM_PACK16 <= format && format <= VK_FORMAT_A4B4G4R4_UNORM_PACK16 ) { return vku_formats[format - VK_FORMAT_A4R4G4B4_UNORM_PACK16 + 245]; }
+    else if (VK_FORMAT_R16G16_SFIXED5_NV <= format && format <= VK_FORMAT_R16G16_SFIXED5_NV ) { return vku_formats[format - VK_FORMAT_R16G16_SFIXED5_NV + 247]; }
+    else if (VK_FORMAT_A1B5G5R5_UNORM_PACK16 <= format && format <= VK_FORMAT_A8_UNORM ) { return vku_formats[format - VK_FORMAT_A1B5G5R5_UNORM_PACK16 + 248]; }
+    // Default case - return VK_FORMAT_UNDEFINED
+    else {
+        return vku_formats[0];
+    }
 }
 
 struct VKU_FORMAT_PER_PLANE_COMPATIBILITY {
diff --git a/scripts/generators/format_utils_generator.py b/scripts/generators/format_utils_generator.py
index bdf857d..d0d1897 100644
--- a/scripts/generators/format_utils_generator.py
+++ b/scripts/generators/format_utils_generator.py
@@ -7,6 +7,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import os
+from collections import namedtuple
 from vulkan_object import (Format)
 from base_generator import BaseGenerator
 
@@ -292,7 +293,7 @@ enum VKU_FORMAT_COMPONENT_TYPE {
 };
 
 // Compressed formats don't have a defined component size
-const uint32_t VKU_FORMAT_COMPRESSED_COMPONENT = 0xFFFFFFFF;
+#define VKU_FORMAT_COMPRESSED_COMPONENT 0xFFFFFFFF
 
 struct VKU_FORMAT_COMPONENT_INFO {
     enum VKU_FORMAT_COMPONENT_TYPE type;
@@ -309,27 +310,57 @@ struct VKU_FORMAT_INFO {
     struct VKU_FORMAT_COMPONENT_INFO components[VKU_FORMAT_MAX_COMPONENTS];
 };
 ''')
-        out.append('inline const struct VKU_FORMAT_INFO vkuGetFormatInfo(VkFormat format) {\n')
-        out.append('    switch (format) {\n')
-        for f in self.vk.formats.values():
+        formats_in_order = {}
+        # Manually add in the entry for VK_FORMAT_UNDEFINED because it is missing from the self.vk.formats dict
+        formats_in_order[0] = Format('VK_FORMAT_UNDEFINED', 'NONE', 0,0, ['0','0','0'], None, None, None, [], [], None)
+        for e in self.vk.enums['VkFormat'].fields:
+            if e.name != 'VK_FORMAT_UNDEFINED':
+                formats_in_order[e.value] = self.vk.formats[e.name]
+        # Number of VkFormats should equal the fields of the VkFormat enum
+        assert(len(formats_in_order) == len(self.vk.enums['VkFormat'].fields))
+        formats_in_order = dict(sorted(formats_in_order.items()))
+
+        out.append(f'const struct VKU_FORMAT_INFO vku_formats[{len(self.vk.formats) + 1}] = {{\n')
+        for f in formats_in_order.values():
             className = getClassName(f.className)
             blockExtent = ', '.join(f.blockExtent) if f.blockExtent is not None else '1, 1, 1'
-            out.extend(f'        case {f.name}: {{\n')
-            out.extend(f'            struct VKU_FORMAT_INFO out = {{VKU_FORMAT_COMPATIBILITY_CLASS_{className}, {f.blockSize}, {f.texelsPerBlock}, {{{blockExtent}}}, {len(f.components)}, {{')
+            out.extend(f'    {{ VKU_FORMAT_COMPATIBILITY_CLASS_{className}, {f.blockSize}, {f.texelsPerBlock}, {{{blockExtent}}}, {len(f.components)}, {{')
             for index, component in enumerate(f.components):
                 bits = 'VKU_FORMAT_COMPRESSED_COMPONENT' if component.bits == 'compressed' else component.bits
                 out.append(f'{{VKU_FORMAT_COMPONENT_TYPE_{component.type}, {bits}}}')
                 if index + 1 != len(f.components):
                     out.append(', ')
-            out.append('}};\n')
-            out.append('            return out; }\n')
-        out.append('''
-        default: {
-            // return values for VK_FORMAT_UNDEFINED
-            struct VKU_FORMAT_INFO out = { VKU_FORMAT_COMPATIBILITY_CLASS_NONE, 0, 0, {0, 0, 0}, 0, {{VKU_FORMAT_COMPONENT_TYPE_NONE, 0}, {VKU_FORMAT_COMPONENT_TYPE_NONE, 0}, {VKU_FORMAT_COMPONENT_TYPE_NONE, 0}, {VKU_FORMAT_COMPONENT_TYPE_NONE, 0}} };
-            return out;
-        }
-    };
+            out.append('} },\n')
+        out.append('};\n')
+
+        # Find the "format groups", eg formats whose value are consecutive, as that is the way they are written into the 'formats' array.
+        # Value refers to the enum value. These are discontinuous.
+        # Index refers to the index of a format in the vku_formats array. These are from 0 to the len(formats_in_order).
+        format_values = list(formats_in_order.keys())
+        FormatGroup = namedtuple('FormatGroup', ['begin_format', 'end_format','array_index'])
+        format_groups = []
+        index = 0
+        while index < len(format_values):
+            start_value = format_values[index]
+            end_value = format_values[-1] # use last format as sentinel so the last group can get the right end value
+            previous_value = start_value - 1
+            # Find the end value for the current group
+            for format_value in format_values[index:]:
+                if previous_value + 1 != format_value:
+                    end_value = previous_value
+                    break
+                previous_value = format_value
+            format_groups.append(FormatGroup(formats_in_order[start_value].name, formats_in_order[end_value].name, index))
+            index += (end_value - start_value) + 1
+
+        out.append('inline const struct VKU_FORMAT_INFO vkuGetFormatInfo(VkFormat format) {\n')
+        for group in format_groups:
+            out.append(f'    {"else " if group.array_index != 0 else ""}if ({group.begin_format} <= format && format <= {group.end_format} )')
+            out.append(f' {{ return vku_formats[format - {group.begin_format} + {group.array_index}]; }}\n')
+        out.append('''    // Default case - return VK_FORMAT_UNDEFINED
+    else {
+        return vku_formats[0];
+    }
 }
 
 struct VKU_FORMAT_PER_PLANE_COMPATIBILITY {

From 551221d913cc56218fcaddce086ae293d375ac28 Mon Sep 17 00:00:00 2001
From: spencer-lunarg <spencer@lunarg.com>
Date: Fri, 28 Mar 2025 21:51:18 -0400
Subject: [PATCH 095/106] formats: Handle SRGB correction

---
 scripts/generators/format_utils_generator.py | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/scripts/generators/format_utils_generator.py b/scripts/generators/format_utils_generator.py
index d0d1897..c11b833 100644
--- a/scripts/generators/format_utils_generator.py
+++ b/scripts/generators/format_utils_generator.py
@@ -26,7 +26,13 @@ def formatHasEqualBitsize(format: Format, bitsize: str) -> bool:
 
 # True if all components are same numericFormat
 def formatHasNumericFormat(format: Format, numericFormat: str) -> bool:
-    return all(x.numericFormat == numericFormat for x in format.components)
+    if numericFormat == 'SRGB':
+        # For SRGB, the Alpha will be UNORM, but it is still considered an SRGB format
+        if format.name == 'VK_FORMAT_A8_UNORM':
+            return False
+        return all(x.type == 'A' or x.numericFormat == numericFormat for x in format.components)
+    else:
+        return all(x.numericFormat == numericFormat for x in format.components)
 
 class FormatUtilsOutputGenerator(BaseGenerator):
     def __init__(self):

From 01851ecae564f8d3da0123659c26a2f5bbfc0228 Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Fri, 4 Apr 2025 09:19:02 -0700
Subject: [PATCH 096/106] build: Update to header 1.4.312

---
 include/vulkan/utility/vk_dispatch_table.h  |  12 +
 include/vulkan/utility/vk_safe_struct.hpp   | 189 +++++++
 include/vulkan/utility/vk_struct_helper.hpp |  11 +
 include/vulkan/vk_enum_string_helper.h      |  53 ++
 scripts/known_good.json                     |   2 +-
 src/vulkan/vk_safe_struct_utils.cpp         |  30 ++
 src/vulkan/vk_safe_struct_vendor.cpp        | 570 ++++++++++++++++++++
 7 files changed, 866 insertions(+), 1 deletion(-)

diff --git a/include/vulkan/utility/vk_dispatch_table.h b/include/vulkan/utility/vk_dispatch_table.h
index d68b79a..f13b592 100644
--- a/include/vulkan/utility/vk_dispatch_table.h
+++ b/include/vulkan/utility/vk_dispatch_table.h
@@ -641,6 +641,9 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkDestroyCudaFunctionNV DestroyCudaFunctionNV;
     PFN_vkCmdCudaLaunchKernelNV CmdCudaLaunchKernelNV;
 #endif  // VK_ENABLE_BETA_EXTENSIONS
+    PFN_vkCmdDispatchTileQCOM CmdDispatchTileQCOM;
+    PFN_vkCmdBeginPerTileExecutionQCOM CmdBeginPerTileExecutionQCOM;
+    PFN_vkCmdEndPerTileExecutionQCOM CmdEndPerTileExecutionQCOM;
 #ifdef VK_USE_PLATFORM_METAL_EXT
     PFN_vkExportMetalObjectsEXT ExportMetalObjectsEXT;
 #endif  // VK_USE_PLATFORM_METAL_EXT
@@ -764,6 +767,9 @@ typedef struct VkuDeviceDispatchTable_ {
 #ifdef VK_USE_PLATFORM_SCREEN_QNX
     PFN_vkGetScreenBufferPropertiesQNX GetScreenBufferPropertiesQNX;
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
+    PFN_vkCreateExternalComputeQueueNV CreateExternalComputeQueueNV;
+    PFN_vkDestroyExternalComputeQueueNV DestroyExternalComputeQueueNV;
+    PFN_vkGetExternalComputeQueueDataNV GetExternalComputeQueueDataNV;
     PFN_vkGetClusterAccelerationStructureBuildSizesNV GetClusterAccelerationStructureBuildSizesNV;
     PFN_vkCmdBuildClusterAccelerationStructureIndirectNV CmdBuildClusterAccelerationStructureIndirectNV;
     PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV GetPartitionedAccelerationStructuresBuildSizesNV;
@@ -1286,6 +1292,9 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
     table->DestroyCudaFunctionNV = (PFN_vkDestroyCudaFunctionNV)gdpa(device, "vkDestroyCudaFunctionNV");
     table->CmdCudaLaunchKernelNV = (PFN_vkCmdCudaLaunchKernelNV)gdpa(device, "vkCmdCudaLaunchKernelNV");
 #endif  // VK_ENABLE_BETA_EXTENSIONS
+    table->CmdDispatchTileQCOM = (PFN_vkCmdDispatchTileQCOM)gdpa(device, "vkCmdDispatchTileQCOM");
+    table->CmdBeginPerTileExecutionQCOM = (PFN_vkCmdBeginPerTileExecutionQCOM)gdpa(device, "vkCmdBeginPerTileExecutionQCOM");
+    table->CmdEndPerTileExecutionQCOM = (PFN_vkCmdEndPerTileExecutionQCOM)gdpa(device, "vkCmdEndPerTileExecutionQCOM");
 #ifdef VK_USE_PLATFORM_METAL_EXT
     table->ExportMetalObjectsEXT = (PFN_vkExportMetalObjectsEXT)gdpa(device, "vkExportMetalObjectsEXT");
 #endif  // VK_USE_PLATFORM_METAL_EXT
@@ -1409,6 +1418,9 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
 #ifdef VK_USE_PLATFORM_SCREEN_QNX
     table->GetScreenBufferPropertiesQNX = (PFN_vkGetScreenBufferPropertiesQNX)gdpa(device, "vkGetScreenBufferPropertiesQNX");
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
+    table->CreateExternalComputeQueueNV = (PFN_vkCreateExternalComputeQueueNV)gdpa(device, "vkCreateExternalComputeQueueNV");
+    table->DestroyExternalComputeQueueNV = (PFN_vkDestroyExternalComputeQueueNV)gdpa(device, "vkDestroyExternalComputeQueueNV");
+    table->GetExternalComputeQueueDataNV = (PFN_vkGetExternalComputeQueueDataNV)gdpa(device, "vkGetExternalComputeQueueDataNV");
     table->GetClusterAccelerationStructureBuildSizesNV = (PFN_vkGetClusterAccelerationStructureBuildSizesNV)gdpa(device, "vkGetClusterAccelerationStructureBuildSizesNV");
     table->CmdBuildClusterAccelerationStructureIndirectNV = (PFN_vkCmdBuildClusterAccelerationStructureIndirectNV)gdpa(device, "vkCmdBuildClusterAccelerationStructureIndirectNV");
     table->GetPartitionedAccelerationStructuresBuildSizesNV = (PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV)gdpa(device, "vkGetPartitionedAccelerationStructuresBuildSizesNV");
diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index 42bdb85..74449f7 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -14231,6 +14231,119 @@ struct safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV {
     }
 };
 #endif  // VK_ENABLE_BETA_EXTENSIONS
+struct safe_VkPhysicalDeviceTileShadingFeaturesQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 tileShading;
+    VkBool32 tileShadingFragmentStage;
+    VkBool32 tileShadingColorAttachments;
+    VkBool32 tileShadingDepthAttachments;
+    VkBool32 tileShadingStencilAttachments;
+    VkBool32 tileShadingInputAttachments;
+    VkBool32 tileShadingSampledAttachments;
+    VkBool32 tileShadingPerTileDraw;
+    VkBool32 tileShadingPerTileDispatch;
+    VkBool32 tileShadingDispatchTile;
+    VkBool32 tileShadingApron;
+    VkBool32 tileShadingAnisotropicApron;
+    VkBool32 tileShadingAtomicOps;
+    VkBool32 tileShadingImageProcessing;
+
+    safe_VkPhysicalDeviceTileShadingFeaturesQCOM(const VkPhysicalDeviceTileShadingFeaturesQCOM* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceTileShadingFeaturesQCOM(const safe_VkPhysicalDeviceTileShadingFeaturesQCOM& copy_src);
+    safe_VkPhysicalDeviceTileShadingFeaturesQCOM& operator=(const safe_VkPhysicalDeviceTileShadingFeaturesQCOM& copy_src);
+    safe_VkPhysicalDeviceTileShadingFeaturesQCOM();
+    ~safe_VkPhysicalDeviceTileShadingFeaturesQCOM();
+    void initialize(const VkPhysicalDeviceTileShadingFeaturesQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceTileShadingFeaturesQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceTileShadingFeaturesQCOM* ptr() { return reinterpret_cast<VkPhysicalDeviceTileShadingFeaturesQCOM*>(this); }
+    VkPhysicalDeviceTileShadingFeaturesQCOM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceTileShadingFeaturesQCOM const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceTileShadingPropertiesQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxApronSize;
+    VkBool32 preferNonCoherent;
+    VkExtent2D tileGranularity;
+    VkExtent2D maxTileShadingRate;
+
+    safe_VkPhysicalDeviceTileShadingPropertiesQCOM(const VkPhysicalDeviceTileShadingPropertiesQCOM* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceTileShadingPropertiesQCOM(const safe_VkPhysicalDeviceTileShadingPropertiesQCOM& copy_src);
+    safe_VkPhysicalDeviceTileShadingPropertiesQCOM& operator=(const safe_VkPhysicalDeviceTileShadingPropertiesQCOM& copy_src);
+    safe_VkPhysicalDeviceTileShadingPropertiesQCOM();
+    ~safe_VkPhysicalDeviceTileShadingPropertiesQCOM();
+    void initialize(const VkPhysicalDeviceTileShadingPropertiesQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceTileShadingPropertiesQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceTileShadingPropertiesQCOM* ptr() { return reinterpret_cast<VkPhysicalDeviceTileShadingPropertiesQCOM*>(this); }
+    VkPhysicalDeviceTileShadingPropertiesQCOM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceTileShadingPropertiesQCOM const*>(this);
+    }
+};
+struct safe_VkRenderPassTileShadingCreateInfoQCOM {
+    VkStructureType sType;
+    const void* pNext{};
+    VkTileShadingRenderPassFlagsQCOM flags;
+    VkExtent2D tileApronSize;
+
+    safe_VkRenderPassTileShadingCreateInfoQCOM(const VkRenderPassTileShadingCreateInfoQCOM* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkRenderPassTileShadingCreateInfoQCOM(const safe_VkRenderPassTileShadingCreateInfoQCOM& copy_src);
+    safe_VkRenderPassTileShadingCreateInfoQCOM& operator=(const safe_VkRenderPassTileShadingCreateInfoQCOM& copy_src);
+    safe_VkRenderPassTileShadingCreateInfoQCOM();
+    ~safe_VkRenderPassTileShadingCreateInfoQCOM();
+    void initialize(const VkRenderPassTileShadingCreateInfoQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkRenderPassTileShadingCreateInfoQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkRenderPassTileShadingCreateInfoQCOM* ptr() { return reinterpret_cast<VkRenderPassTileShadingCreateInfoQCOM*>(this); }
+    VkRenderPassTileShadingCreateInfoQCOM const* ptr() const {
+        return reinterpret_cast<VkRenderPassTileShadingCreateInfoQCOM const*>(this);
+    }
+};
+struct safe_VkPerTileBeginInfoQCOM {
+    VkStructureType sType;
+    const void* pNext{};
+
+    safe_VkPerTileBeginInfoQCOM(const VkPerTileBeginInfoQCOM* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPerTileBeginInfoQCOM(const safe_VkPerTileBeginInfoQCOM& copy_src);
+    safe_VkPerTileBeginInfoQCOM& operator=(const safe_VkPerTileBeginInfoQCOM& copy_src);
+    safe_VkPerTileBeginInfoQCOM();
+    ~safe_VkPerTileBeginInfoQCOM();
+    void initialize(const VkPerTileBeginInfoQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPerTileBeginInfoQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkPerTileBeginInfoQCOM* ptr() { return reinterpret_cast<VkPerTileBeginInfoQCOM*>(this); }
+    VkPerTileBeginInfoQCOM const* ptr() const { return reinterpret_cast<VkPerTileBeginInfoQCOM const*>(this); }
+};
+struct safe_VkPerTileEndInfoQCOM {
+    VkStructureType sType;
+    const void* pNext{};
+
+    safe_VkPerTileEndInfoQCOM(const VkPerTileEndInfoQCOM* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPerTileEndInfoQCOM(const safe_VkPerTileEndInfoQCOM& copy_src);
+    safe_VkPerTileEndInfoQCOM& operator=(const safe_VkPerTileEndInfoQCOM& copy_src);
+    safe_VkPerTileEndInfoQCOM();
+    ~safe_VkPerTileEndInfoQCOM();
+    void initialize(const VkPerTileEndInfoQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPerTileEndInfoQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkPerTileEndInfoQCOM* ptr() { return reinterpret_cast<VkPerTileEndInfoQCOM*>(this); }
+    VkPerTileEndInfoQCOM const* ptr() const { return reinterpret_cast<VkPerTileEndInfoQCOM const*>(this); }
+};
+struct safe_VkDispatchTileInfoQCOM {
+    VkStructureType sType;
+    const void* pNext{};
+
+    safe_VkDispatchTileInfoQCOM(const VkDispatchTileInfoQCOM* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkDispatchTileInfoQCOM(const safe_VkDispatchTileInfoQCOM& copy_src);
+    safe_VkDispatchTileInfoQCOM& operator=(const safe_VkDispatchTileInfoQCOM& copy_src);
+    safe_VkDispatchTileInfoQCOM();
+    ~safe_VkDispatchTileInfoQCOM();
+    void initialize(const VkDispatchTileInfoQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDispatchTileInfoQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkDispatchTileInfoQCOM* ptr() { return reinterpret_cast<VkDispatchTileInfoQCOM*>(this); }
+    VkDispatchTileInfoQCOM const* ptr() const { return reinterpret_cast<VkDispatchTileInfoQCOM const*>(this); }
+};
 struct safe_VkQueryLowLatencySupportNV {
     VkStructureType sType;
     const void* pNext{};
@@ -19233,6 +19346,82 @@ struct safe_VkPhysicalDeviceRawAccessChainsFeaturesNV {
         return reinterpret_cast<VkPhysicalDeviceRawAccessChainsFeaturesNV const*>(this);
     }
 };
+struct safe_VkExternalComputeQueueDeviceCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t reservedExternalQueues;
+
+    safe_VkExternalComputeQueueDeviceCreateInfoNV(const VkExternalComputeQueueDeviceCreateInfoNV* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkExternalComputeQueueDeviceCreateInfoNV(const safe_VkExternalComputeQueueDeviceCreateInfoNV& copy_src);
+    safe_VkExternalComputeQueueDeviceCreateInfoNV& operator=(const safe_VkExternalComputeQueueDeviceCreateInfoNV& copy_src);
+    safe_VkExternalComputeQueueDeviceCreateInfoNV();
+    ~safe_VkExternalComputeQueueDeviceCreateInfoNV();
+    void initialize(const VkExternalComputeQueueDeviceCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExternalComputeQueueDeviceCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkExternalComputeQueueDeviceCreateInfoNV* ptr() { return reinterpret_cast<VkExternalComputeQueueDeviceCreateInfoNV*>(this); }
+    VkExternalComputeQueueDeviceCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkExternalComputeQueueDeviceCreateInfoNV const*>(this);
+    }
+};
+struct safe_VkExternalComputeQueueCreateInfoNV {
+    VkStructureType sType;
+    const void* pNext{};
+    VkQueue preferredQueue;
+
+    safe_VkExternalComputeQueueCreateInfoNV(const VkExternalComputeQueueCreateInfoNV* in_struct, PNextCopyState* copy_state = {},
+                                            bool copy_pnext = true);
+    safe_VkExternalComputeQueueCreateInfoNV(const safe_VkExternalComputeQueueCreateInfoNV& copy_src);
+    safe_VkExternalComputeQueueCreateInfoNV& operator=(const safe_VkExternalComputeQueueCreateInfoNV& copy_src);
+    safe_VkExternalComputeQueueCreateInfoNV();
+    ~safe_VkExternalComputeQueueCreateInfoNV();
+    void initialize(const VkExternalComputeQueueCreateInfoNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExternalComputeQueueCreateInfoNV* copy_src, PNextCopyState* copy_state = {});
+    VkExternalComputeQueueCreateInfoNV* ptr() { return reinterpret_cast<VkExternalComputeQueueCreateInfoNV*>(this); }
+    VkExternalComputeQueueCreateInfoNV const* ptr() const {
+        return reinterpret_cast<VkExternalComputeQueueCreateInfoNV const*>(this);
+    }
+};
+struct safe_VkExternalComputeQueueDataParamsNV {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t deviceIndex;
+
+    safe_VkExternalComputeQueueDataParamsNV(const VkExternalComputeQueueDataParamsNV* in_struct, PNextCopyState* copy_state = {},
+                                            bool copy_pnext = true);
+    safe_VkExternalComputeQueueDataParamsNV(const safe_VkExternalComputeQueueDataParamsNV& copy_src);
+    safe_VkExternalComputeQueueDataParamsNV& operator=(const safe_VkExternalComputeQueueDataParamsNV& copy_src);
+    safe_VkExternalComputeQueueDataParamsNV();
+    ~safe_VkExternalComputeQueueDataParamsNV();
+    void initialize(const VkExternalComputeQueueDataParamsNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExternalComputeQueueDataParamsNV* copy_src, PNextCopyState* copy_state = {});
+    VkExternalComputeQueueDataParamsNV* ptr() { return reinterpret_cast<VkExternalComputeQueueDataParamsNV*>(this); }
+    VkExternalComputeQueueDataParamsNV const* ptr() const {
+        return reinterpret_cast<VkExternalComputeQueueDataParamsNV const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t externalDataSize;
+    uint32_t maxExternalQueues;
+
+    safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV(const VkPhysicalDeviceExternalComputeQueuePropertiesNV* in_struct,
+                                                          PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV(const safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV& copy_src);
+    safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV& operator=(
+        const safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV& copy_src);
+    safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV();
+    ~safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV();
+    void initialize(const VkPhysicalDeviceExternalComputeQueuePropertiesNV* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExternalComputeQueuePropertiesNV* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceExternalComputeQueuePropertiesNV*>(this);
+    }
+    VkPhysicalDeviceExternalComputeQueuePropertiesNV const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExternalComputeQueuePropertiesNV const*>(this);
+    }
+};
 struct safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV {
     VkStructureType sType;
     void* pNext{};
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index b9dc50e..ee1ce72 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -751,6 +751,12 @@ template <> inline VkStructureType GetSType<VkCudaLaunchInfoNV>() { return VK_ST
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCudaKernelLaunchFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCudaKernelLaunchPropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV; }
 #endif  // VK_ENABLE_BETA_EXTENSIONS
+template <> inline VkStructureType GetSType<VkPhysicalDeviceTileShadingFeaturesQCOM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceTileShadingPropertiesQCOM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM; }
+template <> inline VkStructureType GetSType<VkRenderPassTileShadingCreateInfoQCOM>() { return VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM; }
+template <> inline VkStructureType GetSType<VkPerTileBeginInfoQCOM>() { return VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM; }
+template <> inline VkStructureType GetSType<VkPerTileEndInfoQCOM>() { return VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM; }
+template <> inline VkStructureType GetSType<VkDispatchTileInfoQCOM>() { return VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM; }
 template <> inline VkStructureType GetSType<VkQueryLowLatencySupportNV>() { return VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV; }
 #ifdef VK_USE_PLATFORM_METAL_EXT
 template <> inline VkStructureType GetSType<VkExportMetalObjectCreateInfoEXT>() { return VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT; }
@@ -1004,6 +1010,10 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceDescriptorPoolOveral
 template <> inline VkStructureType GetSType<VkDisplaySurfaceStereoCreateInfoNV>() { return VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV; }
 template <> inline VkStructureType GetSType<VkDisplayModeStereoPropertiesNV>() { return VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceRawAccessChainsFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV; }
+template <> inline VkStructureType GetSType<VkExternalComputeQueueDeviceCreateInfoNV>() { return VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV; }
+template <> inline VkStructureType GetSType<VkExternalComputeQueueCreateInfoNV>() { return VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV; }
+template <> inline VkStructureType GetSType<VkExternalComputeQueueDataParamsNV>() { return VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceExternalComputeQueuePropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCommandBufferInheritanceFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; }
@@ -1209,6 +1219,7 @@ template<> inline VkObjectType GetObjectType<VkBufferCollectionFUCHSIA>() { retu
 template<> inline VkObjectType GetObjectType<VkMicromapEXT>() { return VK_OBJECT_TYPE_MICROMAP_EXT; }
 template<> inline VkObjectType GetObjectType<VkOpticalFlowSessionNV>() { return VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV; }
 template<> inline VkObjectType GetObjectType<VkShaderEXT>() { return VK_OBJECT_TYPE_SHADER_EXT; }
+template<> inline VkObjectType GetObjectType<VkExternalComputeQueueNV>() { return VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV; }
 template<> inline VkObjectType GetObjectType<VkIndirectExecutionSetEXT>() { return VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT; }
 template<> inline VkObjectType GetObjectType<VkIndirectCommandsLayoutEXT>() { return VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT; }
 
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index 3c30dd4..e821927 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -1422,6 +1422,18 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV";
 #endif  // VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM";
+        case VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM:
+            return "VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM";
+        case VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM:
+            return "VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM";
+        case VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM:
+            return "VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM";
+        case VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM:
+            return "VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM";
         case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV:
             return "VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV";
         case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT:
@@ -2006,6 +2018,14 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV";
+        case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV:
+            return "VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV";
+        case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV:
+            return "VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV";
+        case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV:
+            return "VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV:
@@ -2326,6 +2346,8 @@ static inline const char* string_VkObjectType(VkObjectType input_value) {
             return "VK_OBJECT_TYPE_SHADER_EXT";
         case VK_OBJECT_TYPE_PIPELINE_BINARY_KHR:
             return "VK_OBJECT_TYPE_PIPELINE_BINARY_KHR";
+        case VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV:
+            return "VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV";
         case VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT:
             return "VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT";
         case VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT:
@@ -6794,6 +6816,8 @@ static inline const char* string_VkSubpassDescriptionFlagBits(VkSubpassDescripti
             return "VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM";
         case VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM:
             return "VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM";
+        case VK_SUBPASS_DESCRIPTION_TILE_SHADING_APRON_BIT_QCOM:
+            return "VK_SUBPASS_DESCRIPTION_TILE_SHADING_APRON_BIT_QCOM";
         case VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT:
             return "VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT";
         case VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT:
@@ -7591,6 +7615,8 @@ static inline const char* string_VkAccessFlagBits2(uint64_t input_value) {
     if (input_value == VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR) return "VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR";
     if (input_value == VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR) return "VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR";
     if (input_value == VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR) return "VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR";
+    if (input_value == VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM) return "VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM";
+    if (input_value == VK_ACCESS_2_SHADER_TILE_ATTACHMENT_WRITE_BIT_QCOM) return "VK_ACCESS_2_SHADER_TILE_ATTACHMENT_WRITE_BIT_QCOM";
     if (input_value == VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT) return "VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT";
     if (input_value == VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT) return "VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT";
     if (input_value == VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT) return "VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT";
@@ -9530,6 +9556,33 @@ static inline std::string string_VkDeviceDiagnosticsConfigFlagsNV(VkDeviceDiagno
     return ret;
 }
 #endif // __cplusplus
+static inline const char* string_VkTileShadingRenderPassFlagBitsQCOM(VkTileShadingRenderPassFlagBitsQCOM input_value) {
+    switch (input_value) {
+        case VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM:
+            return "VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM";
+        case VK_TILE_SHADING_RENDER_PASS_PER_TILE_EXECUTION_BIT_QCOM:
+            return "VK_TILE_SHADING_RENDER_PASS_PER_TILE_EXECUTION_BIT_QCOM";
+        default:
+            return "Unhandled VkTileShadingRenderPassFlagBitsQCOM";
+    }
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkTileShadingRenderPassFlagsQCOM(VkTileShadingRenderPassFlagsQCOM input_value) {
+    std::string ret;
+    int index = 0;
+    while(input_value) {
+        if (input_value & 1) {
+            if( !ret.empty()) ret.append("|");
+            ret.append(string_VkTileShadingRenderPassFlagBitsQCOM(static_cast<VkTileShadingRenderPassFlagBitsQCOM>(1U << index)));
+        }
+        ++index;
+        input_value >>= 1;
+    }
+    if (ret.empty()) ret.append("VkTileShadingRenderPassFlagsQCOM(0)");
+    return ret;
+}
+#endif // __cplusplus
 #ifdef VK_USE_PLATFORM_METAL_EXT
 static inline const char* string_VkExportMetalObjectTypeFlagBitsEXT(VkExportMetalObjectTypeFlagBitsEXT input_value) {
     switch (input_value) {
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 9f83ed8..c829994 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.4.311"
+            "commit": "v1.4.312"
         },
         {
             "name": "googletest",
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index cdcfb69..d6357da 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -1391,6 +1391,15 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
                 safe_pNext = new safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV(reinterpret_cast<const VkPhysicalDeviceCudaKernelLaunchPropertiesNV *>(pNext), copy_state, false);
                 break;
 #endif  // VK_ENABLE_BETA_EXTENSIONS
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM:
+                safe_pNext = new safe_VkPhysicalDeviceTileShadingFeaturesQCOM(reinterpret_cast<const VkPhysicalDeviceTileShadingFeaturesQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM:
+                safe_pNext = new safe_VkPhysicalDeviceTileShadingPropertiesQCOM(reinterpret_cast<const VkPhysicalDeviceTileShadingPropertiesQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM:
+                safe_pNext = new safe_VkRenderPassTileShadingCreateInfoQCOM(reinterpret_cast<const VkRenderPassTileShadingCreateInfoQCOM *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV:
                 safe_pNext = new safe_VkQueryLowLatencySupportNV(reinterpret_cast<const VkQueryLowLatencySupportNV *>(pNext), copy_state, false);
                 break;
@@ -1947,6 +1956,12 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
                 safe_pNext = new safe_VkPhysicalDeviceRawAccessChainsFeaturesNV(reinterpret_cast<const VkPhysicalDeviceRawAccessChainsFeaturesNV *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV:
+                safe_pNext = new safe_VkExternalComputeQueueDeviceCreateInfoNV(reinterpret_cast<const VkExternalComputeQueueDeviceCreateInfoNV *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV:
+                safe_pNext = new safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV(reinterpret_cast<const VkPhysicalDeviceExternalComputeQueuePropertiesNV *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV:
                 safe_pNext = new safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV(reinterpret_cast<const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *>(pNext), copy_state, false);
                 break;
@@ -3445,6 +3460,15 @@ void FreePnextChain(const void *pNext) {
             delete reinterpret_cast<safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV *>(header);
             break;
 #endif  // VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM:
+            delete reinterpret_cast<safe_VkPhysicalDeviceTileShadingFeaturesQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM:
+            delete reinterpret_cast<safe_VkPhysicalDeviceTileShadingPropertiesQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM:
+            delete reinterpret_cast<safe_VkRenderPassTileShadingCreateInfoQCOM *>(header);
+            break;
         case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV:
             delete reinterpret_cast<safe_VkQueryLowLatencySupportNV *>(header);
             break;
@@ -4001,6 +4025,12 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
             delete reinterpret_cast<safe_VkPhysicalDeviceRawAccessChainsFeaturesNV *>(header);
             break;
+        case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV:
+            delete reinterpret_cast<safe_VkExternalComputeQueueDeviceCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV:
+            delete reinterpret_cast<safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV:
             delete reinterpret_cast<safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *>(header);
             break;
diff --git a/src/vulkan/vk_safe_struct_vendor.cpp b/src/vulkan/vk_safe_struct_vendor.cpp
index e12547c..163c488 100644
--- a/src/vulkan/vk_safe_struct_vendor.cpp
+++ b/src/vulkan/vk_safe_struct_vendor.cpp
@@ -8275,6 +8275,375 @@ void safe_VkPhysicalDeviceCudaKernelLaunchPropertiesNV::initialize(
 }
 #endif  // VK_ENABLE_BETA_EXTENSIONS
 
+safe_VkPhysicalDeviceTileShadingFeaturesQCOM::safe_VkPhysicalDeviceTileShadingFeaturesQCOM(
+    const VkPhysicalDeviceTileShadingFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      tileShading(in_struct->tileShading),
+      tileShadingFragmentStage(in_struct->tileShadingFragmentStage),
+      tileShadingColorAttachments(in_struct->tileShadingColorAttachments),
+      tileShadingDepthAttachments(in_struct->tileShadingDepthAttachments),
+      tileShadingStencilAttachments(in_struct->tileShadingStencilAttachments),
+      tileShadingInputAttachments(in_struct->tileShadingInputAttachments),
+      tileShadingSampledAttachments(in_struct->tileShadingSampledAttachments),
+      tileShadingPerTileDraw(in_struct->tileShadingPerTileDraw),
+      tileShadingPerTileDispatch(in_struct->tileShadingPerTileDispatch),
+      tileShadingDispatchTile(in_struct->tileShadingDispatchTile),
+      tileShadingApron(in_struct->tileShadingApron),
+      tileShadingAnisotropicApron(in_struct->tileShadingAnisotropicApron),
+      tileShadingAtomicOps(in_struct->tileShadingAtomicOps),
+      tileShadingImageProcessing(in_struct->tileShadingImageProcessing) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceTileShadingFeaturesQCOM::safe_VkPhysicalDeviceTileShadingFeaturesQCOM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM),
+      pNext(nullptr),
+      tileShading(),
+      tileShadingFragmentStage(),
+      tileShadingColorAttachments(),
+      tileShadingDepthAttachments(),
+      tileShadingStencilAttachments(),
+      tileShadingInputAttachments(),
+      tileShadingSampledAttachments(),
+      tileShadingPerTileDraw(),
+      tileShadingPerTileDispatch(),
+      tileShadingDispatchTile(),
+      tileShadingApron(),
+      tileShadingAnisotropicApron(),
+      tileShadingAtomicOps(),
+      tileShadingImageProcessing() {}
+
+safe_VkPhysicalDeviceTileShadingFeaturesQCOM::safe_VkPhysicalDeviceTileShadingFeaturesQCOM(
+    const safe_VkPhysicalDeviceTileShadingFeaturesQCOM& copy_src) {
+    sType = copy_src.sType;
+    tileShading = copy_src.tileShading;
+    tileShadingFragmentStage = copy_src.tileShadingFragmentStage;
+    tileShadingColorAttachments = copy_src.tileShadingColorAttachments;
+    tileShadingDepthAttachments = copy_src.tileShadingDepthAttachments;
+    tileShadingStencilAttachments = copy_src.tileShadingStencilAttachments;
+    tileShadingInputAttachments = copy_src.tileShadingInputAttachments;
+    tileShadingSampledAttachments = copy_src.tileShadingSampledAttachments;
+    tileShadingPerTileDraw = copy_src.tileShadingPerTileDraw;
+    tileShadingPerTileDispatch = copy_src.tileShadingPerTileDispatch;
+    tileShadingDispatchTile = copy_src.tileShadingDispatchTile;
+    tileShadingApron = copy_src.tileShadingApron;
+    tileShadingAnisotropicApron = copy_src.tileShadingAnisotropicApron;
+    tileShadingAtomicOps = copy_src.tileShadingAtomicOps;
+    tileShadingImageProcessing = copy_src.tileShadingImageProcessing;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceTileShadingFeaturesQCOM& safe_VkPhysicalDeviceTileShadingFeaturesQCOM::operator=(
+    const safe_VkPhysicalDeviceTileShadingFeaturesQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    tileShading = copy_src.tileShading;
+    tileShadingFragmentStage = copy_src.tileShadingFragmentStage;
+    tileShadingColorAttachments = copy_src.tileShadingColorAttachments;
+    tileShadingDepthAttachments = copy_src.tileShadingDepthAttachments;
+    tileShadingStencilAttachments = copy_src.tileShadingStencilAttachments;
+    tileShadingInputAttachments = copy_src.tileShadingInputAttachments;
+    tileShadingSampledAttachments = copy_src.tileShadingSampledAttachments;
+    tileShadingPerTileDraw = copy_src.tileShadingPerTileDraw;
+    tileShadingPerTileDispatch = copy_src.tileShadingPerTileDispatch;
+    tileShadingDispatchTile = copy_src.tileShadingDispatchTile;
+    tileShadingApron = copy_src.tileShadingApron;
+    tileShadingAnisotropicApron = copy_src.tileShadingAnisotropicApron;
+    tileShadingAtomicOps = copy_src.tileShadingAtomicOps;
+    tileShadingImageProcessing = copy_src.tileShadingImageProcessing;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceTileShadingFeaturesQCOM::~safe_VkPhysicalDeviceTileShadingFeaturesQCOM() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceTileShadingFeaturesQCOM::initialize(const VkPhysicalDeviceTileShadingFeaturesQCOM* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    tileShading = in_struct->tileShading;
+    tileShadingFragmentStage = in_struct->tileShadingFragmentStage;
+    tileShadingColorAttachments = in_struct->tileShadingColorAttachments;
+    tileShadingDepthAttachments = in_struct->tileShadingDepthAttachments;
+    tileShadingStencilAttachments = in_struct->tileShadingStencilAttachments;
+    tileShadingInputAttachments = in_struct->tileShadingInputAttachments;
+    tileShadingSampledAttachments = in_struct->tileShadingSampledAttachments;
+    tileShadingPerTileDraw = in_struct->tileShadingPerTileDraw;
+    tileShadingPerTileDispatch = in_struct->tileShadingPerTileDispatch;
+    tileShadingDispatchTile = in_struct->tileShadingDispatchTile;
+    tileShadingApron = in_struct->tileShadingApron;
+    tileShadingAnisotropicApron = in_struct->tileShadingAnisotropicApron;
+    tileShadingAtomicOps = in_struct->tileShadingAtomicOps;
+    tileShadingImageProcessing = in_struct->tileShadingImageProcessing;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceTileShadingFeaturesQCOM::initialize(const safe_VkPhysicalDeviceTileShadingFeaturesQCOM* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    tileShading = copy_src->tileShading;
+    tileShadingFragmentStage = copy_src->tileShadingFragmentStage;
+    tileShadingColorAttachments = copy_src->tileShadingColorAttachments;
+    tileShadingDepthAttachments = copy_src->tileShadingDepthAttachments;
+    tileShadingStencilAttachments = copy_src->tileShadingStencilAttachments;
+    tileShadingInputAttachments = copy_src->tileShadingInputAttachments;
+    tileShadingSampledAttachments = copy_src->tileShadingSampledAttachments;
+    tileShadingPerTileDraw = copy_src->tileShadingPerTileDraw;
+    tileShadingPerTileDispatch = copy_src->tileShadingPerTileDispatch;
+    tileShadingDispatchTile = copy_src->tileShadingDispatchTile;
+    tileShadingApron = copy_src->tileShadingApron;
+    tileShadingAnisotropicApron = copy_src->tileShadingAnisotropicApron;
+    tileShadingAtomicOps = copy_src->tileShadingAtomicOps;
+    tileShadingImageProcessing = copy_src->tileShadingImageProcessing;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceTileShadingPropertiesQCOM::safe_VkPhysicalDeviceTileShadingPropertiesQCOM(
+    const VkPhysicalDeviceTileShadingPropertiesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      maxApronSize(in_struct->maxApronSize),
+      preferNonCoherent(in_struct->preferNonCoherent),
+      tileGranularity(in_struct->tileGranularity),
+      maxTileShadingRate(in_struct->maxTileShadingRate) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceTileShadingPropertiesQCOM::safe_VkPhysicalDeviceTileShadingPropertiesQCOM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM),
+      pNext(nullptr),
+      maxApronSize(),
+      preferNonCoherent(),
+      tileGranularity(),
+      maxTileShadingRate() {}
+
+safe_VkPhysicalDeviceTileShadingPropertiesQCOM::safe_VkPhysicalDeviceTileShadingPropertiesQCOM(
+    const safe_VkPhysicalDeviceTileShadingPropertiesQCOM& copy_src) {
+    sType = copy_src.sType;
+    maxApronSize = copy_src.maxApronSize;
+    preferNonCoherent = copy_src.preferNonCoherent;
+    tileGranularity = copy_src.tileGranularity;
+    maxTileShadingRate = copy_src.maxTileShadingRate;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceTileShadingPropertiesQCOM& safe_VkPhysicalDeviceTileShadingPropertiesQCOM::operator=(
+    const safe_VkPhysicalDeviceTileShadingPropertiesQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxApronSize = copy_src.maxApronSize;
+    preferNonCoherent = copy_src.preferNonCoherent;
+    tileGranularity = copy_src.tileGranularity;
+    maxTileShadingRate = copy_src.maxTileShadingRate;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceTileShadingPropertiesQCOM::~safe_VkPhysicalDeviceTileShadingPropertiesQCOM() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceTileShadingPropertiesQCOM::initialize(const VkPhysicalDeviceTileShadingPropertiesQCOM* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxApronSize = in_struct->maxApronSize;
+    preferNonCoherent = in_struct->preferNonCoherent;
+    tileGranularity = in_struct->tileGranularity;
+    maxTileShadingRate = in_struct->maxTileShadingRate;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceTileShadingPropertiesQCOM::initialize(const safe_VkPhysicalDeviceTileShadingPropertiesQCOM* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxApronSize = copy_src->maxApronSize;
+    preferNonCoherent = copy_src->preferNonCoherent;
+    tileGranularity = copy_src->tileGranularity;
+    maxTileShadingRate = copy_src->maxTileShadingRate;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkRenderPassTileShadingCreateInfoQCOM::safe_VkRenderPassTileShadingCreateInfoQCOM(
+    const VkRenderPassTileShadingCreateInfoQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags), tileApronSize(in_struct->tileApronSize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkRenderPassTileShadingCreateInfoQCOM::safe_VkRenderPassTileShadingCreateInfoQCOM()
+    : sType(VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM), pNext(nullptr), flags(), tileApronSize() {}
+
+safe_VkRenderPassTileShadingCreateInfoQCOM::safe_VkRenderPassTileShadingCreateInfoQCOM(
+    const safe_VkRenderPassTileShadingCreateInfoQCOM& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    tileApronSize = copy_src.tileApronSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkRenderPassTileShadingCreateInfoQCOM& safe_VkRenderPassTileShadingCreateInfoQCOM::operator=(
+    const safe_VkRenderPassTileShadingCreateInfoQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    tileApronSize = copy_src.tileApronSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkRenderPassTileShadingCreateInfoQCOM::~safe_VkRenderPassTileShadingCreateInfoQCOM() { FreePnextChain(pNext); }
+
+void safe_VkRenderPassTileShadingCreateInfoQCOM::initialize(const VkRenderPassTileShadingCreateInfoQCOM* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    tileApronSize = in_struct->tileApronSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkRenderPassTileShadingCreateInfoQCOM::initialize(const safe_VkRenderPassTileShadingCreateInfoQCOM* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    tileApronSize = copy_src->tileApronSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPerTileBeginInfoQCOM::safe_VkPerTileBeginInfoQCOM(const VkPerTileBeginInfoQCOM* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPerTileBeginInfoQCOM::safe_VkPerTileBeginInfoQCOM() : sType(VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM), pNext(nullptr) {}
+
+safe_VkPerTileBeginInfoQCOM::safe_VkPerTileBeginInfoQCOM(const safe_VkPerTileBeginInfoQCOM& copy_src) {
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPerTileBeginInfoQCOM& safe_VkPerTileBeginInfoQCOM::operator=(const safe_VkPerTileBeginInfoQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPerTileBeginInfoQCOM::~safe_VkPerTileBeginInfoQCOM() { FreePnextChain(pNext); }
+
+void safe_VkPerTileBeginInfoQCOM::initialize(const VkPerTileBeginInfoQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPerTileBeginInfoQCOM::initialize(const safe_VkPerTileBeginInfoQCOM* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPerTileEndInfoQCOM::safe_VkPerTileEndInfoQCOM(const VkPerTileEndInfoQCOM* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPerTileEndInfoQCOM::safe_VkPerTileEndInfoQCOM() : sType(VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM), pNext(nullptr) {}
+
+safe_VkPerTileEndInfoQCOM::safe_VkPerTileEndInfoQCOM(const safe_VkPerTileEndInfoQCOM& copy_src) {
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPerTileEndInfoQCOM& safe_VkPerTileEndInfoQCOM::operator=(const safe_VkPerTileEndInfoQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPerTileEndInfoQCOM::~safe_VkPerTileEndInfoQCOM() { FreePnextChain(pNext); }
+
+void safe_VkPerTileEndInfoQCOM::initialize(const VkPerTileEndInfoQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPerTileEndInfoQCOM::initialize(const safe_VkPerTileEndInfoQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDispatchTileInfoQCOM::safe_VkDispatchTileInfoQCOM(const VkDispatchTileInfoQCOM* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDispatchTileInfoQCOM::safe_VkDispatchTileInfoQCOM() : sType(VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM), pNext(nullptr) {}
+
+safe_VkDispatchTileInfoQCOM::safe_VkDispatchTileInfoQCOM(const safe_VkDispatchTileInfoQCOM& copy_src) {
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDispatchTileInfoQCOM& safe_VkDispatchTileInfoQCOM::operator=(const safe_VkDispatchTileInfoQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDispatchTileInfoQCOM::~safe_VkDispatchTileInfoQCOM() { FreePnextChain(pNext); }
+
+void safe_VkDispatchTileInfoQCOM::initialize(const VkDispatchTileInfoQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDispatchTileInfoQCOM::initialize(const safe_VkDispatchTileInfoQCOM* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkQueryLowLatencySupportNV::safe_VkQueryLowLatencySupportNV(const VkQueryLowLatencySupportNV* in_struct,
                                                                  [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType), pQueriedLowLatencyData(in_struct->pQueriedLowLatencyData) {
@@ -15723,6 +16092,207 @@ void safe_VkPhysicalDeviceRawAccessChainsFeaturesNV::initialize(const safe_VkPhy
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkExternalComputeQueueDeviceCreateInfoNV::safe_VkExternalComputeQueueDeviceCreateInfoNV(
+    const VkExternalComputeQueueDeviceCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), reservedExternalQueues(in_struct->reservedExternalQueues) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkExternalComputeQueueDeviceCreateInfoNV::safe_VkExternalComputeQueueDeviceCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV), pNext(nullptr), reservedExternalQueues() {}
+
+safe_VkExternalComputeQueueDeviceCreateInfoNV::safe_VkExternalComputeQueueDeviceCreateInfoNV(
+    const safe_VkExternalComputeQueueDeviceCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    reservedExternalQueues = copy_src.reservedExternalQueues;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkExternalComputeQueueDeviceCreateInfoNV& safe_VkExternalComputeQueueDeviceCreateInfoNV::operator=(
+    const safe_VkExternalComputeQueueDeviceCreateInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    reservedExternalQueues = copy_src.reservedExternalQueues;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkExternalComputeQueueDeviceCreateInfoNV::~safe_VkExternalComputeQueueDeviceCreateInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkExternalComputeQueueDeviceCreateInfoNV::initialize(const VkExternalComputeQueueDeviceCreateInfoNV* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    reservedExternalQueues = in_struct->reservedExternalQueues;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkExternalComputeQueueDeviceCreateInfoNV::initialize(const safe_VkExternalComputeQueueDeviceCreateInfoNV* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    reservedExternalQueues = copy_src->reservedExternalQueues;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkExternalComputeQueueCreateInfoNV::safe_VkExternalComputeQueueCreateInfoNV(
+    const VkExternalComputeQueueCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), preferredQueue(in_struct->preferredQueue) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkExternalComputeQueueCreateInfoNV::safe_VkExternalComputeQueueCreateInfoNV()
+    : sType(VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV), pNext(nullptr), preferredQueue() {}
+
+safe_VkExternalComputeQueueCreateInfoNV::safe_VkExternalComputeQueueCreateInfoNV(
+    const safe_VkExternalComputeQueueCreateInfoNV& copy_src) {
+    sType = copy_src.sType;
+    preferredQueue = copy_src.preferredQueue;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkExternalComputeQueueCreateInfoNV& safe_VkExternalComputeQueueCreateInfoNV::operator=(
+    const safe_VkExternalComputeQueueCreateInfoNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    preferredQueue = copy_src.preferredQueue;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkExternalComputeQueueCreateInfoNV::~safe_VkExternalComputeQueueCreateInfoNV() { FreePnextChain(pNext); }
+
+void safe_VkExternalComputeQueueCreateInfoNV::initialize(const VkExternalComputeQueueCreateInfoNV* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    preferredQueue = in_struct->preferredQueue;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkExternalComputeQueueCreateInfoNV::initialize(const safe_VkExternalComputeQueueCreateInfoNV* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    preferredQueue = copy_src->preferredQueue;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkExternalComputeQueueDataParamsNV::safe_VkExternalComputeQueueDataParamsNV(
+    const VkExternalComputeQueueDataParamsNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), deviceIndex(in_struct->deviceIndex) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkExternalComputeQueueDataParamsNV::safe_VkExternalComputeQueueDataParamsNV()
+    : sType(VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV), pNext(nullptr), deviceIndex() {}
+
+safe_VkExternalComputeQueueDataParamsNV::safe_VkExternalComputeQueueDataParamsNV(
+    const safe_VkExternalComputeQueueDataParamsNV& copy_src) {
+    sType = copy_src.sType;
+    deviceIndex = copy_src.deviceIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkExternalComputeQueueDataParamsNV& safe_VkExternalComputeQueueDataParamsNV::operator=(
+    const safe_VkExternalComputeQueueDataParamsNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    deviceIndex = copy_src.deviceIndex;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkExternalComputeQueueDataParamsNV::~safe_VkExternalComputeQueueDataParamsNV() { FreePnextChain(pNext); }
+
+void safe_VkExternalComputeQueueDataParamsNV::initialize(const VkExternalComputeQueueDataParamsNV* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    deviceIndex = in_struct->deviceIndex;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkExternalComputeQueueDataParamsNV::initialize(const safe_VkExternalComputeQueueDataParamsNV* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    deviceIndex = copy_src->deviceIndex;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV::safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV(
+    const VkPhysicalDeviceExternalComputeQueuePropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), externalDataSize(in_struct->externalDataSize), maxExternalQueues(in_struct->maxExternalQueues) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV::safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV),
+      pNext(nullptr),
+      externalDataSize(),
+      maxExternalQueues() {}
+
+safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV::safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV(
+    const safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV& copy_src) {
+    sType = copy_src.sType;
+    externalDataSize = copy_src.externalDataSize;
+    maxExternalQueues = copy_src.maxExternalQueues;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV& safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV::operator=(
+    const safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    externalDataSize = copy_src.externalDataSize;
+    maxExternalQueues = copy_src.maxExternalQueues;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV::~safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV::initialize(
+    const VkPhysicalDeviceExternalComputeQueuePropertiesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    externalDataSize = in_struct->externalDataSize;
+    maxExternalQueues = in_struct->maxExternalQueues;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV::initialize(
+    const safe_VkPhysicalDeviceExternalComputeQueuePropertiesNV* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    externalDataSize = copy_src->externalDataSize;
+    maxExternalQueues = copy_src->maxExternalQueues;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV::safe_VkPhysicalDeviceCommandBufferInheritanceFeaturesNV(
     const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
     bool copy_pnext)

From abc2498bde8d65841f463431a6220701fad44c64 Mon Sep 17 00:00:00 2001
From: Christophe <christophe@lunarg.com>
Date: Mon, 7 Apr 2025 16:47:48 +0200
Subject: [PATCH 097/106] Fix typo

---
 docs/layer_configuration.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/layer_configuration.md b/docs/layer_configuration.md
index 360fe9b..1226fc1 100644
--- a/docs/layer_configuration.md
+++ b/docs/layer_configuration.md
@@ -92,7 +92,7 @@ Layer settings may be configured using the `VK_EXT_layer_settings` extension by
         {layer_name, "validate_sync", VK_LAYER_SETTING_TYPE_BOOL32_EXT, 1, &setting_validate_sync},
         {layer_name, "thread_safety", VK_LAYER_SETTING_TYPE_BOOL32_EXT, 1, &setting_thread_safety},
         {layer_name, "debug_action", VK_LAYER_SETTING_TYPE_STRING_EXT, 1, setting_debug_action},
-        {layer_name, "report_flags", VK_LAYER_SETTING_TYPE_STRING_EXT, static_cast<uint32_t>(std::size(setting_report_flags)), setting_report_flags}
+        {layer_name, "report_flags", VK_LAYER_SETTING_TYPE_STRING_EXT, static_cast<uint32_t>(std::size(setting_report_flags)), setting_report_flags},
         {layer_name, "enable_message_limit", VK_LAYER_SETTING_TYPE_BOOL32_EXT, 1, &setting_enable_message_limit},
         {layer_name, "duplicate_message_limit", VK_LAYER_SETTING_TYPE_INT32_EXT, 1, &setting_duplicate_message_limit}};
 

From ad2ffcba7b2b3f327dcbcb1f825450d49181b46d Mon Sep 17 00:00:00 2001
From: Christophe <christophe@lunarg.com>
Date: Tue, 8 Apr 2025 16:19:58 +0200
Subject: [PATCH 098/106] settings: Add Android layer settings example

---
 docs/layer_configuration.md | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/docs/layer_configuration.md b/docs/layer_configuration.md
index 1226fc1..50e46ad 100644
--- a/docs/layer_configuration.md
+++ b/docs/layer_configuration.md
@@ -368,4 +368,14 @@ $ export VK_VALIDATION_DEBUG_ACTION=VK_DBG_LAYER_ACTION_LOG_MSG
 $ export VK_VALIDATION_REPORT_FLAGS=debug:error:perf:info:warn
 $ export VK_VALIDATION_ENABLE_MESSAGE_LIMIT=true
 $ export VK_VALIDATION_DUPLICATE_MESSAGE_LIMIT=3
-```
\ No newline at end of file
+```
+
+#### Example Usage on Android:
+
+```
+$ adb setprop debug.vvl.validation_core true
+$ adb setprop debug.vulkan.validation.validation_sync true
+$ adb setprop debug.vulkan.validation.thread_safety true
+$ adb setprop debug.vulkan.validation.enable_message_limit true
+$ adb setprop debug.vulkan.validation.duplicate_message_limit 3
+```

From 4ee0833a3cdb834aa71c2b77ce5b01235b7b7170 Mon Sep 17 00:00:00 2001
From: jpr42 <github@jpr.mozmail.com>
Date: Fri, 11 Apr 2025 23:20:56 -0700
Subject: [PATCH 099/106] Fix UBSAN error

Calling memcpy with either src or dst as nullptr is undefined
even if the count is 0.

Discovered by running tests with -fsanitize=undefined

safe_struct.extension_add_remove specifcially
---
 CMakeLists.txt                                  | 17 ++++++++++++++++-
 include/vulkan/utility/vk_safe_struct_utils.hpp |  4 +++-
 2 files changed, 19 insertions(+), 2 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8e84121..fea5be3 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -25,6 +25,22 @@ add_subdirectory(scripts)
 
 find_package(VulkanHeaders CONFIG)
 
+option(VUL_ENABLE_ASAN "Use address sanitization")
+if (VUL_ENABLE_ASAN)
+    add_compile_options(-fsanitize=address)
+    if (NOT MSVC)
+        add_link_options(-fsanitize=address)
+    endif()
+endif()
+
+option(VUL_ENABLE_UBSAN "Use undefined behavior sanitization")
+if (VUL_ENABLE_UBSAN)
+    if (NOT MSVC)
+        add_compile_options(-fsanitize=undefined)
+        add_link_options(-fsanitize=undefined)
+    endif()
+endif()
+
 add_subdirectory(src)
 add_subdirectory(include)
 
@@ -37,7 +53,6 @@ if (PROJECT_IS_TOP_LEVEL)
 endif()
 
 option(VUL_ENABLE_INSTALL "Enable install" ${PROJECT_IS_TOP_LEVEL})
-
 if (VUL_ENABLE_INSTALL)
 
     include(GNUInstallDirs)
diff --git a/include/vulkan/utility/vk_safe_struct_utils.hpp b/include/vulkan/utility/vk_safe_struct_utils.hpp
index a770298..ff87859 100644
--- a/include/vulkan/utility/vk_safe_struct_utils.hpp
+++ b/include/vulkan/utility/vk_safe_struct_utils.hpp
@@ -83,7 +83,9 @@ bool AddExtension(CreateInfo& ci, const char* extension_name) {
         return false;
     }
     char** exts = new char*[ci.enabledExtensionCount + 1];
-    memcpy(exts, ci.ppEnabledExtensionNames, sizeof(char*) * ci.enabledExtensionCount);
+    if (ci.ppEnabledExtensionNames) {
+        memcpy(exts, ci.ppEnabledExtensionNames, sizeof(char*) * ci.enabledExtensionCount);
+    }
     exts[ci.enabledExtensionCount] = SafeStringCopy(extension_name);
     delete[] ci.ppEnabledExtensionNames;
     ci.ppEnabledExtensionNames = exts;

From 4e246c56ec5afb5ad66b9b04374d39ac04675c8e Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Fri, 18 Apr 2025 11:43:41 -0700
Subject: [PATCH 100/106] build: Update to header 1.4.313

---
 include/vulkan/utility/vk_dispatch_table.h  |   2 +
 include/vulkan/utility/vk_safe_struct.hpp   |  90 +++++++
 include/vulkan/utility/vk_struct_helper.hpp |   5 +
 include/vulkan/vk_enum_string_helper.h      |  17 ++
 scripts/known_good.json                     |   2 +-
 src/vulkan/vk_safe_struct_utils.cpp         |  30 +++
 src/vulkan/vk_safe_struct_vendor.cpp        | 247 ++++++++++++++++++++
 7 files changed, 392 insertions(+), 1 deletion(-)

diff --git a/include/vulkan/utility/vk_dispatch_table.h b/include/vulkan/utility/vk_dispatch_table.h
index f13b592..1c0f82a 100644
--- a/include/vulkan/utility/vk_dispatch_table.h
+++ b/include/vulkan/utility/vk_dispatch_table.h
@@ -767,6 +767,7 @@ typedef struct VkuDeviceDispatchTable_ {
 #ifdef VK_USE_PLATFORM_SCREEN_QNX
     PFN_vkGetScreenBufferPropertiesQNX GetScreenBufferPropertiesQNX;
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
+    PFN_vkCmdBindTileMemoryQCOM CmdBindTileMemoryQCOM;
     PFN_vkCreateExternalComputeQueueNV CreateExternalComputeQueueNV;
     PFN_vkDestroyExternalComputeQueueNV DestroyExternalComputeQueueNV;
     PFN_vkGetExternalComputeQueueDataNV GetExternalComputeQueueDataNV;
@@ -1418,6 +1419,7 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
 #ifdef VK_USE_PLATFORM_SCREEN_QNX
     table->GetScreenBufferPropertiesQNX = (PFN_vkGetScreenBufferPropertiesQNX)gdpa(device, "vkGetScreenBufferPropertiesQNX");
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
+    table->CmdBindTileMemoryQCOM = (PFN_vkCmdBindTileMemoryQCOM)gdpa(device, "vkCmdBindTileMemoryQCOM");
     table->CreateExternalComputeQueueNV = (PFN_vkCreateExternalComputeQueueNV)gdpa(device, "vkCreateExternalComputeQueueNV");
     table->DestroyExternalComputeQueueNV = (PFN_vkDestroyExternalComputeQueueNV)gdpa(device, "vkDestroyExternalComputeQueueNV");
     table->GetExternalComputeQueueDataNV = (PFN_vkGetExternalComputeQueueDataNV)gdpa(device, "vkGetExternalComputeQueueDataNV");
diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index 74449f7..f208e1b 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -19294,6 +19294,96 @@ struct safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV {
         return reinterpret_cast<VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV const*>(this);
     }
 };
+struct safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 tileMemoryHeap;
+
+    safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM(const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM* in_struct,
+                                                    PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM(const safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM& copy_src);
+    safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM& operator=(const safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM& copy_src);
+    safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM();
+    ~safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM();
+    void initialize(const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceTileMemoryHeapFeaturesQCOM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceTileMemoryHeapFeaturesQCOM*>(this);
+    }
+    VkPhysicalDeviceTileMemoryHeapFeaturesQCOM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceTileMemoryHeapFeaturesQCOM const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 queueSubmitBoundary;
+    VkBool32 tileBufferTransfers;
+
+    safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM(const VkPhysicalDeviceTileMemoryHeapPropertiesQCOM* in_struct,
+                                                      PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM(const safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM& copy_src);
+    safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM& operator=(const safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM& copy_src);
+    safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM();
+    ~safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM();
+    void initialize(const VkPhysicalDeviceTileMemoryHeapPropertiesQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceTileMemoryHeapPropertiesQCOM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceTileMemoryHeapPropertiesQCOM*>(this);
+    }
+    VkPhysicalDeviceTileMemoryHeapPropertiesQCOM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceTileMemoryHeapPropertiesQCOM const*>(this);
+    }
+};
+struct safe_VkTileMemoryRequirementsQCOM {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceSize size;
+    VkDeviceSize alignment;
+
+    safe_VkTileMemoryRequirementsQCOM(const VkTileMemoryRequirementsQCOM* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    safe_VkTileMemoryRequirementsQCOM(const safe_VkTileMemoryRequirementsQCOM& copy_src);
+    safe_VkTileMemoryRequirementsQCOM& operator=(const safe_VkTileMemoryRequirementsQCOM& copy_src);
+    safe_VkTileMemoryRequirementsQCOM();
+    ~safe_VkTileMemoryRequirementsQCOM();
+    void initialize(const VkTileMemoryRequirementsQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkTileMemoryRequirementsQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkTileMemoryRequirementsQCOM* ptr() { return reinterpret_cast<VkTileMemoryRequirementsQCOM*>(this); }
+    VkTileMemoryRequirementsQCOM const* ptr() const { return reinterpret_cast<VkTileMemoryRequirementsQCOM const*>(this); }
+};
+struct safe_VkTileMemoryBindInfoQCOM {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceMemory memory;
+
+    safe_VkTileMemoryBindInfoQCOM(const VkTileMemoryBindInfoQCOM* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    safe_VkTileMemoryBindInfoQCOM(const safe_VkTileMemoryBindInfoQCOM& copy_src);
+    safe_VkTileMemoryBindInfoQCOM& operator=(const safe_VkTileMemoryBindInfoQCOM& copy_src);
+    safe_VkTileMemoryBindInfoQCOM();
+    ~safe_VkTileMemoryBindInfoQCOM();
+    void initialize(const VkTileMemoryBindInfoQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkTileMemoryBindInfoQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkTileMemoryBindInfoQCOM* ptr() { return reinterpret_cast<VkTileMemoryBindInfoQCOM*>(this); }
+    VkTileMemoryBindInfoQCOM const* ptr() const { return reinterpret_cast<VkTileMemoryBindInfoQCOM const*>(this); }
+};
+struct safe_VkTileMemorySizeInfoQCOM {
+    VkStructureType sType;
+    const void* pNext{};
+    VkDeviceSize size;
+
+    safe_VkTileMemorySizeInfoQCOM(const VkTileMemorySizeInfoQCOM* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    safe_VkTileMemorySizeInfoQCOM(const safe_VkTileMemorySizeInfoQCOM& copy_src);
+    safe_VkTileMemorySizeInfoQCOM& operator=(const safe_VkTileMemorySizeInfoQCOM& copy_src);
+    safe_VkTileMemorySizeInfoQCOM();
+    ~safe_VkTileMemorySizeInfoQCOM();
+    void initialize(const VkTileMemorySizeInfoQCOM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkTileMemorySizeInfoQCOM* copy_src, PNextCopyState* copy_state = {});
+    VkTileMemorySizeInfoQCOM* ptr() { return reinterpret_cast<VkTileMemorySizeInfoQCOM*>(this); }
+    VkTileMemorySizeInfoQCOM const* ptr() const { return reinterpret_cast<VkTileMemorySizeInfoQCOM const*>(this); }
+};
 struct safe_VkDisplaySurfaceStereoCreateInfoNV {
     VkStructureType sType;
     const void* pNext{};
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index ee1ce72..9894cbc 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -1007,6 +1007,11 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceExternalMemoryScreen
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
 template <> inline VkStructureType GetSType<VkPhysicalDeviceLayeredDriverPropertiesMSFT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceTileMemoryHeapFeaturesQCOM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceTileMemoryHeapPropertiesQCOM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM; }
+template <> inline VkStructureType GetSType<VkTileMemoryRequirementsQCOM>() { return VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM; }
+template <> inline VkStructureType GetSType<VkTileMemoryBindInfoQCOM>() { return VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM; }
+template <> inline VkStructureType GetSType<VkTileMemorySizeInfoQCOM>() { return VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM; }
 template <> inline VkStructureType GetSType<VkDisplaySurfaceStereoCreateInfoNV>() { return VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV; }
 template <> inline VkStructureType GetSType<VkDisplayModeStereoPropertiesNV>() { return VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceRawAccessChainsFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index e821927..5b1e584 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -1992,6 +1992,16 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM";
+        case VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM:
+            return "VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM";
+        case VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM:
+            return "VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM";
+        case VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM:
+            return "VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM";
         case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV:
             return "VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV";
         case VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV:
@@ -5644,6 +5654,8 @@ static inline const char* string_VkImageUsageFlagBits(VkImageUsageFlagBits input
             return "VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM";
         case VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM:
             return "VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM";
+        case VK_IMAGE_USAGE_TILE_MEMORY_QCOM:
+            return "VK_IMAGE_USAGE_TILE_MEMORY_QCOM";
         case VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR:
             return "VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR";
         case VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR:
@@ -5700,6 +5712,8 @@ static inline const char* string_VkMemoryHeapFlagBits(VkMemoryHeapFlagBits input
             return "VK_MEMORY_HEAP_DEVICE_LOCAL_BIT";
         case VK_MEMORY_HEAP_MULTI_INSTANCE_BIT:
             return "VK_MEMORY_HEAP_MULTI_INSTANCE_BIT";
+        case VK_MEMORY_HEAP_TILE_MEMORY_BIT_QCOM:
+            return "VK_MEMORY_HEAP_TILE_MEMORY_BIT_QCOM";
         default:
             return "Unhandled VkMemoryHeapFlagBits";
     }
@@ -6209,6 +6223,8 @@ static inline const char* string_VkBufferUsageFlagBits(VkBufferUsageFlagBits inp
             return "VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT";
         case VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT:
             return "VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT";
+        case VK_BUFFER_USAGE_TILE_MEMORY_QCOM:
+            return "VK_BUFFER_USAGE_TILE_MEMORY_QCOM";
         default:
             return "Unhandled VkBufferUsageFlagBits";
     }
@@ -7891,6 +7907,7 @@ static inline const char* string_VkBufferUsageFlagBits2(uint64_t input_value) {
     if (input_value == VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT";
     if (input_value == VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT) return "VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT";
     if (input_value == VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT) return "VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT";
+    if (input_value == VK_BUFFER_USAGE_2_TILE_MEMORY_QCOM) return "VK_BUFFER_USAGE_2_TILE_MEMORY_QCOM";
     if (input_value == VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT";
     return "Unhandled VkBufferUsageFlagBits2";
 }
diff --git a/scripts/known_good.json b/scripts/known_good.json
index c829994..dcd6555 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.4.312"
+            "commit": "v1.4.313"
         },
         {
             "name": "googletest",
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index d6357da..d71352f 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -1947,6 +1947,21 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
                 safe_pNext = new safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV(reinterpret_cast<const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM:
+                safe_pNext = new safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM(reinterpret_cast<const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM:
+                safe_pNext = new safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM(reinterpret_cast<const VkPhysicalDeviceTileMemoryHeapPropertiesQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM:
+                safe_pNext = new safe_VkTileMemoryRequirementsQCOM(reinterpret_cast<const VkTileMemoryRequirementsQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM:
+                safe_pNext = new safe_VkTileMemoryBindInfoQCOM(reinterpret_cast<const VkTileMemoryBindInfoQCOM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM:
+                safe_pNext = new safe_VkTileMemorySizeInfoQCOM(reinterpret_cast<const VkTileMemorySizeInfoQCOM *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV:
                 safe_pNext = new safe_VkDisplaySurfaceStereoCreateInfoNV(reinterpret_cast<const VkDisplaySurfaceStereoCreateInfoNV *>(pNext), copy_state, false);
                 break;
@@ -4016,6 +4031,21 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
             delete reinterpret_cast<safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM:
+            delete reinterpret_cast<safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM:
+            delete reinterpret_cast<safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM:
+            delete reinterpret_cast<safe_VkTileMemoryRequirementsQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM:
+            delete reinterpret_cast<safe_VkTileMemoryBindInfoQCOM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM:
+            delete reinterpret_cast<safe_VkTileMemorySizeInfoQCOM *>(header);
+            break;
         case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV:
             delete reinterpret_cast<safe_VkDisplaySurfaceStereoCreateInfoNV *>(header);
             break;
diff --git a/src/vulkan/vk_safe_struct_vendor.cpp b/src/vulkan/vk_safe_struct_vendor.cpp
index 163c488..8d84afd 100644
--- a/src/vulkan/vk_safe_struct_vendor.cpp
+++ b/src/vulkan/vk_safe_struct_vendor.cpp
@@ -15948,6 +15948,253 @@ void safe_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV::initialize(
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM::safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM(
+    const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), tileMemoryHeap(in_struct->tileMemoryHeap) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM::safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM), pNext(nullptr), tileMemoryHeap() {}
+
+safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM::safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM(
+    const safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM& copy_src) {
+    sType = copy_src.sType;
+    tileMemoryHeap = copy_src.tileMemoryHeap;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM& safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM::operator=(
+    const safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    tileMemoryHeap = copy_src.tileMemoryHeap;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM::~safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM::initialize(const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM* in_struct,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    tileMemoryHeap = in_struct->tileMemoryHeap;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM::initialize(const safe_VkPhysicalDeviceTileMemoryHeapFeaturesQCOM* copy_src,
+                                                                 [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    tileMemoryHeap = copy_src->tileMemoryHeap;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM::safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM(
+    const VkPhysicalDeviceTileMemoryHeapPropertiesQCOM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      queueSubmitBoundary(in_struct->queueSubmitBoundary),
+      tileBufferTransfers(in_struct->tileBufferTransfers) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM::safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM),
+      pNext(nullptr),
+      queueSubmitBoundary(),
+      tileBufferTransfers() {}
+
+safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM::safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM(
+    const safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM& copy_src) {
+    sType = copy_src.sType;
+    queueSubmitBoundary = copy_src.queueSubmitBoundary;
+    tileBufferTransfers = copy_src.tileBufferTransfers;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM& safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM::operator=(
+    const safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    queueSubmitBoundary = copy_src.queueSubmitBoundary;
+    tileBufferTransfers = copy_src.tileBufferTransfers;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM::~safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM::initialize(const VkPhysicalDeviceTileMemoryHeapPropertiesQCOM* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    queueSubmitBoundary = in_struct->queueSubmitBoundary;
+    tileBufferTransfers = in_struct->tileBufferTransfers;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM::initialize(
+    const safe_VkPhysicalDeviceTileMemoryHeapPropertiesQCOM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    queueSubmitBoundary = copy_src->queueSubmitBoundary;
+    tileBufferTransfers = copy_src->tileBufferTransfers;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkTileMemoryRequirementsQCOM::safe_VkTileMemoryRequirementsQCOM(const VkTileMemoryRequirementsQCOM* in_struct,
+                                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), size(in_struct->size), alignment(in_struct->alignment) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkTileMemoryRequirementsQCOM::safe_VkTileMemoryRequirementsQCOM()
+    : sType(VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM), pNext(nullptr), size(), alignment() {}
+
+safe_VkTileMemoryRequirementsQCOM::safe_VkTileMemoryRequirementsQCOM(const safe_VkTileMemoryRequirementsQCOM& copy_src) {
+    sType = copy_src.sType;
+    size = copy_src.size;
+    alignment = copy_src.alignment;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkTileMemoryRequirementsQCOM& safe_VkTileMemoryRequirementsQCOM::operator=(const safe_VkTileMemoryRequirementsQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    size = copy_src.size;
+    alignment = copy_src.alignment;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkTileMemoryRequirementsQCOM::~safe_VkTileMemoryRequirementsQCOM() { FreePnextChain(pNext); }
+
+void safe_VkTileMemoryRequirementsQCOM::initialize(const VkTileMemoryRequirementsQCOM* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    size = in_struct->size;
+    alignment = in_struct->alignment;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkTileMemoryRequirementsQCOM::initialize(const safe_VkTileMemoryRequirementsQCOM* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    size = copy_src->size;
+    alignment = copy_src->alignment;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkTileMemoryBindInfoQCOM::safe_VkTileMemoryBindInfoQCOM(const VkTileMemoryBindInfoQCOM* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), memory(in_struct->memory) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkTileMemoryBindInfoQCOM::safe_VkTileMemoryBindInfoQCOM()
+    : sType(VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM), pNext(nullptr), memory() {}
+
+safe_VkTileMemoryBindInfoQCOM::safe_VkTileMemoryBindInfoQCOM(const safe_VkTileMemoryBindInfoQCOM& copy_src) {
+    sType = copy_src.sType;
+    memory = copy_src.memory;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkTileMemoryBindInfoQCOM& safe_VkTileMemoryBindInfoQCOM::operator=(const safe_VkTileMemoryBindInfoQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    memory = copy_src.memory;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkTileMemoryBindInfoQCOM::~safe_VkTileMemoryBindInfoQCOM() { FreePnextChain(pNext); }
+
+void safe_VkTileMemoryBindInfoQCOM::initialize(const VkTileMemoryBindInfoQCOM* in_struct,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    memory = in_struct->memory;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkTileMemoryBindInfoQCOM::initialize(const safe_VkTileMemoryBindInfoQCOM* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    memory = copy_src->memory;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkTileMemorySizeInfoQCOM::safe_VkTileMemorySizeInfoQCOM(const VkTileMemorySizeInfoQCOM* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), size(in_struct->size) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkTileMemorySizeInfoQCOM::safe_VkTileMemorySizeInfoQCOM()
+    : sType(VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM), pNext(nullptr), size() {}
+
+safe_VkTileMemorySizeInfoQCOM::safe_VkTileMemorySizeInfoQCOM(const safe_VkTileMemorySizeInfoQCOM& copy_src) {
+    sType = copy_src.sType;
+    size = copy_src.size;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkTileMemorySizeInfoQCOM& safe_VkTileMemorySizeInfoQCOM::operator=(const safe_VkTileMemorySizeInfoQCOM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    size = copy_src.size;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkTileMemorySizeInfoQCOM::~safe_VkTileMemorySizeInfoQCOM() { FreePnextChain(pNext); }
+
+void safe_VkTileMemorySizeInfoQCOM::initialize(const VkTileMemorySizeInfoQCOM* in_struct,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    size = in_struct->size;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkTileMemorySizeInfoQCOM::initialize(const safe_VkTileMemorySizeInfoQCOM* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    size = copy_src->size;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkDisplaySurfaceStereoCreateInfoNV::safe_VkDisplaySurfaceStereoCreateInfoNV(
     const VkDisplaySurfaceStereoCreateInfoNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType), stereoType(in_struct->stereoType) {

From be40e67892c83d4752ccfbee7ce690ea88087d2b Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Mon, 5 May 2025 11:44:33 -0700
Subject: [PATCH 101/106] build: Update to header 1.4.314

---
 include/vulkan/utility/vk_safe_struct.hpp   |  78 ++++++-------
 include/vulkan/utility/vk_struct_helper.hpp |   4 +-
 include/vulkan/vk_enum_string_helper.h      |   8 +-
 scripts/known_good.json                     |   2 +-
 src/vulkan/vk_safe_struct_ext.cpp           | 120 --------------------
 src/vulkan/vk_safe_struct_khr.cpp           | 120 ++++++++++++++++++++
 src/vulkan/vk_safe_struct_utils.cpp         |  24 ++--
 7 files changed, 178 insertions(+), 178 deletions(-)

diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index f208e1b..ab7f77a 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -9754,6 +9754,45 @@ struct safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR {
         return reinterpret_cast<VkPhysicalDeviceDepthClampZeroOneFeaturesKHR const*>(this);
     }
 };
+struct safe_VkPhysicalDeviceRobustness2FeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 robustBufferAccess2;
+    VkBool32 robustImageAccess2;
+    VkBool32 nullDescriptor;
+
+    safe_VkPhysicalDeviceRobustness2FeaturesKHR(const VkPhysicalDeviceRobustness2FeaturesKHR* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceRobustness2FeaturesKHR(const safe_VkPhysicalDeviceRobustness2FeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceRobustness2FeaturesKHR& operator=(const safe_VkPhysicalDeviceRobustness2FeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceRobustness2FeaturesKHR();
+    ~safe_VkPhysicalDeviceRobustness2FeaturesKHR();
+    void initialize(const VkPhysicalDeviceRobustness2FeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceRobustness2FeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRobustness2FeaturesKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesKHR*>(this); }
+    VkPhysicalDeviceRobustness2FeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceRobustness2PropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkDeviceSize robustStorageBufferAccessSizeAlignment;
+    VkDeviceSize robustUniformBufferAccessSizeAlignment;
+
+    safe_VkPhysicalDeviceRobustness2PropertiesKHR(const VkPhysicalDeviceRobustness2PropertiesKHR* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceRobustness2PropertiesKHR(const safe_VkPhysicalDeviceRobustness2PropertiesKHR& copy_src);
+    safe_VkPhysicalDeviceRobustness2PropertiesKHR& operator=(const safe_VkPhysicalDeviceRobustness2PropertiesKHR& copy_src);
+    safe_VkPhysicalDeviceRobustness2PropertiesKHR();
+    ~safe_VkPhysicalDeviceRobustness2PropertiesKHR();
+    void initialize(const VkPhysicalDeviceRobustness2PropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceRobustness2PropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceRobustness2PropertiesKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesKHR*>(this); }
+    VkPhysicalDeviceRobustness2PropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesKHR const*>(this);
+    }
+};
 struct safe_VkDebugReportCallbackCreateInfoEXT {
     VkStructureType sType;
     const void* pNext{};
@@ -13936,45 +13975,6 @@ struct safe_VkDeviceDeviceMemoryReportCreateInfoEXT {
         return reinterpret_cast<VkDeviceDeviceMemoryReportCreateInfoEXT const*>(this);
     }
 };
-struct safe_VkPhysicalDeviceRobustness2FeaturesEXT {
-    VkStructureType sType;
-    void* pNext{};
-    VkBool32 robustBufferAccess2;
-    VkBool32 robustImageAccess2;
-    VkBool32 nullDescriptor;
-
-    safe_VkPhysicalDeviceRobustness2FeaturesEXT(const VkPhysicalDeviceRobustness2FeaturesEXT* in_struct,
-                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPhysicalDeviceRobustness2FeaturesEXT(const safe_VkPhysicalDeviceRobustness2FeaturesEXT& copy_src);
-    safe_VkPhysicalDeviceRobustness2FeaturesEXT& operator=(const safe_VkPhysicalDeviceRobustness2FeaturesEXT& copy_src);
-    safe_VkPhysicalDeviceRobustness2FeaturesEXT();
-    ~safe_VkPhysicalDeviceRobustness2FeaturesEXT();
-    void initialize(const VkPhysicalDeviceRobustness2FeaturesEXT* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPhysicalDeviceRobustness2FeaturesEXT* copy_src, PNextCopyState* copy_state = {});
-    VkPhysicalDeviceRobustness2FeaturesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesEXT*>(this); }
-    VkPhysicalDeviceRobustness2FeaturesEXT const* ptr() const {
-        return reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesEXT const*>(this);
-    }
-};
-struct safe_VkPhysicalDeviceRobustness2PropertiesEXT {
-    VkStructureType sType;
-    void* pNext{};
-    VkDeviceSize robustStorageBufferAccessSizeAlignment;
-    VkDeviceSize robustUniformBufferAccessSizeAlignment;
-
-    safe_VkPhysicalDeviceRobustness2PropertiesEXT(const VkPhysicalDeviceRobustness2PropertiesEXT* in_struct,
-                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
-    safe_VkPhysicalDeviceRobustness2PropertiesEXT(const safe_VkPhysicalDeviceRobustness2PropertiesEXT& copy_src);
-    safe_VkPhysicalDeviceRobustness2PropertiesEXT& operator=(const safe_VkPhysicalDeviceRobustness2PropertiesEXT& copy_src);
-    safe_VkPhysicalDeviceRobustness2PropertiesEXT();
-    ~safe_VkPhysicalDeviceRobustness2PropertiesEXT();
-    void initialize(const VkPhysicalDeviceRobustness2PropertiesEXT* in_struct, PNextCopyState* copy_state = {});
-    void initialize(const safe_VkPhysicalDeviceRobustness2PropertiesEXT* copy_src, PNextCopyState* copy_state = {});
-    VkPhysicalDeviceRobustness2PropertiesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesEXT*>(this); }
-    VkPhysicalDeviceRobustness2PropertiesEXT const* ptr() const {
-        return reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesEXT const*>(this);
-    }
-};
 struct safe_VkSamplerCustomBorderColorCreateInfoEXT {
     VkStructureType sType;
     const void* pNext{};
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index 9894cbc..d17118f 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -511,6 +511,8 @@ template <> inline VkStructureType GetSType<VkVideoDecodeH264InlineSessionParame
 template <> inline VkStructureType GetSType<VkVideoDecodeH265InlineSessionParametersInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkVideoDecodeAV1InlineSessionParametersInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceDepthClampZeroOneFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceRobustness2FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceRobustness2PropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR; }
 template <> inline VkStructureType GetSType<VkDebugReportCallbackCreateInfoEXT>() { return VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkPipelineRasterizationStateRasterizationOrderAMD>() { return VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD; }
 template <> inline VkStructureType GetSType<VkDebugMarkerObjectNameInfoEXT>() { return VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT; }
@@ -734,8 +736,6 @@ template <> inline VkStructureType GetSType<VkDepthBiasRepresentationInfoEXT>()
 template <> inline VkStructureType GetSType<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkDeviceMemoryReportCallbackDataEXT>() { return VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT; }
 template <> inline VkStructureType GetSType<VkDeviceDeviceMemoryReportCreateInfoEXT>() { return VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceRobustness2FeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT; }
-template <> inline VkStructureType GetSType<VkPhysicalDeviceRobustness2PropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT; }
 template <> inline VkStructureType GetSType<VkSamplerCustomBorderColorCreateInfoEXT>() { return VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCustomBorderColorPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCustomBorderColorFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index 5b1e584..ad7c9a3 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -1362,10 +1362,6 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT";
         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT:
             return "VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT";
         case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
             return "VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
@@ -2156,6 +2152,10 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR";
 #ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV:
             return "VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV";
diff --git a/scripts/known_good.json b/scripts/known_good.json
index dcd6555..63dbffc 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.4.313"
+            "commit": "v1.4.314"
         },
         {
             "name": "googletest",
diff --git a/src/vulkan/vk_safe_struct_ext.cpp b/src/vulkan/vk_safe_struct_ext.cpp
index 8ae56bc..83c9296 100644
--- a/src/vulkan/vk_safe_struct_ext.cpp
+++ b/src/vulkan/vk_safe_struct_ext.cpp
@@ -6776,126 +6776,6 @@ void safe_VkDeviceDeviceMemoryReportCreateInfoEXT::initialize(const safe_VkDevic
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
-safe_VkPhysicalDeviceRobustness2FeaturesEXT::safe_VkPhysicalDeviceRobustness2FeaturesEXT(
-    const VkPhysicalDeviceRobustness2FeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType),
-      robustBufferAccess2(in_struct->robustBufferAccess2),
-      robustImageAccess2(in_struct->robustImageAccess2),
-      nullDescriptor(in_struct->nullDescriptor) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkPhysicalDeviceRobustness2FeaturesEXT::safe_VkPhysicalDeviceRobustness2FeaturesEXT()
-    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT),
-      pNext(nullptr),
-      robustBufferAccess2(),
-      robustImageAccess2(),
-      nullDescriptor() {}
-
-safe_VkPhysicalDeviceRobustness2FeaturesEXT::safe_VkPhysicalDeviceRobustness2FeaturesEXT(
-    const safe_VkPhysicalDeviceRobustness2FeaturesEXT& copy_src) {
-    sType = copy_src.sType;
-    robustBufferAccess2 = copy_src.robustBufferAccess2;
-    robustImageAccess2 = copy_src.robustImageAccess2;
-    nullDescriptor = copy_src.nullDescriptor;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPhysicalDeviceRobustness2FeaturesEXT& safe_VkPhysicalDeviceRobustness2FeaturesEXT::operator=(
-    const safe_VkPhysicalDeviceRobustness2FeaturesEXT& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    robustBufferAccess2 = copy_src.robustBufferAccess2;
-    robustImageAccess2 = copy_src.robustImageAccess2;
-    nullDescriptor = copy_src.nullDescriptor;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkPhysicalDeviceRobustness2FeaturesEXT::~safe_VkPhysicalDeviceRobustness2FeaturesEXT() { FreePnextChain(pNext); }
-
-void safe_VkPhysicalDeviceRobustness2FeaturesEXT::initialize(const VkPhysicalDeviceRobustness2FeaturesEXT* in_struct,
-                                                             [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    robustBufferAccess2 = in_struct->robustBufferAccess2;
-    robustImageAccess2 = in_struct->robustImageAccess2;
-    nullDescriptor = in_struct->nullDescriptor;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPhysicalDeviceRobustness2FeaturesEXT::initialize(const safe_VkPhysicalDeviceRobustness2FeaturesEXT* copy_src,
-                                                             [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    robustBufferAccess2 = copy_src->robustBufferAccess2;
-    robustImageAccess2 = copy_src->robustImageAccess2;
-    nullDescriptor = copy_src->nullDescriptor;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
-safe_VkPhysicalDeviceRobustness2PropertiesEXT::safe_VkPhysicalDeviceRobustness2PropertiesEXT(
-    const VkPhysicalDeviceRobustness2PropertiesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
-    : sType(in_struct->sType),
-      robustStorageBufferAccessSizeAlignment(in_struct->robustStorageBufferAccessSizeAlignment),
-      robustUniformBufferAccessSizeAlignment(in_struct->robustUniformBufferAccessSizeAlignment) {
-    if (copy_pnext) {
-        pNext = SafePnextCopy(in_struct->pNext, copy_state);
-    }
-}
-
-safe_VkPhysicalDeviceRobustness2PropertiesEXT::safe_VkPhysicalDeviceRobustness2PropertiesEXT()
-    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT),
-      pNext(nullptr),
-      robustStorageBufferAccessSizeAlignment(),
-      robustUniformBufferAccessSizeAlignment() {}
-
-safe_VkPhysicalDeviceRobustness2PropertiesEXT::safe_VkPhysicalDeviceRobustness2PropertiesEXT(
-    const safe_VkPhysicalDeviceRobustness2PropertiesEXT& copy_src) {
-    sType = copy_src.sType;
-    robustStorageBufferAccessSizeAlignment = copy_src.robustStorageBufferAccessSizeAlignment;
-    robustUniformBufferAccessSizeAlignment = copy_src.robustUniformBufferAccessSizeAlignment;
-    pNext = SafePnextCopy(copy_src.pNext);
-}
-
-safe_VkPhysicalDeviceRobustness2PropertiesEXT& safe_VkPhysicalDeviceRobustness2PropertiesEXT::operator=(
-    const safe_VkPhysicalDeviceRobustness2PropertiesEXT& copy_src) {
-    if (&copy_src == this) return *this;
-
-    FreePnextChain(pNext);
-
-    sType = copy_src.sType;
-    robustStorageBufferAccessSizeAlignment = copy_src.robustStorageBufferAccessSizeAlignment;
-    robustUniformBufferAccessSizeAlignment = copy_src.robustUniformBufferAccessSizeAlignment;
-    pNext = SafePnextCopy(copy_src.pNext);
-
-    return *this;
-}
-
-safe_VkPhysicalDeviceRobustness2PropertiesEXT::~safe_VkPhysicalDeviceRobustness2PropertiesEXT() { FreePnextChain(pNext); }
-
-void safe_VkPhysicalDeviceRobustness2PropertiesEXT::initialize(const VkPhysicalDeviceRobustness2PropertiesEXT* in_struct,
-                                                               [[maybe_unused]] PNextCopyState* copy_state) {
-    FreePnextChain(pNext);
-    sType = in_struct->sType;
-    robustStorageBufferAccessSizeAlignment = in_struct->robustStorageBufferAccessSizeAlignment;
-    robustUniformBufferAccessSizeAlignment = in_struct->robustUniformBufferAccessSizeAlignment;
-    pNext = SafePnextCopy(in_struct->pNext, copy_state);
-}
-
-void safe_VkPhysicalDeviceRobustness2PropertiesEXT::initialize(const safe_VkPhysicalDeviceRobustness2PropertiesEXT* copy_src,
-                                                               [[maybe_unused]] PNextCopyState* copy_state) {
-    sType = copy_src->sType;
-    robustStorageBufferAccessSizeAlignment = copy_src->robustStorageBufferAccessSizeAlignment;
-    robustUniformBufferAccessSizeAlignment = copy_src->robustUniformBufferAccessSizeAlignment;
-    pNext = SafePnextCopy(copy_src->pNext);
-}
-
 safe_VkSamplerCustomBorderColorCreateInfoEXT::safe_VkSamplerCustomBorderColorCreateInfoEXT(
     const VkSamplerCustomBorderColorCreateInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType), customBorderColor(in_struct->customBorderColor), format(in_struct->format) {
diff --git a/src/vulkan/vk_safe_struct_khr.cpp b/src/vulkan/vk_safe_struct_khr.cpp
index 2ad1936..777704f 100644
--- a/src/vulkan/vk_safe_struct_khr.cpp
+++ b/src/vulkan/vk_safe_struct_khr.cpp
@@ -15235,6 +15235,126 @@ void safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR::initialize(
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkPhysicalDeviceRobustness2FeaturesKHR::safe_VkPhysicalDeviceRobustness2FeaturesKHR(
+    const VkPhysicalDeviceRobustness2FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      robustBufferAccess2(in_struct->robustBufferAccess2),
+      robustImageAccess2(in_struct->robustImageAccess2),
+      nullDescriptor(in_struct->nullDescriptor) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceRobustness2FeaturesKHR::safe_VkPhysicalDeviceRobustness2FeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR),
+      pNext(nullptr),
+      robustBufferAccess2(),
+      robustImageAccess2(),
+      nullDescriptor() {}
+
+safe_VkPhysicalDeviceRobustness2FeaturesKHR::safe_VkPhysicalDeviceRobustness2FeaturesKHR(
+    const safe_VkPhysicalDeviceRobustness2FeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    robustBufferAccess2 = copy_src.robustBufferAccess2;
+    robustImageAccess2 = copy_src.robustImageAccess2;
+    nullDescriptor = copy_src.nullDescriptor;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceRobustness2FeaturesKHR& safe_VkPhysicalDeviceRobustness2FeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceRobustness2FeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    robustBufferAccess2 = copy_src.robustBufferAccess2;
+    robustImageAccess2 = copy_src.robustImageAccess2;
+    nullDescriptor = copy_src.nullDescriptor;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceRobustness2FeaturesKHR::~safe_VkPhysicalDeviceRobustness2FeaturesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceRobustness2FeaturesKHR::initialize(const VkPhysicalDeviceRobustness2FeaturesKHR* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    robustBufferAccess2 = in_struct->robustBufferAccess2;
+    robustImageAccess2 = in_struct->robustImageAccess2;
+    nullDescriptor = in_struct->nullDescriptor;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceRobustness2FeaturesKHR::initialize(const safe_VkPhysicalDeviceRobustness2FeaturesKHR* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    robustBufferAccess2 = copy_src->robustBufferAccess2;
+    robustImageAccess2 = copy_src->robustImageAccess2;
+    nullDescriptor = copy_src->nullDescriptor;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceRobustness2PropertiesKHR::safe_VkPhysicalDeviceRobustness2PropertiesKHR(
+    const VkPhysicalDeviceRobustness2PropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      robustStorageBufferAccessSizeAlignment(in_struct->robustStorageBufferAccessSizeAlignment),
+      robustUniformBufferAccessSizeAlignment(in_struct->robustUniformBufferAccessSizeAlignment) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceRobustness2PropertiesKHR::safe_VkPhysicalDeviceRobustness2PropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR),
+      pNext(nullptr),
+      robustStorageBufferAccessSizeAlignment(),
+      robustUniformBufferAccessSizeAlignment() {}
+
+safe_VkPhysicalDeviceRobustness2PropertiesKHR::safe_VkPhysicalDeviceRobustness2PropertiesKHR(
+    const safe_VkPhysicalDeviceRobustness2PropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    robustStorageBufferAccessSizeAlignment = copy_src.robustStorageBufferAccessSizeAlignment;
+    robustUniformBufferAccessSizeAlignment = copy_src.robustUniformBufferAccessSizeAlignment;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceRobustness2PropertiesKHR& safe_VkPhysicalDeviceRobustness2PropertiesKHR::operator=(
+    const safe_VkPhysicalDeviceRobustness2PropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    robustStorageBufferAccessSizeAlignment = copy_src.robustStorageBufferAccessSizeAlignment;
+    robustUniformBufferAccessSizeAlignment = copy_src.robustUniformBufferAccessSizeAlignment;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceRobustness2PropertiesKHR::~safe_VkPhysicalDeviceRobustness2PropertiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceRobustness2PropertiesKHR::initialize(const VkPhysicalDeviceRobustness2PropertiesKHR* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    robustStorageBufferAccessSizeAlignment = in_struct->robustStorageBufferAccessSizeAlignment;
+    robustUniformBufferAccessSizeAlignment = in_struct->robustUniformBufferAccessSizeAlignment;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceRobustness2PropertiesKHR::initialize(const safe_VkPhysicalDeviceRobustness2PropertiesKHR* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    robustStorageBufferAccessSizeAlignment = copy_src->robustStorageBufferAccessSizeAlignment;
+    robustUniformBufferAccessSizeAlignment = copy_src->robustUniformBufferAccessSizeAlignment;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkDeviceOrHostAddressConstKHR::safe_VkDeviceOrHostAddressConstKHR(const VkDeviceOrHostAddressConstKHR* in_struct,
                                                                        PNextCopyState*) {
     initialize(in_struct);
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index d71352f..f0fb734 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -911,6 +911,12 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR:
                 safe_pNext = new safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceRobustness2FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceRobustness2PropertiesKHR(reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesKHR *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
                 safe_pNext = new safe_VkDebugReportCallbackCreateInfoEXT(reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>(pNext), copy_state, false);
                 break;
@@ -1353,12 +1359,6 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
                 safe_pNext = new safe_VkDeviceDeviceMemoryReportCreateInfoEXT(reinterpret_cast<const VkDeviceDeviceMemoryReportCreateInfoEXT *>(pNext), copy_state, false);
                 break;
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
-                safe_pNext = new safe_VkPhysicalDeviceRobustness2FeaturesEXT(reinterpret_cast<const VkPhysicalDeviceRobustness2FeaturesEXT *>(pNext), copy_state, false);
-                break;
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
-                safe_pNext = new safe_VkPhysicalDeviceRobustness2PropertiesEXT(reinterpret_cast<const VkPhysicalDeviceRobustness2PropertiesEXT *>(pNext), copy_state, false);
-                break;
             case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
                 safe_pNext = new safe_VkSamplerCustomBorderColorCreateInfoEXT(reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT *>(pNext), copy_state, false);
                 break;
@@ -2995,6 +2995,12 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR:
             delete reinterpret_cast<safe_VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR:
+            delete reinterpret_cast<safe_VkPhysicalDeviceRobustness2FeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR:
+            delete reinterpret_cast<safe_VkPhysicalDeviceRobustness2PropertiesKHR *>(header);
+            break;
         case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
             delete reinterpret_cast<safe_VkDebugReportCallbackCreateInfoEXT *>(header);
             break;
@@ -3437,12 +3443,6 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
             delete reinterpret_cast<safe_VkDeviceDeviceMemoryReportCreateInfoEXT *>(header);
             break;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT:
-            delete reinterpret_cast<safe_VkPhysicalDeviceRobustness2FeaturesEXT *>(header);
-            break;
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT:
-            delete reinterpret_cast<safe_VkPhysicalDeviceRobustness2PropertiesEXT *>(header);
-            break;
         case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
             delete reinterpret_cast<safe_VkSamplerCustomBorderColorCreateInfoEXT *>(header);
             break;

From 4f628210460c4df62029959cc7fb237ac75f7189 Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Fri, 9 May 2025 08:07:50 -0700
Subject: [PATCH 102/106] build: Update to header 1.4.315

---
 include/vulkan/utility/vk_safe_struct.hpp   | 23 +++++++++
 include/vulkan/utility/vk_struct_helper.hpp |  1 +
 include/vulkan/vk_enum_string_helper.h      | 16 +++++--
 scripts/known_good.json                     |  2 +-
 src/vulkan/vk_safe_struct_ext.cpp           | 53 +++++++++++++++++++++
 src/vulkan/vk_safe_struct_utils.cpp         |  6 +++
 6 files changed, 95 insertions(+), 6 deletions(-)

diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index ab7f77a..1092242 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -20643,6 +20643,29 @@ struct safe_VkRenderingEndInfoEXT {
     VkRenderingEndInfoEXT* ptr() { return reinterpret_cast<VkRenderingEndInfoEXT*>(this); }
     VkRenderingEndInfoEXT const* ptr() const { return reinterpret_cast<VkRenderingEndInfoEXT const*>(this); }
 };
+struct safe_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 zeroInitializeDeviceMemory;
+
+    safe_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT(
+        const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT* in_struct, PNextCopyState* copy_state = {},
+        bool copy_pnext = true);
+    safe_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT(
+        const safe_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT& operator=(
+        const safe_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT();
+    ~safe_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT();
+    void initialize(const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT*>(this);
+    }
+    VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const*>(this);
+    }
+};
 struct safe_VkAccelerationStructureGeometryTrianglesDataKHR {
     VkStructureType sType;
     const void* pNext{};
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index d17118f..1c77fba 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -1074,6 +1074,7 @@ template <> inline VkStructureType GetSType<VkSetPresentConfigNV>() { return VK_
 template <> inline VkStructureType GetSType<VkPhysicalDevicePresentMeteringFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV; }
 #endif  // VK_ENABLE_BETA_EXTENSIONS
 template <> inline VkStructureType GetSType<VkRenderingEndInfoEXT>() { return VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryTrianglesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryAabbsDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR; }
 template <> inline VkStructureType GetSType<VkAccelerationStructureGeometryInstancesDataKHR>() { return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index ad7c9a3..99deb87 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -2170,6 +2170,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT";
         case VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT:
             return "VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT";
         default:
             return "Unhandled VkStructureType";
     }
@@ -2244,6 +2246,8 @@ static inline const char* string_VkImageLayout(VkImageLayout input_value) {
             return "VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT";
         case VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR:
             return "VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR";
+        case VK_IMAGE_LAYOUT_ZERO_INITIALIZED_EXT:
+            return "VK_IMAGE_LAYOUT_ZERO_INITIALIZED_EXT";
         default:
             return "Unhandled VkImageLayout";
     }
@@ -5654,8 +5658,8 @@ static inline const char* string_VkImageUsageFlagBits(VkImageUsageFlagBits input
             return "VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM";
         case VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM:
             return "VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM";
-        case VK_IMAGE_USAGE_TILE_MEMORY_QCOM:
-            return "VK_IMAGE_USAGE_TILE_MEMORY_QCOM";
+        case VK_IMAGE_USAGE_TILE_MEMORY_BIT_QCOM:
+            return "VK_IMAGE_USAGE_TILE_MEMORY_BIT_QCOM";
         case VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR:
             return "VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR";
         case VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR:
@@ -6223,8 +6227,8 @@ static inline const char* string_VkBufferUsageFlagBits(VkBufferUsageFlagBits inp
             return "VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT";
         case VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT:
             return "VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT";
-        case VK_BUFFER_USAGE_TILE_MEMORY_QCOM:
-            return "VK_BUFFER_USAGE_TILE_MEMORY_QCOM";
+        case VK_BUFFER_USAGE_TILE_MEMORY_BIT_QCOM:
+            return "VK_BUFFER_USAGE_TILE_MEMORY_BIT_QCOM";
         default:
             return "Unhandled VkBufferUsageFlagBits";
     }
@@ -7108,6 +7112,8 @@ static inline const char* string_VkMemoryAllocateFlagBits(VkMemoryAllocateFlagBi
             return "VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT";
         case VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT:
             return "VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT";
+        case VK_MEMORY_ALLOCATE_ZERO_INITIALIZE_BIT_EXT:
+            return "VK_MEMORY_ALLOCATE_ZERO_INITIALIZE_BIT_EXT";
         default:
             return "Unhandled VkMemoryAllocateFlagBits";
     }
@@ -7907,7 +7913,7 @@ static inline const char* string_VkBufferUsageFlagBits2(uint64_t input_value) {
     if (input_value == VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT";
     if (input_value == VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT) return "VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT";
     if (input_value == VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT) return "VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT";
-    if (input_value == VK_BUFFER_USAGE_2_TILE_MEMORY_QCOM) return "VK_BUFFER_USAGE_2_TILE_MEMORY_QCOM";
+    if (input_value == VK_BUFFER_USAGE_2_TILE_MEMORY_BIT_QCOM) return "VK_BUFFER_USAGE_2_TILE_MEMORY_BIT_QCOM";
     if (input_value == VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT) return "VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT";
     return "Unhandled VkBufferUsageFlagBits2";
 }
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 63dbffc..258ff02 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.4.314"
+            "commit": "v1.4.315"
         },
         {
             "name": "googletest",
diff --git a/src/vulkan/vk_safe_struct_ext.cpp b/src/vulkan/vk_safe_struct_ext.cpp
index 83c9296..3289616 100644
--- a/src/vulkan/vk_safe_struct_ext.cpp
+++ b/src/vulkan/vk_safe_struct_ext.cpp
@@ -15817,6 +15817,59 @@ void safe_VkRenderingEndInfoEXT::initialize(const safe_VkRenderingEndInfoEXT* co
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT::safe_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT(
+    const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), zeroInitializeDeviceMemory(in_struct->zeroInitializeDeviceMemory) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT::safe_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT),
+      pNext(nullptr),
+      zeroInitializeDeviceMemory() {}
+
+safe_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT::safe_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT(
+    const safe_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    zeroInitializeDeviceMemory = copy_src.zeroInitializeDeviceMemory;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT& safe_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    zeroInitializeDeviceMemory = copy_src.zeroInitializeDeviceMemory;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT::~safe_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT::initialize(
+    const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    zeroInitializeDeviceMemory = in_struct->zeroInitializeDeviceMemory;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT::initialize(
+    const safe_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    zeroInitializeDeviceMemory = copy_src->zeroInitializeDeviceMemory;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkPhysicalDeviceMeshShaderFeaturesEXT::safe_VkPhysicalDeviceMeshShaderFeaturesEXT(
     const VkPhysicalDeviceMeshShaderFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType),
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index f0fb734..095c758 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -2068,6 +2068,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
                 safe_pNext = new safe_VkPhysicalDevicePresentMeteringFeaturesNV(reinterpret_cast<const VkPhysicalDevicePresentMeteringFeaturesNV *>(pNext), copy_state, false);
                 break;
 #endif  // VK_ENABLE_BETA_EXTENSIONS
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
                 safe_pNext = new safe_VkWriteDescriptorSetAccelerationStructureKHR(reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureKHR *>(pNext), copy_state, false);
                 break;
@@ -4152,6 +4155,9 @@ void FreePnextChain(const void *pNext) {
             delete reinterpret_cast<safe_VkPhysicalDevicePresentMeteringFeaturesNV *>(header);
             break;
 #endif  // VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT:
+            delete reinterpret_cast<safe_VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *>(header);
+            break;
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
             delete reinterpret_cast<safe_VkWriteDescriptorSetAccelerationStructureKHR *>(header);
             break;

From ae56bd6e65d9faa731150e931cb35f0d895223bc Mon Sep 17 00:00:00 2001
From: spencer-lunarg <spencer@lunarg.com>
Date: Thu, 22 May 2025 08:41:19 -0400
Subject: [PATCH 103/106] formats: Remove old format utils

---
 include/vulkan/utility/vk_format_utils.h     | 53 --------------------
 scripts/generators/format_utils_generator.py | 53 --------------------
 tests/test_formats.cpp                       | 24 ---------
 3 files changed, 130 deletions(-)

diff --git a/include/vulkan/utility/vk_format_utils.h b/include/vulkan/utility/vk_format_utils.h
index 0bdefc5..6b5e776 100644
--- a/include/vulkan/utility/vk_format_utils.h
+++ b/include/vulkan/utility/vk_format_utils.h
@@ -283,24 +283,6 @@ inline uint32_t vkuFormatTexelsPerBlock(VkFormat format);
 // When dealing with mulit-planar formats, need to consider using vkuGetPlaneIndex.
 inline uint32_t vkuFormatTexelBlockSize(VkFormat format);
 
-// Return size, in bytes, of one element of a VkFormat
-// Format must not be a depth, stencil, or multiplane format
-// Deprecated - Use vkuFormatTexelBlockSize - there is no "element" size in the spec
-inline uint32_t vkuFormatElementSize(VkFormat format);
-
-// Return the size in bytes of one texel of a VkFormat
-// For compressed or multi-plane, this may be a fractional number
-// Deprecated - Use vkuFormatTexelBlockSize - there is no "element" size in the spec
-inline uint32_t vkuFormatElementSizeWithAspect(VkFormat format, VkImageAspectFlagBits aspectMask);
-
-// Return the size in bytes of one texel of a VkFormat
-// Format must not be a depth, stencil, or multiplane format
-inline double vkuFormatTexelSize(VkFormat format);
-
-// Return the size in bytes of one texel of a VkFormat
-// For compressed or multi-plane, this may be a fractional number
-inline double vkuFormatTexelSizeWithAspect(VkFormat format, VkImageAspectFlagBits aspectMask);
-
 // Returns whether a VkFormat contains only 8-bit sized components
 inline bool vkuFormatIs8bit(VkFormat format);
 
@@ -1591,41 +1573,6 @@ inline uint32_t vkuFormatTexelsPerBlock(VkFormat format) { return vkuGetFormatIn
 
 inline uint32_t vkuFormatTexelBlockSize(VkFormat format) { return vkuGetFormatInfo(format).texel_block_size; }
 
-// Deprecated - Use vkuFormatTexelBlockSize
-inline uint32_t vkuFormatElementSize(VkFormat format) {
-    return vkuFormatElementSizeWithAspect(format, VK_IMAGE_ASPECT_COLOR_BIT);
-}
-
-// Deprecated - Use vkuFormatTexelBlockSize
-inline uint32_t vkuFormatElementSizeWithAspect(VkFormat format, VkImageAspectFlagBits aspectMask) {
-    // Depth/Stencil aspect have separate helper functions
-    if (aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) {
-        return vkuFormatStencilSize(format) / 8;
-    } else if (aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) {
-        return vkuFormatDepthSize(format) / 8;
-    } else if (vkuFormatIsMultiplane(format)) {
-        // Element of entire multiplane format is not useful,
-        // Want to get just a single plane as the lookup format
-        format = vkuFindMultiplaneCompatibleFormat(format, aspectMask);
-    }
-
-    return vkuGetFormatInfo(format).texel_block_size;
-}
-
-inline double vkuFormatTexelSize(VkFormat format) {
-    return vkuFormatTexelSizeWithAspect(format, VK_IMAGE_ASPECT_COLOR_BIT);
-}
-
-inline double vkuFormatTexelSizeWithAspect(VkFormat format, VkImageAspectFlagBits aspectMask) {
-    double texel_size = (double)(vkuFormatElementSizeWithAspect(format, aspectMask));
-    VkExtent3D block_extent = vkuFormatTexelBlockExtent(format);
-    uint32_t texels_per_block = block_extent.width * block_extent.height * block_extent.depth;
-    if (1 < texels_per_block) {
-        texel_size /= (double)(texels_per_block);
-    }
-    return texel_size;
-}
-
 inline bool vkuFormatIs8bit(VkFormat format) {
     switch (format) {
         case VK_FORMAT_A8_UNORM:
diff --git a/scripts/generators/format_utils_generator.py b/scripts/generators/format_utils_generator.py
index c11b833..8b4b65c 100644
--- a/scripts/generators/format_utils_generator.py
+++ b/scripts/generators/format_utils_generator.py
@@ -236,24 +236,6 @@ inline uint32_t vkuFormatTexelsPerBlock(VkFormat format);
 // When dealing with mulit-planar formats, need to consider using vkuGetPlaneIndex.
 inline uint32_t vkuFormatTexelBlockSize(VkFormat format);
 
-// Return size, in bytes, of one element of a VkFormat
-// Format must not be a depth, stencil, or multiplane format
-// Deprecated - Use vkuFormatTexelBlockSize - there is no "element" size in the spec
-inline uint32_t vkuFormatElementSize(VkFormat format);
-
-// Return the size in bytes of one texel of a VkFormat
-// For compressed or multi-plane, this may be a fractional number
-// Deprecated - Use vkuFormatTexelBlockSize - there is no "element" size in the spec
-inline uint32_t vkuFormatElementSizeWithAspect(VkFormat format, VkImageAspectFlagBits aspectMask);
-
-// Return the size in bytes of one texel of a VkFormat
-// Format must not be a depth, stencil, or multiplane format
-inline double vkuFormatTexelSize(VkFormat format);
-
-// Return the size in bytes of one texel of a VkFormat
-// For compressed or multi-plane, this may be a fractional number
-inline double vkuFormatTexelSizeWithAspect(VkFormat format, VkImageAspectFlagBits aspectMask);
-
 ''')
         for bits in ['8', '16', '32', '64']:
             out.append(f'// Returns whether a VkFormat contains only {bits}-bit sized components\n')
@@ -643,41 +625,6 @@ inline uint32_t vkuFormatTexelsPerBlock(VkFormat format) { return vkuGetFormatIn
 
 inline uint32_t vkuFormatTexelBlockSize(VkFormat format) { return vkuGetFormatInfo(format).texel_block_size; }
 
-// Deprecated - Use vkuFormatTexelBlockSize
-inline uint32_t vkuFormatElementSize(VkFormat format) {
-    return vkuFormatElementSizeWithAspect(format, VK_IMAGE_ASPECT_COLOR_BIT);
-}
-
-// Deprecated - Use vkuFormatTexelBlockSize
-inline uint32_t vkuFormatElementSizeWithAspect(VkFormat format, VkImageAspectFlagBits aspectMask) {
-    // Depth/Stencil aspect have separate helper functions
-    if (aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) {
-        return vkuFormatStencilSize(format) / 8;
-    } else if (aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) {
-        return vkuFormatDepthSize(format) / 8;
-    } else if (vkuFormatIsMultiplane(format)) {
-        // Element of entire multiplane format is not useful,
-        // Want to get just a single plane as the lookup format
-        format = vkuFindMultiplaneCompatibleFormat(format, aspectMask);
-    }
-
-    return vkuGetFormatInfo(format).texel_block_size;
-}
-
-inline double vkuFormatTexelSize(VkFormat format) {
-    return vkuFormatTexelSizeWithAspect(format, VK_IMAGE_ASPECT_COLOR_BIT);
-}
-
-inline double vkuFormatTexelSizeWithAspect(VkFormat format, VkImageAspectFlagBits aspectMask) {
-    double texel_size = (double)(vkuFormatElementSizeWithAspect(format, aspectMask));
-    VkExtent3D block_extent = vkuFormatTexelBlockExtent(format);
-    uint32_t texels_per_block = block_extent.width * block_extent.height * block_extent.depth;
-    if (1 < texels_per_block) {
-        texel_size /= (double)(texels_per_block);
-    }
-    return texel_size;
-}
-
 ''')
         # Could loop the components, but faster to just list these
         for bits in ['8', '16', '32', '64']:
diff --git a/tests/test_formats.cpp b/tests/test_formats.cpp
index 7fa66d1..cf3d1e0 100644
--- a/tests/test_formats.cpp
+++ b/tests/test_formats.cpp
@@ -546,30 +546,6 @@ TEST(format_utils, vkuFormatTexelBlockSize) {
     EXPECT_EQ(vkuFormatTexelBlockSize(VK_FORMAT_S8_UINT), 1u);
 }
 
-TEST(format_utils, vkuFormatTexelSizeWithAspect) {
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_R64G64_SFLOAT, VK_IMAGE_ASPECT_NONE), 16);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_R64G64_SFLOAT, VK_IMAGE_ASPECT_STENCIL_BIT), 0);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_R64G64_SFLOAT, VK_IMAGE_ASPECT_DEPTH_BIT), 0);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_NONE), 16. / 20.);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_STENCIL_BIT), 0);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_IMAGE_ASPECT_DEPTH_BIT), 0);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_NONE), 0);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_PLANE_0_BIT), 2);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_PLANE_1_BIT), 2);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_PLANE_2_BIT), 2);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_STENCIL_BIT), 0);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_STENCIL_BIT), 0);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_IMAGE_ASPECT_DEPTH_BIT), 0);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_D32_SFLOAT, VK_IMAGE_ASPECT_NONE), 4);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_D32_SFLOAT, VK_IMAGE_ASPECT_STENCIL_BIT), 0);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_D32_SFLOAT, VK_IMAGE_ASPECT_DEPTH_BIT), 4);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_D32_SFLOAT_S8_UINT, VK_IMAGE_ASPECT_NONE), 5);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_D32_SFLOAT_S8_UINT, VK_IMAGE_ASPECT_STENCIL_BIT), 1);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_D32_SFLOAT_S8_UINT, VK_IMAGE_ASPECT_DEPTH_BIT), 4);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_S8_UINT, VK_IMAGE_ASPECT_NONE), 1);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_S8_UINT, VK_IMAGE_ASPECT_STENCIL_BIT), 1);
-    EXPECT_EQ(vkuFormatTexelSizeWithAspect(VK_FORMAT_S8_UINT, VK_IMAGE_ASPECT_DEPTH_BIT), 0);
-}
 TEST(format_utils, vkuFormatIs64bit) {
     for (auto [format, format_str] : magic_enum::enum_entries<VkFormat>()) {
         if (std::string::npos != format_str.find("R64")) {

From 49ac28931f28bffaa3cd73dc4ad997284d574962 Mon Sep 17 00:00:00 2001
From: spencer-lunarg <spencer@lunarg.com>
Date: Sun, 25 May 2025 22:52:05 -0400
Subject: [PATCH 104/106] enums: Add C Name helper for VkStructureType

---
 include/vulkan/vk_enum_string_helper.h        | 2112 ++++++++++++++++-
 .../enum_string_helper_generator.py           |   29 +-
 2 files changed, 2132 insertions(+), 9 deletions(-)

diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index 99deb87..680f218 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -1,8 +1,8 @@
 // *** THIS FILE IS GENERATED - DO NOT EDIT ***
 // See enum_string_helper_generator.py for modifications
-// Copyright 2023 The Khronos Group Inc.
-// Copyright 2023 Valve Corporation
-// Copyright 2023 LunarG, Inc.
+// Copyright 2023-2025 The Khronos Group Inc.
+// Copyright 2023-2025 Valve Corporation
+// Copyright 2023-2025 LunarG, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
 
@@ -10359,3 +10359,2109 @@ static inline std::string string_VkAccelerationStructureCreateFlagsKHR(VkAcceler
 }
 #endif // __cplusplus
 // clang-format on
+
+// Same thing as string_VkStructureType, but prints out the API name
+static inline const char* string_VkStructureName(VkStructureType input_value) {
+    switch (input_value) {
+        case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
+            return "VkBufferMemoryBarrier";
+        case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
+            return "VkImageMemoryBarrier";
+        case VK_STRUCTURE_TYPE_MEMORY_BARRIER:
+            return "VkMemoryBarrier";
+        case VK_STRUCTURE_TYPE_APPLICATION_INFO:
+            return "VkApplicationInfo";
+        case VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO:
+            return "VkInstanceCreateInfo";
+        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO:
+            return "VkDeviceQueueCreateInfo";
+        case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
+            return "VkDeviceCreateInfo";
+        case VK_STRUCTURE_TYPE_SUBMIT_INFO:
+            return "VkSubmitInfo";
+        case VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE:
+            return "VkMappedMemoryRange";
+        case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:
+            return "VkMemoryAllocateInfo";
+        case VK_STRUCTURE_TYPE_BIND_SPARSE_INFO:
+            return "VkBindSparseInfo";
+        case VK_STRUCTURE_TYPE_FENCE_CREATE_INFO:
+            return "VkFenceCreateInfo";
+        case VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO:
+            return "VkSemaphoreCreateInfo";
+        case VK_STRUCTURE_TYPE_EVENT_CREATE_INFO:
+            return "VkEventCreateInfo";
+        case VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
+            return "VkQueryPoolCreateInfo";
+        case VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
+            return "VkBufferCreateInfo";
+        case VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
+            return "VkBufferViewCreateInfo";
+        case VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
+            return "VkImageCreateInfo";
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
+            return "VkImageViewCreateInfo";
+        case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:
+            return "VkShaderModuleCreateInfo";
+        case VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO:
+            return "VkPipelineCacheCreateInfo";
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
+            return "VkPipelineShaderStageCreateInfo";
+        case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
+            return "VkComputePipelineCreateInfo";
+        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO:
+            return "VkPipelineVertexInputStateCreateInfo";
+        case VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO:
+            return "VkPipelineInputAssemblyStateCreateInfo";
+        case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO:
+            return "VkPipelineTessellationStateCreateInfo";
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO:
+            return "VkPipelineViewportStateCreateInfo";
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO:
+            return "VkPipelineRasterizationStateCreateInfo";
+        case VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO:
+            return "VkPipelineMultisampleStateCreateInfo";
+        case VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO:
+            return "VkPipelineDepthStencilStateCreateInfo";
+        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO:
+            return "VkPipelineColorBlendStateCreateInfo";
+        case VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO:
+            return "VkPipelineDynamicStateCreateInfo";
+        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
+            return "VkGraphicsPipelineCreateInfo";
+        case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:
+            return "VkPipelineLayoutCreateInfo";
+        case VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
+            return "VkSamplerCreateInfo";
+        case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
+            return "VkCopyDescriptorSet";
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO:
+            return "VkDescriptorPoolCreateInfo";
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO:
+            return "VkDescriptorSetAllocateInfo";
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
+            return "VkDescriptorSetLayoutCreateInfo";
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
+            return "VkWriteDescriptorSet";
+        case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
+            return "VkFramebufferCreateInfo";
+        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
+            return "VkRenderPassCreateInfo";
+        case VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO:
+            return "VkCommandPoolCreateInfo";
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO:
+            return "VkCommandBufferAllocateInfo";
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO:
+            return "VkCommandBufferInheritanceInfo";
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO:
+            return "VkCommandBufferBeginInfo";
+        case VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO:
+            return "VkRenderPassBeginInfo";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
+            return "VkPhysicalDeviceSubgroupProperties";
+        case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO:
+            return "VkBindBufferMemoryInfo";
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO:
+            return "VkBindImageMemoryInfo";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
+            return "VkPhysicalDevice16BitStorageFeatures";
+        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
+            return "VkMemoryDedicatedRequirements";
+        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
+            return "VkMemoryDedicatedAllocateInfo";
+        case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
+            return "VkMemoryAllocateFlagsInfo";
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
+            return "VkDeviceGroupRenderPassBeginInfo";
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
+            return "VkDeviceGroupCommandBufferBeginInfo";
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
+            return "VkDeviceGroupSubmitInfo";
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
+            return "VkDeviceGroupBindSparseInfo";
+        case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
+            return "VkBindBufferMemoryDeviceGroupInfo";
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
+            return "VkBindImageMemoryDeviceGroupInfo";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES:
+            return "VkPhysicalDeviceGroupProperties";
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
+            return "VkDeviceGroupDeviceCreateInfo";
+        case VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2:
+            return "VkBufferMemoryRequirementsInfo2";
+        case VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2:
+            return "VkImageMemoryRequirementsInfo2";
+        case VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2:
+            return "VkImageSparseMemoryRequirementsInfo2";
+        case VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2:
+            return "VkMemoryRequirements2";
+        case VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2:
+            return "VkSparseImageMemoryRequirements2";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
+            return "VkPhysicalDeviceFeatures2";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2:
+            return "VkPhysicalDeviceProperties2";
+        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2:
+            return "VkFormatProperties2";
+        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2:
+            return "VkImageFormatProperties2";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2:
+            return "VkPhysicalDeviceImageFormatInfo2";
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2:
+            return "VkQueueFamilyProperties2";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2:
+            return "VkPhysicalDeviceMemoryProperties2";
+        case VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2:
+            return "VkSparseImageFormatProperties2";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2:
+            return "VkPhysicalDeviceSparseImageFormatInfo2";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
+            return "VkPhysicalDevicePointClippingProperties";
+        case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
+            return "VkRenderPassInputAttachmentAspectCreateInfo";
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
+            return "VkImageViewUsageCreateInfo";
+        case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
+            return "VkPipelineTessellationDomainOriginStateCreateInfo";
+        case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
+            return "VkRenderPassMultiviewCreateInfo";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
+            return "VkPhysicalDeviceMultiviewFeatures";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
+            return "VkPhysicalDeviceMultiviewProperties";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
+            return "VkPhysicalDeviceVariablePointersFeatures";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
+            return "VkPhysicalDeviceProtectedMemoryFeatures";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
+            return "VkPhysicalDeviceProtectedMemoryProperties";
+        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2:
+            return "VkDeviceQueueInfo2";
+        case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
+            return "VkProtectedSubmitInfo";
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO:
+            return "VkSamplerYcbcrConversionCreateInfo";
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
+            return "VkSamplerYcbcrConversionInfo";
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
+            return "VkBindImagePlaneMemoryInfo";
+        case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
+            return "VkImagePlaneMemoryRequirementsInfo";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
+            return "VkPhysicalDeviceSamplerYcbcrConversionFeatures";
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
+            return "VkSamplerYcbcrConversionImageFormatProperties";
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO:
+            return "VkDescriptorUpdateTemplateCreateInfo";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
+            return "VkPhysicalDeviceExternalImageFormatInfo";
+        case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
+            return "VkExternalImageFormatProperties";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO:
+            return "VkPhysicalDeviceExternalBufferInfo";
+        case VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES:
+            return "VkExternalBufferProperties";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
+            return "VkPhysicalDeviceIDProperties";
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
+            return "VkExternalMemoryImageCreateInfo";
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
+            return "VkExternalMemoryBufferCreateInfo";
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
+            return "VkExportMemoryAllocateInfo";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO:
+            return "VkPhysicalDeviceExternalFenceInfo";
+        case VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES:
+            return "VkExternalFenceProperties";
+        case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
+            return "VkExportFenceCreateInfo";
+        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
+            return "VkExportSemaphoreCreateInfo";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO:
+            return "VkPhysicalDeviceExternalSemaphoreInfo";
+        case VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES:
+            return "VkExternalSemaphoreProperties";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
+            return "VkPhysicalDeviceMaintenance3Properties";
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT:
+            return "VkDescriptorSetLayoutSupport";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
+            return "VkPhysicalDeviceShaderDrawParametersFeatures";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
+            return "VkPhysicalDeviceVulkan11Features";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES:
+            return "VkPhysicalDeviceVulkan11Properties";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
+            return "VkPhysicalDeviceVulkan12Features";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES:
+            return "VkPhysicalDeviceVulkan12Properties";
+        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
+            return "VkImageFormatListCreateInfo";
+        case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2:
+            return "VkAttachmentDescription2";
+        case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2:
+            return "VkAttachmentReference2";
+        case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2:
+            return "VkSubpassDescription2";
+        case VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2:
+            return "VkSubpassDependency2";
+        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2:
+            return "VkRenderPassCreateInfo2";
+        case VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO:
+            return "VkSubpassBeginInfo";
+        case VK_STRUCTURE_TYPE_SUBPASS_END_INFO:
+            return "VkSubpassEndInfo";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES:
+            return "VkPhysicalDevice8BitStorageFeatures";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES:
+            return "VkPhysicalDeviceDriverProperties";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
+            return "VkPhysicalDeviceShaderAtomicInt64Features";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
+            return "VkPhysicalDeviceShaderFloat16Int8Features";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
+            return "VkPhysicalDeviceFloatControlsProperties";
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
+            return "VkDescriptorSetLayoutBindingFlagsCreateInfo";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
+            return "VkPhysicalDeviceDescriptorIndexingFeatures";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES:
+            return "VkPhysicalDeviceDescriptorIndexingProperties";
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
+            return "VkDescriptorSetVariableDescriptorCountAllocateInfo";
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
+            return "VkDescriptorSetVariableDescriptorCountLayoutSupport";
+        case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE:
+            return "VkSubpassDescriptionDepthStencilResolve";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES:
+            return "VkPhysicalDeviceDepthStencilResolveProperties";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
+            return "VkPhysicalDeviceScalarBlockLayoutFeatures";
+        case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
+            return "VkImageStencilUsageCreateInfo";
+        case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
+            return "VkSamplerReductionModeCreateInfo";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES:
+            return "VkPhysicalDeviceSamplerFilterMinmaxProperties";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
+            return "VkPhysicalDeviceVulkanMemoryModelFeatures";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
+            return "VkPhysicalDeviceImagelessFramebufferFeatures";
+        case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO:
+            return "VkFramebufferAttachmentImageInfo";
+        case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
+            return "VkFramebufferAttachmentsCreateInfo";
+        case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
+            return "VkRenderPassAttachmentBeginInfo";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
+            return "VkPhysicalDeviceUniformBufferStandardLayoutFeatures";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES:
+            return "VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
+            return "VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures";
+        case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT:
+            return "VkAttachmentReferenceStencilLayout";
+        case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT:
+            return "VkAttachmentDescriptionStencilLayout";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
+            return "VkPhysicalDeviceHostQueryResetFeatures";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
+            return "VkPhysicalDeviceTimelineSemaphoreFeatures";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES:
+            return "VkPhysicalDeviceTimelineSemaphoreProperties";
+        case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
+            return "VkSemaphoreTypeCreateInfo";
+        case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO:
+            return "VkTimelineSemaphoreSubmitInfo";
+        case VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO:
+            return "VkSemaphoreWaitInfo";
+        case VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO:
+            return "VkSemaphoreSignalInfo";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
+            return "VkPhysicalDeviceBufferDeviceAddressFeatures";
+        case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO:
+            return "VkBufferDeviceAddressInfo";
+        case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
+            return "VkBufferOpaqueCaptureAddressCreateInfo";
+        case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO:
+            return "VkMemoryOpaqueCaptureAddressAllocateInfo";
+        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO:
+            return "VkDeviceMemoryOpaqueCaptureAddressInfo";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES:
+            return "VkPhysicalDeviceVulkan13Features";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES:
+            return "VkPhysicalDeviceVulkan13Properties";
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
+            return "VkPipelineCreationFeedbackCreateInfo";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES:
+            return "VkPhysicalDeviceShaderTerminateInvocationFeatures";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES:
+            return "VkPhysicalDeviceToolProperties";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES:
+            return "VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES:
+            return "VkPhysicalDevicePrivateDataFeatures";
+        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO:
+            return "VkDevicePrivateDataCreateInfo";
+        case VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO:
+            return "VkPrivateDataSlotCreateInfo";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES:
+            return "VkPhysicalDevicePipelineCreationCacheControlFeatures";
+        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2:
+            return "VkMemoryBarrier2";
+        case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2:
+            return "VkBufferMemoryBarrier2";
+        case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2:
+            return "VkImageMemoryBarrier2";
+        case VK_STRUCTURE_TYPE_DEPENDENCY_INFO:
+            return "VkDependencyInfo";
+        case VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO:
+            return "VkSemaphoreSubmitInfo";
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO:
+            return "VkCommandBufferSubmitInfo";
+        case VK_STRUCTURE_TYPE_SUBMIT_INFO_2:
+            return "VkSubmitInfo2";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES:
+            return "VkPhysicalDeviceSynchronization2Features";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES:
+            return "VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES:
+            return "VkPhysicalDeviceImageRobustnessFeatures";
+        case VK_STRUCTURE_TYPE_BUFFER_COPY_2:
+            return "VkBufferCopy2";
+        case VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2:
+            return "VkCopyBufferInfo2";
+        case VK_STRUCTURE_TYPE_IMAGE_COPY_2:
+            return "VkImageCopy2";
+        case VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2:
+            return "VkCopyImageInfo2";
+        case VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2:
+            return "VkBufferImageCopy2";
+        case VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2:
+            return "VkCopyBufferToImageInfo2";
+        case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2:
+            return "VkCopyImageToBufferInfo2";
+        case VK_STRUCTURE_TYPE_IMAGE_BLIT_2:
+            return "VkImageBlit2";
+        case VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2:
+            return "VkBlitImageInfo2";
+        case VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2:
+            return "VkImageResolve2";
+        case VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2:
+            return "VkResolveImageInfo2";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES:
+            return "VkPhysicalDeviceSubgroupSizeControlFeatures";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES:
+            return "VkPhysicalDeviceSubgroupSizeControlProperties";
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
+            return "VkPipelineShaderStageRequiredSubgroupSizeCreateInfo";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES:
+            return "VkPhysicalDeviceInlineUniformBlockFeatures";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES:
+            return "VkPhysicalDeviceInlineUniformBlockProperties";
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK:
+            return "VkWriteDescriptorSetInlineUniformBlock";
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO:
+            return "VkDescriptorPoolInlineUniformBlockCreateInfo";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES:
+            return "VkPhysicalDeviceTextureCompressionASTCHDRFeatures";
+        case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO:
+            return "VkRenderingAttachmentInfo";
+        case VK_STRUCTURE_TYPE_RENDERING_INFO:
+            return "VkRenderingInfo";
+        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
+            return "VkPipelineRenderingCreateInfo";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES:
+            return "VkPhysicalDeviceDynamicRenderingFeatures";
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO:
+            return "VkCommandBufferInheritanceRenderingInfo";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES:
+            return "VkPhysicalDeviceShaderIntegerDotProductFeatures";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES:
+            return "VkPhysicalDeviceShaderIntegerDotProductProperties";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES:
+            return "VkPhysicalDeviceTexelBufferAlignmentProperties";
+        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3:
+            return "VkFormatProperties3";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES:
+            return "VkPhysicalDeviceMaintenance4Features";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES:
+            return "VkPhysicalDeviceMaintenance4Properties";
+        case VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS:
+            return "VkDeviceBufferMemoryRequirements";
+        case VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS:
+            return "VkDeviceImageMemoryRequirements";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES:
+            return "VkPhysicalDeviceVulkan14Features";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES:
+            return "VkPhysicalDeviceVulkan14Properties";
+        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO:
+            return "VkDeviceQueueGlobalPriorityCreateInfo";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES:
+            return "VkPhysicalDeviceGlobalPriorityQueryFeatures";
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES:
+            return "VkQueueFamilyGlobalPriorityProperties";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES:
+            return "VkPhysicalDeviceShaderSubgroupRotateFeatures";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES:
+            return "VkPhysicalDeviceShaderFloatControls2Features";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES:
+            return "VkPhysicalDeviceShaderExpectAssumeFeatures";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES:
+            return "VkPhysicalDeviceLineRasterizationFeatures";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES:
+            return "VkPhysicalDeviceLineRasterizationProperties";
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO:
+            return "VkPipelineRasterizationLineStateCreateInfo";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES:
+            return "VkPhysicalDeviceVertexAttributeDivisorProperties";
+        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO:
+            return "VkPipelineVertexInputDivisorStateCreateInfo";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES:
+            return "VkPhysicalDeviceVertexAttributeDivisorFeatures";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES:
+            return "VkPhysicalDeviceIndexTypeUint8Features";
+        case VK_STRUCTURE_TYPE_MEMORY_MAP_INFO:
+            return "VkMemoryMapInfo";
+        case VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO:
+            return "VkMemoryUnmapInfo";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES:
+            return "VkPhysicalDeviceMaintenance5Features";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES:
+            return "VkPhysicalDeviceMaintenance5Properties";
+        case VK_STRUCTURE_TYPE_RENDERING_AREA_INFO:
+            return "VkRenderingAreaInfo";
+        case VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2:
+            return "VkImageSubresource2";
+        case VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO:
+            return "VkDeviceImageSubresourceInfo";
+        case VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2:
+            return "VkSubresourceLayout2";
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO:
+            return "VkPipelineCreateFlags2CreateInfo";
+        case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO:
+            return "VkBufferUsageFlags2CreateInfo";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES:
+            return "VkPhysicalDevicePushDescriptorProperties";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES:
+            return "VkPhysicalDeviceDynamicRenderingLocalReadFeatures";
+        case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO:
+            return "VkRenderingAttachmentLocationInfo";
+        case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO:
+            return "VkRenderingInputAttachmentIndexInfo";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES:
+            return "VkPhysicalDeviceMaintenance6Features";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES:
+            return "VkPhysicalDeviceMaintenance6Properties";
+        case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS:
+            return "VkBindMemoryStatus";
+        case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO:
+            return "VkBindDescriptorSetsInfo";
+        case VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO:
+            return "VkPushConstantsInfo";
+        case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO:
+            return "VkPushDescriptorSetInfo";
+        case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO:
+            return "VkPushDescriptorSetWithTemplateInfo";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES:
+            return "VkPhysicalDevicePipelineProtectedAccessFeatures";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES:
+            return "VkPhysicalDevicePipelineRobustnessFeatures";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES:
+            return "VkPhysicalDevicePipelineRobustnessProperties";
+        case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO:
+            return "VkPipelineRobustnessCreateInfo";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES:
+            return "VkPhysicalDeviceHostImageCopyFeatures";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES:
+            return "VkPhysicalDeviceHostImageCopyProperties";
+        case VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY:
+            return "VkMemoryToImageCopy";
+        case VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY:
+            return "VkImageToMemoryCopy";
+        case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO:
+            return "VkCopyMemoryToImageInfo";
+        case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO:
+            return "VkCopyImageToMemoryInfo";
+        case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO:
+            return "VkCopyImageToImageInfo";
+        case VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO:
+            return "VkHostImageLayoutTransitionInfo";
+        case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE:
+            return "VkSubresourceHostMemcpySize";
+        case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY:
+            return "VkHostImageCopyDevicePerformanceQuery";
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR:
+            return "VkSwapchainCreateInfoKHR";
+        case VK_STRUCTURE_TYPE_PRESENT_INFO_KHR:
+            return "VkPresentInfoKHR";
+        case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
+            return "VkImageSwapchainCreateInfoKHR";
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
+            return "VkBindImageMemorySwapchainInfoKHR";
+        case VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR:
+            return "VkAcquireNextImageInfoKHR";
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR:
+            return "VkDeviceGroupPresentCapabilitiesKHR";
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
+            return "VkDeviceGroupPresentInfoKHR";
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
+            return "VkDeviceGroupSwapchainCreateInfoKHR";
+        case VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR:
+            return "VkDisplayModeCreateInfoKHR";
+        case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR:
+            return "VkDisplaySurfaceCreateInfoKHR";
+        case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
+            return "VkDisplayPresentInfoKHR";
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+        case VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR:
+            return "VkXlibSurfaceCreateInfoKHR";
+#endif  // VK_USE_PLATFORM_XLIB_KHR
+#ifdef VK_USE_PLATFORM_XCB_KHR
+        case VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR:
+            return "VkXcbSurfaceCreateInfoKHR";
+#endif  // VK_USE_PLATFORM_XCB_KHR
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+        case VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR:
+            return "VkWaylandSurfaceCreateInfoKHR";
+#endif  // VK_USE_PLATFORM_WAYLAND_KHR
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+        case VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR:
+            return "VkAndroidSurfaceCreateInfoKHR";
+#endif  // VK_USE_PLATFORM_ANDROID_KHR
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR:
+            return "VkWin32SurfaceCreateInfoKHR";
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR:
+            return "VkQueueFamilyQueryResultStatusPropertiesKHR";
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR:
+            return "VkQueueFamilyVideoPropertiesKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR:
+            return "VkVideoProfileInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR:
+            return "VkVideoProfileListInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR:
+            return "VkVideoCapabilitiesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR:
+            return "VkPhysicalDeviceVideoFormatInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR:
+            return "VkVideoFormatPropertiesKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR:
+            return "VkVideoPictureResourceInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR:
+            return "VkVideoReferenceSlotInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR:
+            return "VkVideoSessionMemoryRequirementsKHR";
+        case VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR:
+            return "VkBindVideoSessionMemoryInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR:
+            return "VkVideoSessionCreateInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR:
+            return "VkVideoSessionParametersCreateInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR:
+            return "VkVideoSessionParametersUpdateInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR:
+            return "VkVideoBeginCodingInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR:
+            return "VkVideoEndCodingInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR:
+            return "VkVideoCodingControlInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR:
+            return "VkVideoDecodeCapabilitiesKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR:
+            return "VkVideoDecodeUsageInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR:
+            return "VkVideoDecodeInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR:
+            return "VkVideoEncodeH264CapabilitiesKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR:
+            return "VkVideoEncodeH264QualityLevelPropertiesKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR:
+            return "VkVideoEncodeH264SessionCreateInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR:
+            return "VkVideoEncodeH264SessionParametersAddInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR:
+            return "VkVideoEncodeH264SessionParametersCreateInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR:
+            return "VkVideoEncodeH264SessionParametersGetInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR:
+            return "VkVideoEncodeH264SessionParametersFeedbackInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR:
+            return "VkVideoEncodeH264NaluSliceInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR:
+            return "VkVideoEncodeH264PictureInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR:
+            return "VkVideoEncodeH264DpbSlotInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR:
+            return "VkVideoEncodeH264ProfileInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR:
+            return "VkVideoEncodeH264RateControlInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR:
+            return "VkVideoEncodeH264RateControlLayerInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR:
+            return "VkVideoEncodeH264GopRemainingFrameInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR:
+            return "VkVideoEncodeH265CapabilitiesKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR:
+            return "VkVideoEncodeH265SessionCreateInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR:
+            return "VkVideoEncodeH265QualityLevelPropertiesKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR:
+            return "VkVideoEncodeH265SessionParametersAddInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR:
+            return "VkVideoEncodeH265SessionParametersCreateInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR:
+            return "VkVideoEncodeH265SessionParametersGetInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR:
+            return "VkVideoEncodeH265SessionParametersFeedbackInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR:
+            return "VkVideoEncodeH265NaluSliceSegmentInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR:
+            return "VkVideoEncodeH265PictureInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR:
+            return "VkVideoEncodeH265DpbSlotInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR:
+            return "VkVideoEncodeH265ProfileInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR:
+            return "VkVideoEncodeH265RateControlInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR:
+            return "VkVideoEncodeH265RateControlLayerInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR:
+            return "VkVideoEncodeH265GopRemainingFrameInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR:
+            return "VkVideoDecodeH264ProfileInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR:
+            return "VkVideoDecodeH264CapabilitiesKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR:
+            return "VkVideoDecodeH264SessionParametersAddInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR:
+            return "VkVideoDecodeH264SessionParametersCreateInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR:
+            return "VkVideoDecodeH264PictureInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR:
+            return "VkVideoDecodeH264DpbSlotInfoKHR";
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+            return "VkImportMemoryWin32HandleInfoKHR";
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+            return "VkExportMemoryWin32HandleInfoKHR";
+        case VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR:
+            return "VkMemoryWin32HandlePropertiesKHR";
+        case VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR:
+            return "VkMemoryGetWin32HandleInfoKHR";
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
+            return "VkImportMemoryFdInfoKHR";
+        case VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR:
+            return "VkMemoryFdPropertiesKHR";
+        case VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR:
+            return "VkMemoryGetFdInfoKHR";
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
+            return "VkWin32KeyedMutexAcquireReleaseInfoKHR";
+        case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
+            return "VkImportSemaphoreWin32HandleInfoKHR";
+        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
+            return "VkExportSemaphoreWin32HandleInfoKHR";
+        case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
+            return "VkD3D12FenceSubmitInfoKHR";
+        case VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR:
+            return "VkSemaphoreGetWin32HandleInfoKHR";
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR:
+            return "VkImportSemaphoreFdInfoKHR";
+        case VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR:
+            return "VkSemaphoreGetFdInfoKHR";
+        case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
+            return "VkPresentRegionsKHR";
+        case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
+            return "VkSharedPresentSurfaceCapabilitiesKHR";
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR:
+            return "VkImportFenceWin32HandleInfoKHR";
+        case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
+            return "VkExportFenceWin32HandleInfoKHR";
+        case VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR:
+            return "VkFenceGetWin32HandleInfoKHR";
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR:
+            return "VkImportFenceFdInfoKHR";
+        case VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR:
+            return "VkFenceGetFdInfoKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR:
+            return "VkPhysicalDevicePerformanceQueryFeaturesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR:
+            return "VkPhysicalDevicePerformanceQueryPropertiesKHR";
+        case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR:
+            return "VkPerformanceCounterKHR";
+        case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR:
+            return "VkPerformanceCounterDescriptionKHR";
+        case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR:
+            return "VkQueryPoolPerformanceCreateInfoKHR";
+        case VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR:
+            return "VkAcquireProfilingLockInfoKHR";
+        case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR:
+            return "VkPerformanceQuerySubmitInfoKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR:
+            return "VkPhysicalDeviceSurfaceInfo2KHR";
+        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR:
+            return "VkSurfaceCapabilities2KHR";
+        case VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR:
+            return "VkSurfaceFormat2KHR";
+        case VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR:
+            return "VkDisplayProperties2KHR";
+        case VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR:
+            return "VkDisplayPlaneProperties2KHR";
+        case VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR:
+            return "VkDisplayModeProperties2KHR";
+        case VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR:
+            return "VkDisplayPlaneInfo2KHR";
+        case VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR:
+            return "VkDisplayPlaneCapabilities2KHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR:
+            return "VkPhysicalDeviceShaderBfloat16FeaturesKHR";
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR:
+            return "VkPhysicalDevicePortabilitySubsetFeaturesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR:
+            return "VkPhysicalDevicePortabilitySubsetPropertiesKHR";
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR:
+            return "VkPhysicalDeviceShaderClockFeaturesKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR:
+            return "VkVideoDecodeH265ProfileInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR:
+            return "VkVideoDecodeH265CapabilitiesKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR:
+            return "VkVideoDecodeH265SessionParametersAddInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR:
+            return "VkVideoDecodeH265SessionParametersCreateInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR:
+            return "VkVideoDecodeH265PictureInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR:
+            return "VkVideoDecodeH265DpbSlotInfoKHR";
+        case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
+            return "VkFragmentShadingRateAttachmentInfoKHR";
+        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR:
+            return "VkPipelineFragmentShadingRateStateCreateInfoKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR:
+            return "VkPhysicalDeviceFragmentShadingRateFeaturesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR:
+            return "VkPhysicalDeviceFragmentShadingRatePropertiesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR:
+            return "VkPhysicalDeviceFragmentShadingRateKHR";
+        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR:
+            return "VkRenderingFragmentShadingRateAttachmentInfoKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR:
+            return "VkPhysicalDeviceShaderQuadControlFeaturesKHR";
+        case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:
+            return "VkSurfaceProtectedCapabilitiesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR:
+            return "VkPhysicalDevicePresentWaitFeaturesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
+            return "VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR";
+        case VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR:
+            return "VkPipelineInfoKHR";
+        case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR:
+            return "VkPipelineExecutablePropertiesKHR";
+        case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR:
+            return "VkPipelineExecutableInfoKHR";
+        case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR:
+            return "VkPipelineExecutableStatisticKHR";
+        case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR:
+            return "VkPipelineExecutableInternalRepresentationKHR";
+        case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
+            return "VkPipelineLibraryCreateInfoKHR";
+        case VK_STRUCTURE_TYPE_PRESENT_ID_KHR:
+            return "VkPresentIdKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR:
+            return "VkPhysicalDevicePresentIdFeaturesKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR:
+            return "VkVideoEncodeInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR:
+            return "VkVideoEncodeCapabilitiesKHR";
+        case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR:
+            return "VkQueryPoolVideoEncodeFeedbackCreateInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR:
+            return "VkVideoEncodeUsageInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR:
+            return "VkVideoEncodeRateControlLayerInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR:
+            return "VkVideoEncodeRateControlInfoKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR:
+            return "VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR:
+            return "VkVideoEncodeQualityLevelPropertiesKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR:
+            return "VkVideoEncodeQualityLevelInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR:
+            return "VkVideoEncodeSessionParametersGetInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR:
+            return "VkVideoEncodeSessionParametersFeedbackInfoKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR:
+            return "VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR:
+            return "VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR:
+            return "VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR:
+            return "VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR:
+            return "VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR:
+            return "VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
+            return "VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR:
+            return "VkPhysicalDevicePipelineBinaryFeaturesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR:
+            return "VkPhysicalDevicePipelineBinaryPropertiesKHR";
+        case VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR:
+            return "VkDevicePipelineBinaryInternalCacheControlKHR";
+        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR:
+            return "VkPipelineBinaryKeyKHR";
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR:
+            return "VkPipelineCreateInfoKHR";
+        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR:
+            return "VkPipelineBinaryCreateInfoKHR";
+        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR:
+            return "VkPipelineBinaryInfoKHR";
+        case VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR:
+            return "VkReleaseCapturedPipelineDataInfoKHR";
+        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR:
+            return "VkPipelineBinaryDataInfoKHR";
+        case VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR:
+            return "VkPipelineBinaryHandlesInfoKHR";
+        case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR:
+            return "VkCooperativeMatrixPropertiesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR:
+            return "VkPhysicalDeviceCooperativeMatrixFeaturesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR:
+            return "VkPhysicalDeviceCooperativeMatrixPropertiesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR:
+            return "VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR:
+            return "VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR:
+            return "VkVideoDecodeAV1ProfileInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR:
+            return "VkVideoDecodeAV1CapabilitiesKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR:
+            return "VkVideoDecodeAV1SessionParametersCreateInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR:
+            return "VkVideoDecodeAV1PictureInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR:
+            return "VkVideoDecodeAV1DpbSlotInfoKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR:
+            return "VkPhysicalDeviceVideoEncodeAV1FeaturesKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR:
+            return "VkVideoEncodeAV1CapabilitiesKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR:
+            return "VkVideoEncodeAV1QualityLevelPropertiesKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR:
+            return "VkVideoEncodeAV1SessionCreateInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR:
+            return "VkVideoEncodeAV1SessionParametersCreateInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR:
+            return "VkVideoEncodeAV1PictureInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR:
+            return "VkVideoEncodeAV1DpbSlotInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR:
+            return "VkVideoEncodeAV1ProfileInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR:
+            return "VkVideoEncodeAV1GopRemainingFrameInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR:
+            return "VkVideoEncodeAV1RateControlInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR:
+            return "VkVideoEncodeAV1RateControlLayerInfoKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
+            return "VkPhysicalDeviceVideoMaintenance1FeaturesKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR:
+            return "VkVideoInlineQueryInfoKHR";
+        case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR:
+            return "VkCalibratedTimestampInfoKHR";
+        case VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT:
+            return "VkSetDescriptorBufferOffsetsInfoEXT";
+        case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT:
+            return "VkBindDescriptorBufferEmbeddedSamplersInfoEXT";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR:
+            return "VkVideoEncodeQuantizationMapCapabilitiesKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR:
+            return "VkVideoFormatQuantizationMapPropertiesKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR:
+            return "VkVideoEncodeQuantizationMapInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR:
+            return "VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR:
+            return "VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR:
+            return "VkVideoEncodeH264QuantizationMapCapabilitiesKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR:
+            return "VkVideoEncodeH265QuantizationMapCapabilitiesKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR:
+            return "VkVideoFormatH265QuantizationMapPropertiesKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR:
+            return "VkVideoEncodeAV1QuantizationMapCapabilitiesKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR:
+            return "VkVideoFormatAV1QuantizationMapPropertiesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR:
+            return "VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR:
+            return "VkPhysicalDeviceMaintenance7FeaturesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR:
+            return "VkPhysicalDeviceMaintenance7PropertiesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR:
+            return "VkPhysicalDeviceLayeredApiPropertiesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR:
+            return "VkPhysicalDeviceLayeredApiPropertiesListKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR:
+            return "VkPhysicalDeviceLayeredApiVulkanPropertiesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR:
+            return "VkPhysicalDeviceMaintenance8FeaturesKHR";
+        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR:
+            return "VkMemoryBarrierAccessFlags3KHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR:
+            return "VkPhysicalDeviceVideoMaintenance2FeaturesKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR:
+            return "VkVideoDecodeH264InlineSessionParametersInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR:
+            return "VkVideoDecodeH265InlineSessionParametersInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR:
+            return "VkVideoDecodeAV1InlineSessionParametersInfoKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR:
+            return "VkPhysicalDeviceDepthClampZeroOneFeaturesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR:
+            return "VkPhysicalDeviceRobustness2FeaturesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR:
+            return "VkPhysicalDeviceRobustness2PropertiesKHR";
+        case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
+            return "VkDebugReportCallbackCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
+            return "VkPipelineRasterizationStateRasterizationOrderAMD";
+        case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT:
+            return "VkDebugMarkerObjectNameInfoEXT";
+        case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT:
+            return "VkDebugMarkerObjectTagInfoEXT";
+        case VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT:
+            return "VkDebugMarkerMarkerInfoEXT";
+        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
+            return "VkDedicatedAllocationImageCreateInfoNV";
+        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
+            return "VkDedicatedAllocationBufferCreateInfoNV";
+        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
+            return "VkDedicatedAllocationMemoryAllocateInfoNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
+            return "VkPhysicalDeviceTransformFeedbackFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
+            return "VkPhysicalDeviceTransformFeedbackPropertiesEXT";
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
+            return "VkPipelineRasterizationStateStreamCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX:
+            return "VkCuModuleCreateInfoNVX";
+        case VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX:
+            return "VkCuModuleTexturingModeCreateInfoNVX";
+        case VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX:
+            return "VkCuFunctionCreateInfoNVX";
+        case VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX:
+            return "VkCuLaunchInfoNVX";
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX:
+            return "VkImageViewHandleInfoNVX";
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX:
+            return "VkImageViewAddressPropertiesNVX";
+        case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
+            return "VkTextureLODGatherFormatPropertiesAMD";
+#ifdef VK_USE_PLATFORM_GGP
+        case VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP:
+            return "VkStreamDescriptorSurfaceCreateInfoGGP";
+#endif  // VK_USE_PLATFORM_GGP
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
+            return "VkPhysicalDeviceCornerSampledImageFeaturesNV";
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
+            return "VkExternalMemoryImageCreateInfoNV";
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
+            return "VkExportMemoryAllocateInfoNV";
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+            return "VkImportMemoryWin32HandleInfoNV";
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+            return "VkExportMemoryWin32HandleInfoNV";
+        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
+            return "VkWin32KeyedMutexAcquireReleaseInfoNV";
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
+            return "VkValidationFlagsEXT";
+#ifdef VK_USE_PLATFORM_VI_NN
+        case VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN:
+            return "VkViSurfaceCreateInfoNN";
+#endif  // VK_USE_PLATFORM_VI_NN
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
+            return "VkImageViewASTCDecodeModeEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
+            return "VkPhysicalDeviceASTCDecodeFeaturesEXT";
+        case VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT:
+            return "VkConditionalRenderingBeginInfoEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
+            return "VkPhysicalDeviceConditionalRenderingFeaturesEXT";
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
+            return "VkCommandBufferInheritanceConditionalRenderingInfoEXT";
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
+            return "VkPipelineViewportWScalingStateCreateInfoNV";
+        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT:
+            return "VkSurfaceCapabilities2EXT";
+        case VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT:
+            return "VkDisplayPowerInfoEXT";
+        case VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT:
+            return "VkDeviceEventInfoEXT";
+        case VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT:
+            return "VkDisplayEventInfoEXT";
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
+            return "VkSwapchainCounterCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
+            return "VkPresentTimesInfoGOOGLE";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
+            return "VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX";
+        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX:
+            return "VkMultiviewPerViewAttributesInfoNVX";
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
+            return "VkPipelineViewportSwizzleStateCreateInfoNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
+            return "VkPhysicalDeviceDiscardRectanglePropertiesEXT";
+        case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
+            return "VkPipelineDiscardRectangleStateCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
+            return "VkPhysicalDeviceConservativeRasterizationPropertiesEXT";
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
+            return "VkPipelineRasterizationConservativeStateCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
+            return "VkPhysicalDeviceDepthClipEnableFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
+            return "VkPipelineRasterizationDepthClipStateCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_HDR_METADATA_EXT:
+            return "VkHdrMetadataEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG:
+            return "VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG";
+#ifdef VK_USE_PLATFORM_IOS_MVK
+        case VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK:
+            return "VkIOSSurfaceCreateInfoMVK";
+#endif  // VK_USE_PLATFORM_IOS_MVK
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+        case VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK:
+            return "VkMacOSSurfaceCreateInfoMVK";
+#endif  // VK_USE_PLATFORM_MACOS_MVK
+        case VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT:
+            return "VkDebugUtilsLabelEXT";
+        case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
+            return "VkDebugUtilsObjectNameInfoEXT";
+        case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT:
+            return "VkDebugUtilsMessengerCallbackDataEXT";
+        case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
+            return "VkDebugUtilsMessengerCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT:
+            return "VkDebugUtilsObjectTagInfoEXT";
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
+            return "VkAndroidHardwareBufferUsageANDROID";
+        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID:
+            return "VkAndroidHardwareBufferPropertiesANDROID";
+        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
+            return "VkAndroidHardwareBufferFormatPropertiesANDROID";
+        case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
+            return "VkImportAndroidHardwareBufferInfoANDROID";
+        case VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
+            return "VkMemoryGetAndroidHardwareBufferInfoANDROID";
+        case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
+            return "VkExternalFormatANDROID";
+        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID:
+            return "VkAndroidHardwareBufferFormatProperties2ANDROID";
+#endif  // VK_USE_PLATFORM_ANDROID_KHR
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX:
+            return "VkPhysicalDeviceShaderEnqueueFeaturesAMDX";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX:
+            return "VkPhysicalDeviceShaderEnqueuePropertiesAMDX";
+        case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX:
+            return "VkExecutionGraphPipelineScratchSizeAMDX";
+        case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX:
+            return "VkExecutionGraphPipelineCreateInfoAMDX";
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX:
+            return "VkPipelineShaderStageNodeCreateInfoAMDX";
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD:
+            return "VkAttachmentSampleCountInfoAMD";
+        case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
+            return "VkSampleLocationsInfoEXT";
+        case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
+            return "VkRenderPassSampleLocationsBeginInfoEXT";
+        case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
+            return "VkPipelineSampleLocationsStateCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
+            return "VkPhysicalDeviceSampleLocationsPropertiesEXT";
+        case VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT:
+            return "VkMultisamplePropertiesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
+            return "VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
+            return "VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT";
+        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
+            return "VkPipelineColorBlendAdvancedStateCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
+            return "VkPipelineCoverageToColorStateCreateInfoNV";
+        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
+            return "VkPipelineCoverageModulationStateCreateInfoNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
+            return "VkPhysicalDeviceShaderSMBuiltinsPropertiesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
+            return "VkPhysicalDeviceShaderSMBuiltinsFeaturesNV";
+        case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
+            return "VkDrmFormatModifierPropertiesListEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
+            return "VkPhysicalDeviceImageDrmFormatModifierInfoEXT";
+        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
+            return "VkImageDrmFormatModifierListCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
+            return "VkImageDrmFormatModifierExplicitCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT:
+            return "VkImageDrmFormatModifierPropertiesEXT";
+        case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT:
+            return "VkDrmFormatModifierPropertiesList2EXT";
+        case VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT:
+            return "VkValidationCacheCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
+            return "VkShaderModuleValidationCacheCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
+            return "VkPipelineViewportShadingRateImageStateCreateInfoNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
+            return "VkPhysicalDeviceShadingRateImageFeaturesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
+            return "VkPhysicalDeviceShadingRateImagePropertiesNV";
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
+            return "VkPipelineViewportCoarseSampleOrderStateCreateInfoNV";
+        case VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV:
+            return "VkRayTracingShaderGroupCreateInfoNV";
+        case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV:
+            return "VkRayTracingPipelineCreateInfoNV";
+        case VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV:
+            return "VkGeometryTrianglesNV";
+        case VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV:
+            return "VkGeometryAABBNV";
+        case VK_STRUCTURE_TYPE_GEOMETRY_NV:
+            return "VkGeometryNV";
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV:
+            return "VkAccelerationStructureInfoNV";
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV:
+            return "VkAccelerationStructureCreateInfoNV";
+        case VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV:
+            return "VkBindAccelerationStructureMemoryInfoNV";
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
+            return "VkWriteDescriptorSetAccelerationStructureNV";
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV:
+            return "VkAccelerationStructureMemoryRequirementsInfoNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
+            return "VkPhysicalDeviceRayTracingPropertiesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
+            return "VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV";
+        case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
+            return "VkPipelineRepresentativeFragmentTestStateCreateInfoNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
+            return "VkPhysicalDeviceImageViewImageFormatInfoEXT";
+        case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
+            return "VkFilterCubicImageViewImageFormatPropertiesEXT";
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
+            return "VkImportMemoryHostPointerInfoEXT";
+        case VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT:
+            return "VkMemoryHostPointerPropertiesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
+            return "VkPhysicalDeviceExternalMemoryHostPropertiesEXT";
+        case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
+            return "VkPipelineCompilerControlCreateInfoAMD";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
+            return "VkPhysicalDeviceShaderCorePropertiesAMD";
+        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
+            return "VkDeviceMemoryOverallocationCreateInfoAMD";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
+            return "VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT";
+#ifdef VK_USE_PLATFORM_GGP
+        case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
+            return "VkPresentFrameTokenGGP";
+#endif  // VK_USE_PLATFORM_GGP
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
+            return "VkPhysicalDeviceMeshShaderFeaturesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
+            return "VkPhysicalDeviceMeshShaderPropertiesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
+            return "VkPhysicalDeviceShaderImageFootprintFeaturesNV";
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
+            return "VkPipelineViewportExclusiveScissorStateCreateInfoNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
+            return "VkPhysicalDeviceExclusiveScissorFeaturesNV";
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
+            return "VkQueueFamilyCheckpointPropertiesNV";
+        case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV:
+            return "VkCheckpointDataNV";
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV:
+            return "VkQueueFamilyCheckpointProperties2NV";
+        case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV:
+            return "VkCheckpointData2NV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
+            return "VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL";
+        case VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL:
+            return "VkInitializePerformanceApiInfoINTEL";
+        case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL:
+            return "VkQueryPoolPerformanceQueryCreateInfoINTEL";
+        case VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL:
+            return "VkPerformanceMarkerInfoINTEL";
+        case VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL:
+            return "VkPerformanceStreamMarkerInfoINTEL";
+        case VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL:
+            return "VkPerformanceOverrideInfoINTEL";
+        case VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL:
+            return "VkPerformanceConfigurationAcquireInfoINTEL";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
+            return "VkPhysicalDevicePCIBusInfoPropertiesEXT";
+        case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD:
+            return "VkDisplayNativeHdrSurfaceCapabilitiesAMD";
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
+            return "VkSwapchainDisplayNativeHdrCreateInfoAMD";
+#ifdef VK_USE_PLATFORM_FUCHSIA
+        case VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA:
+            return "VkImagePipeSurfaceCreateInfoFUCHSIA";
+#endif  // VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_METAL_EXT
+        case VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT:
+            return "VkMetalSurfaceCreateInfoEXT";
+#endif  // VK_USE_PLATFORM_METAL_EXT
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
+            return "VkPhysicalDeviceFragmentDensityMapFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
+            return "VkPhysicalDeviceFragmentDensityMapPropertiesEXT";
+        case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
+            return "VkRenderPassFragmentDensityMapCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT:
+            return "VkRenderingFragmentDensityMapAttachmentInfoEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
+            return "VkPhysicalDeviceShaderCoreProperties2AMD";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
+            return "VkPhysicalDeviceCoherentMemoryFeaturesAMD";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT:
+            return "VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
+            return "VkPhysicalDeviceMemoryBudgetPropertiesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
+            return "VkPhysicalDeviceMemoryPriorityFeaturesEXT";
+        case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
+            return "VkMemoryPriorityAllocateInfoEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
+            return "VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
+            return "VkPhysicalDeviceBufferDeviceAddressFeaturesEXT";
+        case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
+            return "VkBufferDeviceAddressCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
+            return "VkValidationFeaturesEXT";
+        case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV:
+            return "VkCooperativeMatrixPropertiesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
+            return "VkPhysicalDeviceCooperativeMatrixFeaturesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
+            return "VkPhysicalDeviceCooperativeMatrixPropertiesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
+            return "VkPhysicalDeviceCoverageReductionModeFeaturesNV";
+        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
+            return "VkPipelineCoverageReductionStateCreateInfoNV";
+        case VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV:
+            return "VkFramebufferMixedSamplesCombinationNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
+            return "VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
+            return "VkPhysicalDeviceYcbcrImageArraysFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
+            return "VkPhysicalDeviceProvokingVertexFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT:
+            return "VkPhysicalDeviceProvokingVertexPropertiesEXT";
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
+            return "VkPipelineRasterizationProvokingVertexStateCreateInfoEXT";
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
+            return "VkSurfaceFullScreenExclusiveInfoEXT";
+        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
+            return "VkSurfaceCapabilitiesFullScreenExclusiveEXT";
+        case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
+            return "VkSurfaceFullScreenExclusiveWin32InfoEXT";
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT:
+            return "VkHeadlessSurfaceCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT:
+            return "VkPhysicalDeviceShaderAtomicFloatFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT:
+            return "VkPhysicalDeviceExtendedDynamicStateFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT:
+            return "VkPhysicalDeviceMapMemoryPlacedFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT:
+            return "VkPhysicalDeviceMapMemoryPlacedPropertiesEXT";
+        case VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT:
+            return "VkMemoryMapPlacedInfoEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT:
+            return "VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT";
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT:
+            return "VkSurfacePresentModeEXT";
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT:
+            return "VkSurfacePresentScalingCapabilitiesEXT";
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT:
+            return "VkSurfacePresentModeCompatibilityEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT:
+            return "VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT";
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT:
+            return "VkSwapchainPresentFenceInfoEXT";
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT:
+            return "VkSwapchainPresentModesCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT:
+            return "VkSwapchainPresentModeInfoEXT";
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT:
+            return "VkSwapchainPresentScalingCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT:
+            return "VkReleaseSwapchainImagesInfoEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV:
+            return "VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV:
+            return "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV";
+        case VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV:
+            return "VkGraphicsShaderGroupCreateInfoNV";
+        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV:
+            return "VkGraphicsPipelineShaderGroupsCreateInfoNV";
+        case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV:
+            return "VkIndirectCommandsLayoutTokenNV";
+        case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV:
+            return "VkIndirectCommandsLayoutCreateInfoNV";
+        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV:
+            return "VkGeneratedCommandsInfoNV";
+        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV:
+            return "VkGeneratedCommandsMemoryRequirementsInfoNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV:
+            return "VkPhysicalDeviceInheritedViewportScissorFeaturesNV";
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV:
+            return "VkCommandBufferInheritanceViewportScissorInfoNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
+            return "VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT";
+        case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM:
+            return "VkRenderPassTransformBeginInfoQCOM";
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM:
+            return "VkCommandBufferInheritanceRenderPassTransformInfoQCOM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT:
+            return "VkPhysicalDeviceDepthBiasControlFeaturesEXT";
+        case VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT:
+            return "VkDepthBiasInfoEXT";
+        case VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT:
+            return "VkDepthBiasRepresentationInfoEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT:
+            return "VkPhysicalDeviceDeviceMemoryReportFeaturesEXT";
+        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT:
+            return "VkDeviceMemoryReportCallbackDataEXT";
+        case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT:
+            return "VkDeviceDeviceMemoryReportCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
+            return "VkSamplerCustomBorderColorCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT:
+            return "VkPhysicalDeviceCustomBorderColorPropertiesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT:
+            return "VkPhysicalDeviceCustomBorderColorFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV:
+            return "VkPhysicalDevicePresentBarrierFeaturesNV";
+        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV:
+            return "VkSurfaceCapabilitiesPresentBarrierNV";
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV:
+            return "VkSwapchainPresentBarrierCreateInfoNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV:
+            return "VkPhysicalDeviceDiagnosticsConfigFeaturesNV";
+        case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV:
+            return "VkDeviceDiagnosticsConfigCreateInfoNV";
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV:
+            return "VkCudaModuleCreateInfoNV";
+        case VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV:
+            return "VkCudaFunctionCreateInfoNV";
+        case VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV:
+            return "VkCudaLaunchInfoNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV:
+            return "VkPhysicalDeviceCudaKernelLaunchFeaturesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV:
+            return "VkPhysicalDeviceCudaKernelLaunchPropertiesNV";
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM:
+            return "VkPhysicalDeviceTileShadingFeaturesQCOM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM:
+            return "VkPhysicalDeviceTileShadingPropertiesQCOM";
+        case VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM:
+            return "VkRenderPassTileShadingCreateInfoQCOM";
+        case VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM:
+            return "VkPerTileBeginInfoQCOM";
+        case VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM:
+            return "VkPerTileEndInfoQCOM";
+        case VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM:
+            return "VkDispatchTileInfoQCOM";
+        case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV:
+            return "VkQueryLowLatencySupportNV";
+#ifdef VK_USE_PLATFORM_METAL_EXT
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT:
+            return "VkExportMetalObjectCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT:
+            return "VkExportMetalObjectsInfoEXT";
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT:
+            return "VkExportMetalDeviceInfoEXT";
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT:
+            return "VkExportMetalCommandQueueInfoEXT";
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT:
+            return "VkExportMetalBufferInfoEXT";
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT:
+            return "VkImportMetalBufferInfoEXT";
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT:
+            return "VkExportMetalTextureInfoEXT";
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT:
+            return "VkImportMetalTextureInfoEXT";
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT:
+            return "VkExportMetalIOSurfaceInfoEXT";
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT:
+            return "VkImportMetalIOSurfaceInfoEXT";
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT:
+            return "VkExportMetalSharedEventInfoEXT";
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT:
+            return "VkImportMetalSharedEventInfoEXT";
+#endif  // VK_USE_PLATFORM_METAL_EXT
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT:
+            return "VkPhysicalDeviceDescriptorBufferPropertiesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT:
+            return "VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT:
+            return "VkPhysicalDeviceDescriptorBufferFeaturesEXT";
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT:
+            return "VkDescriptorAddressInfoEXT";
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT:
+            return "VkDescriptorBufferBindingInfoEXT";
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT:
+            return "VkDescriptorBufferBindingPushDescriptorBufferHandleEXT";
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT:
+            return "VkDescriptorGetInfoEXT";
+        case VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT:
+            return "VkBufferCaptureDescriptorDataInfoEXT";
+        case VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT:
+            return "VkImageCaptureDescriptorDataInfoEXT";
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT:
+            return "VkImageViewCaptureDescriptorDataInfoEXT";
+        case VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT:
+            return "VkSamplerCaptureDescriptorDataInfoEXT";
+        case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT:
+            return "VkOpaqueCaptureDescriptorDataCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT:
+            return "VkAccelerationStructureCaptureDescriptorDataInfoEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT:
+            return "VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT:
+            return "VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT";
+        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT:
+            return "VkGraphicsPipelineLibraryCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD:
+            return "VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV:
+            return "VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV:
+            return "VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV";
+        case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV:
+            return "VkPipelineFragmentShadingRateEnumStateCreateInfoNV";
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV:
+            return "VkAccelerationStructureGeometryMotionTrianglesDataNV";
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV:
+            return "VkAccelerationStructureMotionInfoNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV:
+            return "VkPhysicalDeviceRayTracingMotionBlurFeaturesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT:
+            return "VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT:
+            return "VkPhysicalDeviceFragmentDensityMap2FeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT:
+            return "VkPhysicalDeviceFragmentDensityMap2PropertiesEXT";
+        case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM:
+            return "VkCopyCommandTransformInfoQCOM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT:
+            return "VkPhysicalDeviceImageCompressionControlFeaturesEXT";
+        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT:
+            return "VkImageCompressionControlEXT";
+        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT:
+            return "VkImageCompressionPropertiesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT:
+            return "VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT:
+            return "VkPhysicalDevice4444FormatsFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT:
+            return "VkPhysicalDeviceFaultFeaturesEXT";
+        case VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT:
+            return "VkDeviceFaultCountsEXT";
+        case VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT:
+            return "VkDeviceFaultInfoEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT:
+            return "VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT:
+            return "VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT";
+#ifdef VK_USE_PLATFORM_DIRECTFB_EXT
+        case VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT:
+            return "VkDirectFBSurfaceCreateInfoEXT";
+#endif  // VK_USE_PLATFORM_DIRECTFB_EXT
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT:
+            return "VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT";
+        case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT:
+            return "VkMutableDescriptorTypeCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT:
+            return "VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT";
+        case VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT:
+            return "VkVertexInputBindingDescription2EXT";
+        case VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT:
+            return "VkVertexInputAttributeDescription2EXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT:
+            return "VkPhysicalDeviceDrmPropertiesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT:
+            return "VkPhysicalDeviceAddressBindingReportFeaturesEXT";
+        case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT:
+            return "VkDeviceAddressBindingCallbackDataEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT:
+            return "VkPhysicalDeviceDepthClipControlFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT:
+            return "VkPipelineViewportDepthClipControlCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT:
+            return "VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT:
+            return "VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT";
+#ifdef VK_USE_PLATFORM_FUCHSIA
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
+            return "VkImportMemoryZirconHandleInfoFUCHSIA";
+        case VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA:
+            return "VkMemoryZirconHandlePropertiesFUCHSIA";
+        case VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA:
+            return "VkMemoryGetZirconHandleInfoFUCHSIA";
+        case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA:
+            return "VkImportSemaphoreZirconHandleInfoFUCHSIA";
+        case VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA:
+            return "VkSemaphoreGetZirconHandleInfoFUCHSIA";
+        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA:
+            return "VkBufferCollectionCreateInfoFUCHSIA";
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA:
+            return "VkImportMemoryBufferCollectionFUCHSIA";
+        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA:
+            return "VkBufferCollectionImageCreateInfoFUCHSIA";
+        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA:
+            return "VkBufferCollectionConstraintsInfoFUCHSIA";
+        case VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA:
+            return "VkBufferConstraintsInfoFUCHSIA";
+        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA:
+            return "VkBufferCollectionBufferCreateInfoFUCHSIA";
+        case VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA:
+            return "VkSysmemColorSpaceFUCHSIA";
+        case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA:
+            return "VkBufferCollectionPropertiesFUCHSIA";
+        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA:
+            return "VkImageFormatConstraintsInfoFUCHSIA";
+        case VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA:
+            return "VkImageConstraintsInfoFUCHSIA";
+#endif  // VK_USE_PLATFORM_FUCHSIA
+        case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI:
+            return "VkSubpassShadingPipelineCreateInfoHUAWEI";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI:
+            return "VkPhysicalDeviceSubpassShadingFeaturesHUAWEI";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI:
+            return "VkPhysicalDeviceSubpassShadingPropertiesHUAWEI";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI:
+            return "VkPhysicalDeviceInvocationMaskFeaturesHUAWEI";
+        case VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV:
+            return "VkMemoryGetRemoteAddressInfoNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV:
+            return "VkPhysicalDeviceExternalMemoryRDMAFeaturesNV";
+        case VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT:
+            return "VkPipelinePropertiesIdentifierEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT:
+            return "VkPhysicalDevicePipelinePropertiesFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT:
+            return "VkPhysicalDeviceFrameBoundaryFeaturesEXT";
+        case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT:
+            return "VkFrameBoundaryEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT:
+            return "VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT";
+        case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT:
+            return "VkSubpassResolvePerformanceQueryEXT";
+        case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT:
+            return "VkMultisampledRenderToSingleSampledInfoEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT:
+            return "VkPhysicalDeviceExtendedDynamicState2FeaturesEXT";
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+        case VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX:
+            return "VkScreenSurfaceCreateInfoQNX";
+#endif  // VK_USE_PLATFORM_SCREEN_QNX
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT:
+            return "VkPhysicalDeviceColorWriteEnableFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT:
+            return "VkPipelineColorWriteCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT:
+            return "VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT:
+            return "VkPhysicalDeviceImageViewMinLodFeaturesEXT";
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT:
+            return "VkImageViewMinLodCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT:
+            return "VkPhysicalDeviceMultiDrawFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT:
+            return "VkPhysicalDeviceMultiDrawPropertiesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT:
+            return "VkPhysicalDeviceImage2DViewOf3DFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT:
+            return "VkPhysicalDeviceShaderTileImageFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT:
+            return "VkPhysicalDeviceShaderTileImagePropertiesEXT";
+        case VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT:
+            return "VkMicromapBuildInfoEXT";
+        case VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT:
+            return "VkMicromapCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT:
+            return "VkPhysicalDeviceOpacityMicromapFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT:
+            return "VkPhysicalDeviceOpacityMicromapPropertiesEXT";
+        case VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT:
+            return "VkMicromapVersionInfoEXT";
+        case VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT:
+            return "VkCopyMicromapToMemoryInfoEXT";
+        case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT:
+            return "VkCopyMemoryToMicromapInfoEXT";
+        case VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT:
+            return "VkCopyMicromapInfoEXT";
+        case VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT:
+            return "VkMicromapBuildSizesInfoEXT";
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT:
+            return "VkAccelerationStructureTrianglesOpacityMicromapEXT";
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV:
+            return "VkPhysicalDeviceDisplacementMicromapFeaturesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV:
+            return "VkPhysicalDeviceDisplacementMicromapPropertiesNV";
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV:
+            return "VkAccelerationStructureTrianglesDisplacementMicromapNV";
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI:
+            return "VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI:
+            return "VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI:
+            return "VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT:
+            return "VkPhysicalDeviceBorderColorSwizzleFeaturesEXT";
+        case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT:
+            return "VkSamplerBorderColorComponentMappingCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT:
+            return "VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM:
+            return "VkPhysicalDeviceShaderCorePropertiesARM";
+        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM:
+            return "VkDeviceQueueShaderCoreControlCreateInfoARM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM:
+            return "VkPhysicalDeviceSchedulingControlsFeaturesARM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM:
+            return "VkPhysicalDeviceSchedulingControlsPropertiesARM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT:
+            return "VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT";
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT:
+            return "VkImageViewSlicedCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE:
+            return "VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE";
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE:
+            return "VkDescriptorSetBindingReferenceVALVE";
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE:
+            return "VkDescriptorSetLayoutHostMappingInfoVALVE";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT:
+            return "VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM:
+            return "VkPhysicalDeviceRenderPassStripedFeaturesARM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM:
+            return "VkPhysicalDeviceRenderPassStripedPropertiesARM";
+        case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM:
+            return "VkRenderPassStripeInfoARM";
+        case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM:
+            return "VkRenderPassStripeBeginInfoARM";
+        case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM:
+            return "VkRenderPassStripeSubmitInfoARM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT:
+            return "VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT:
+            return "VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT";
+        case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT:
+            return "VkRenderPassFragmentDensityMapOffsetEndInfoEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV:
+            return "VkPhysicalDeviceCopyMemoryIndirectFeaturesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV:
+            return "VkPhysicalDeviceCopyMemoryIndirectPropertiesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV:
+            return "VkPhysicalDeviceMemoryDecompressionFeaturesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV:
+            return "VkPhysicalDeviceMemoryDecompressionPropertiesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV:
+            return "VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV";
+        case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV:
+            return "VkComputePipelineIndirectBufferInfoNV";
+        case VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV:
+            return "VkPipelineIndirectDeviceAddressInfoNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV:
+            return "VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV";
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV:
+            return "VkAccelerationStructureGeometryLinearSweptSpheresDataNV";
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV:
+            return "VkAccelerationStructureGeometrySpheresDataNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV:
+            return "VkPhysicalDeviceLinearColorAttachmentFeaturesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT:
+            return "VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT";
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM:
+            return "VkImageViewSampleWeightCreateInfoQCOM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM:
+            return "VkPhysicalDeviceImageProcessingFeaturesQCOM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM:
+            return "VkPhysicalDeviceImageProcessingPropertiesQCOM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT:
+            return "VkPhysicalDeviceNestedCommandBufferFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT:
+            return "VkPhysicalDeviceNestedCommandBufferPropertiesEXT";
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT:
+            return "VkExternalMemoryAcquireUnmodifiedEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT:
+            return "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT:
+            return "VkPhysicalDeviceExtendedDynamicState3PropertiesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT:
+            return "VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT";
+        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT:
+            return "VkRenderPassCreationControlEXT";
+        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT:
+            return "VkRenderPassCreationFeedbackCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT:
+            return "VkRenderPassSubpassFeedbackCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG:
+            return "VkDirectDriverLoadingInfoLUNARG";
+        case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG:
+            return "VkDirectDriverLoadingListLUNARG";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
+            return "VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT:
+            return "VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT";
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT:
+            return "VkPipelineShaderStageModuleIdentifierCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT:
+            return "VkShaderModuleIdentifierEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV:
+            return "VkPhysicalDeviceOpticalFlowFeaturesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV:
+            return "VkPhysicalDeviceOpticalFlowPropertiesNV";
+        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV:
+            return "VkOpticalFlowImageFormatInfoNV";
+        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV:
+            return "VkOpticalFlowImageFormatPropertiesNV";
+        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV:
+            return "VkOpticalFlowSessionCreateInfoNV";
+        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV:
+            return "VkOpticalFlowSessionCreatePrivateDataInfoNV";
+        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV:
+            return "VkOpticalFlowExecuteInfoNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT:
+            return "VkPhysicalDeviceLegacyDitheringFeaturesEXT";
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID:
+            return "VkPhysicalDeviceExternalFormatResolveFeaturesANDROID";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID:
+            return "VkPhysicalDeviceExternalFormatResolvePropertiesANDROID";
+        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID:
+            return "VkAndroidHardwareBufferFormatResolvePropertiesANDROID";
+#endif  // VK_USE_PLATFORM_ANDROID_KHR
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD:
+            return "VkPhysicalDeviceAntiLagFeaturesAMD";
+        case VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD:
+            return "VkAntiLagPresentationInfoAMD";
+        case VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD:
+            return "VkAntiLagDataAMD";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
+            return "VkPhysicalDeviceShaderObjectFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT:
+            return "VkPhysicalDeviceShaderObjectPropertiesEXT";
+        case VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT:
+            return "VkShaderCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM:
+            return "VkPhysicalDeviceTilePropertiesFeaturesQCOM";
+        case VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM:
+            return "VkTilePropertiesQCOM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC:
+            return "VkPhysicalDeviceAmigoProfilingFeaturesSEC";
+        case VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC:
+            return "VkAmigoProfilingSubmitInfoSEC";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM:
+            return "VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV:
+            return "VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV:
+            return "VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV:
+            return "VkPhysicalDeviceCooperativeVectorPropertiesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV:
+            return "VkPhysicalDeviceCooperativeVectorFeaturesNV";
+        case VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV:
+            return "VkCooperativeVectorPropertiesNV";
+        case VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV:
+            return "VkConvertCooperativeVectorMatrixInfoNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV:
+            return "VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV:
+            return "VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT:
+            return "VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT:
+            return "VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT";
+        case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT:
+            return "VkLayerSettingsCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM:
+            return "VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM:
+            return "VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT:
+            return "VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT:
+            return "VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT";
+        case VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV:
+            return "VkLatencySleepModeInfoNV";
+        case VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV:
+            return "VkLatencySleepInfoNV";
+        case VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV:
+            return "VkSetLatencyMarkerInfoNV";
+        case VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV:
+            return "VkLatencyTimingsFrameReportNV";
+        case VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV:
+            return "VkGetLatencyMarkerInfoNV";
+        case VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV:
+            return "VkLatencySubmissionPresentIdNV";
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV:
+            return "VkSwapchainLatencyCreateInfoNV";
+        case VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV:
+            return "VkOutOfBandQueueTypeInfoNV";
+        case VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV:
+            return "VkLatencySurfaceCapabilitiesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM:
+            return "VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM";
+        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM:
+            return "VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV:
+            return "VkPhysicalDevicePerStageDescriptorSetFeaturesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM:
+            return "VkPhysicalDeviceImageProcessing2FeaturesQCOM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM:
+            return "VkPhysicalDeviceImageProcessing2PropertiesQCOM";
+        case VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM:
+            return "VkSamplerBlockMatchWindowCreateInfoQCOM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM:
+            return "VkPhysicalDeviceCubicWeightsFeaturesQCOM";
+        case VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM:
+            return "VkSamplerCubicWeightsCreateInfoQCOM";
+        case VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM:
+            return "VkBlitImageCubicWeightsInfoQCOM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM:
+            return "VkPhysicalDeviceYcbcrDegammaFeaturesQCOM";
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM:
+            return "VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM:
+            return "VkPhysicalDeviceCubicClampFeaturesQCOM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
+            return "VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT";
+#ifdef VK_USE_PLATFORM_SCREEN_QNX
+        case VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX:
+            return "VkScreenBufferPropertiesQNX";
+        case VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX:
+            return "VkScreenBufferFormatPropertiesQNX";
+        case VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX:
+            return "VkImportScreenBufferInfoQNX";
+        case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX:
+            return "VkExternalFormatQNX";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX:
+            return "VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX";
+#endif  // VK_USE_PLATFORM_SCREEN_QNX
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT:
+            return "VkPhysicalDeviceLayeredDriverPropertiesMSFT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV:
+            return "VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM:
+            return "VkPhysicalDeviceTileMemoryHeapFeaturesQCOM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM:
+            return "VkPhysicalDeviceTileMemoryHeapPropertiesQCOM";
+        case VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM:
+            return "VkTileMemoryRequirementsQCOM";
+        case VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM:
+            return "VkTileMemoryBindInfoQCOM";
+        case VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM:
+            return "VkTileMemorySizeInfoQCOM";
+        case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV:
+            return "VkDisplaySurfaceStereoCreateInfoNV";
+        case VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV:
+            return "VkDisplayModeStereoPropertiesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV:
+            return "VkPhysicalDeviceRawAccessChainsFeaturesNV";
+        case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV:
+            return "VkExternalComputeQueueDeviceCreateInfoNV";
+        case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV:
+            return "VkExternalComputeQueueCreateInfoNV";
+        case VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV:
+            return "VkExternalComputeQueueDataParamsNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV:
+            return "VkPhysicalDeviceExternalComputeQueuePropertiesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV:
+            return "VkPhysicalDeviceCommandBufferInheritanceFeaturesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV:
+            return "VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT:
+            return "VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
+            return "VkPhysicalDeviceRayTracingValidationFeaturesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV:
+            return "VkPhysicalDeviceClusterAccelerationStructureFeaturesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV:
+            return "VkPhysicalDeviceClusterAccelerationStructurePropertiesNV";
+        case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV:
+            return "VkClusterAccelerationStructureClustersBottomLevelInputNV";
+        case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV:
+            return "VkClusterAccelerationStructureTriangleClusterInputNV";
+        case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV:
+            return "VkClusterAccelerationStructureMoveObjectsInputNV";
+        case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV:
+            return "VkClusterAccelerationStructureInputInfoNV";
+        case VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV:
+            return "VkClusterAccelerationStructureCommandsInfoNV";
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR:
+            return "VkAccelerationStructureBuildSizesInfoKHR";
+        case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV:
+            return "VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV:
+            return "VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV:
+            return "VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV";
+        case VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV:
+            return "VkPartitionedAccelerationStructureFlagsNV";
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV:
+            return "VkWriteDescriptorSetPartitionedAccelerationStructureNV";
+        case VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV:
+            return "VkPartitionedAccelerationStructureInstancesInputNV";
+        case VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV:
+            return "VkBuildPartitionedAccelerationStructureInfoNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT:
+            return "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT:
+            return "VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT";
+        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT:
+            return "VkGeneratedCommandsMemoryRequirementsInfoEXT";
+        case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT:
+            return "VkIndirectExecutionSetPipelineInfoEXT";
+        case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT:
+            return "VkIndirectExecutionSetShaderLayoutInfoEXT";
+        case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT:
+            return "VkIndirectExecutionSetShaderInfoEXT";
+        case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT:
+            return "VkIndirectExecutionSetCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT:
+            return "VkGeneratedCommandsInfoEXT";
+        case VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT:
+            return "VkWriteIndirectExecutionSetPipelineEXT";
+        case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT:
+            return "VkIndirectCommandsLayoutTokenEXT";
+        case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT:
+            return "VkIndirectCommandsLayoutCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT:
+            return "VkGeneratedCommandsPipelineInfoEXT";
+        case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT:
+            return "VkGeneratedCommandsShaderInfoEXT";
+        case VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT:
+            return "VkWriteIndirectExecutionSetShaderEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA:
+            return "VkPhysicalDeviceImageAlignmentControlFeaturesMESA";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA:
+            return "VkPhysicalDeviceImageAlignmentControlPropertiesMESA";
+        case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA:
+            return "VkImageAlignmentControlCreateInfoMESA";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT:
+            return "VkPhysicalDeviceDepthClampControlFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT:
+            return "VkPipelineViewportDepthClampControlCreateInfoEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI:
+            return "VkPhysicalDeviceHdrVividFeaturesHUAWEI";
+        case VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI:
+            return "VkHdrVividDynamicMetadataHUAWEI";
+        case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV:
+            return "VkCooperativeMatrixFlexibleDimensionsPropertiesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV:
+            return "VkPhysicalDeviceCooperativeMatrix2FeaturesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV:
+            return "VkPhysicalDeviceCooperativeMatrix2PropertiesNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM:
+            return "VkPhysicalDevicePipelineOpacityMicromapFeaturesARM";
+#ifdef VK_USE_PLATFORM_METAL_EXT
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT:
+            return "VkImportMemoryMetalHandleInfoEXT";
+        case VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT:
+            return "VkMemoryMetalHandlePropertiesEXT";
+        case VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT:
+            return "VkMemoryGetMetalHandleInfoEXT";
+#endif  // VK_USE_PLATFORM_METAL_EXT
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
+            return "VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT";
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV:
+            return "VkSetPresentConfigNV";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV:
+            return "VkPhysicalDevicePresentMeteringFeaturesNV";
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT:
+            return "VkRenderingEndInfoEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT:
+            return "VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT";
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR:
+            return "VkAccelerationStructureGeometryTrianglesDataKHR";
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR:
+            return "VkAccelerationStructureGeometryAabbsDataKHR";
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR:
+            return "VkAccelerationStructureGeometryInstancesDataKHR";
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR:
+            return "VkAccelerationStructureGeometryKHR";
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR:
+            return "VkAccelerationStructureBuildGeometryInfoKHR";
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR:
+            return "VkAccelerationStructureCreateInfoKHR";
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR:
+            return "VkWriteDescriptorSetAccelerationStructureKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR:
+            return "VkPhysicalDeviceAccelerationStructureFeaturesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR:
+            return "VkPhysicalDeviceAccelerationStructurePropertiesKHR";
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR:
+            return "VkAccelerationStructureDeviceAddressInfoKHR";
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR:
+            return "VkAccelerationStructureVersionInfoKHR";
+        case VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR:
+            return "VkCopyAccelerationStructureToMemoryInfoKHR";
+        case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR:
+            return "VkCopyMemoryToAccelerationStructureInfoKHR";
+        case VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR:
+            return "VkCopyAccelerationStructureInfoKHR";
+        case VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR:
+            return "VkRayTracingShaderGroupCreateInfoKHR";
+        case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR:
+            return "VkRayTracingPipelineInterfaceCreateInfoKHR";
+        case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR:
+            return "VkRayTracingPipelineCreateInfoKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR:
+            return "VkPhysicalDeviceRayTracingPipelineFeaturesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR:
+            return "VkPhysicalDeviceRayTracingPipelinePropertiesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR:
+            return "VkPhysicalDeviceRayQueryFeaturesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT:
+            return "VkPhysicalDeviceMeshShaderFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT:
+            return "VkPhysicalDeviceMeshShaderPropertiesEXT";
+        default:
+            return "Unhandled VkStructureType";
+    }
+}
diff --git a/scripts/generators/enum_string_helper_generator.py b/scripts/generators/enum_string_helper_generator.py
index 28e7e54..053f2ea 100644
--- a/scripts/generators/enum_string_helper_generator.py
+++ b/scripts/generators/enum_string_helper_generator.py
@@ -1,8 +1,8 @@
 #!/usr/bin/python3 -i
 #
-# Copyright 2023 The Khronos Group Inc.
-# Copyright 2023 Valve Corporation
-# Copyright 2023 LunarG, Inc.
+# Copyright 2023-2025 The Khronos Group Inc.
+# Copyright 2023-2025 Valve Corporation
+# Copyright 2023-2025 LunarG, Inc.
 #
 # SPDX-License-Identifier: Apache-2.0
 
@@ -18,9 +18,9 @@ class EnumStringHelperOutputGenerator(BaseGenerator):
         out = []
         out.append(f'''// *** THIS FILE IS GENERATED - DO NOT EDIT ***
 // See {os.path.basename(__file__)} for modifications
-// Copyright 2023 The Khronos Group Inc.
-// Copyright 2023 Valve Corporation
-// Copyright 2023 LunarG, Inc.
+// Copyright 2023-2025 The Khronos Group Inc.
+// Copyright 2023-2025 Valve Corporation
+// Copyright 2023-2025 LunarG, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
 ''')
@@ -112,4 +112,21 @@ static inline std::string string_{bitmask.flagName}({bitmask.flagName} input_val
             out.append('#endif // __cplusplus\n')
         out.extend(guard_helper.add_guard(None))
         out.append('// clang-format on')
+
+        # Special lookup for struct name of VkStructureType (since the sType name is not always that helpful)
+        out.append('''\n
+                   // Same thing as string_VkStructureType, but prints out the API name
+                   static inline const char* string_VkStructureName(VkStructureType input_value) {
+                        switch (input_value) {\n''')
+        struct_guard_helper = PlatformGuardHelper()
+        for struct in [x for x in self.vk.structs.values() if x.sType]:
+            out.extend(struct_guard_helper.add_guard(struct.protect))
+            out.append(f'        case {struct.sType}:\n')
+            out.append(f'            return "{struct.name}";\n')
+        out.append('''    default:
+                            return "Unhandled VkStructureType";
+                        }
+                    }
+                   ''')
+
         self.write("".join(out))

From 03e1445cc7cce22baeeef8eff7bb934362d040eb Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Fri, 30 May 2025 10:21:57 -0700
Subject: [PATCH 105/106] build: Update to header 1.4.316

---
 include/vulkan/utility/vk_format_utils.h    | 61 ++++++++++++++++++++-
 include/vulkan/utility/vk_safe_struct.hpp   | 18 ++++++
 include/vulkan/utility/vk_struct_helper.hpp |  1 +
 include/vulkan/vk_enum_string_helper.h      | 32 +++++++++++
 scripts/known_good.json                     |  2 +-
 src/vulkan/vk_safe_struct_utils.cpp         |  6 ++
 src/vulkan/vk_safe_struct_vendor.cpp        | 48 ++++++++++++++++
 7 files changed, 166 insertions(+), 2 deletions(-)

diff --git a/include/vulkan/utility/vk_format_utils.h b/include/vulkan/utility/vk_format_utils.h
index 6b5e776..d182b05 100644
--- a/include/vulkan/utility/vk_format_utils.h
+++ b/include/vulkan/utility/vk_format_utils.h
@@ -51,6 +51,8 @@ enum VKU_FORMAT_COMPATIBILITY_CLASS {
     VKU_FORMAT_COMPATIBILITY_CLASS_12BIT_3PLANE_420,
     VKU_FORMAT_COMPATIBILITY_CLASS_12BIT_3PLANE_422,
     VKU_FORMAT_COMPATIBILITY_CLASS_12BIT_3PLANE_444,
+    VKU_FORMAT_COMPATIBILITY_CLASS_14BIT_2PLANE_420,
+    VKU_FORMAT_COMPATIBILITY_CLASS_14BIT_2PLANE_422,
     VKU_FORMAT_COMPATIBILITY_CLASS_16BIT,
     VKU_FORMAT_COMPATIBILITY_CLASS_16BIT_2PLANE_420,
     VKU_FORMAT_COMPATIBILITY_CLASS_16BIT_2PLANE_422,
@@ -74,6 +76,7 @@ enum VKU_FORMAT_COMPATIBILITY_CLASS {
     VKU_FORMAT_COMPATIBILITY_CLASS_64BIT_G16B16G16R16,
     VKU_FORMAT_COMPATIBILITY_CLASS_64BIT_R10G10B10A10,
     VKU_FORMAT_COMPATIBILITY_CLASS_64BIT_R12G12B12A12,
+    VKU_FORMAT_COMPATIBILITY_CLASS_64BIT_R14G14B14A14,
     VKU_FORMAT_COMPATIBILITY_CLASS_8BIT,
     VKU_FORMAT_COMPATIBILITY_CLASS_8BIT_2PLANE_420,
     VKU_FORMAT_COMPATIBILITY_CLASS_8BIT_2PLANE_422,
@@ -351,7 +354,7 @@ struct VKU_FORMAT_INFO {
     uint32_t component_count;
     struct VKU_FORMAT_COMPONENT_INFO components[VKU_FORMAT_MAX_COMPONENTS];
 };
-const struct VKU_FORMAT_INFO vku_formats[250] = {
+const struct VKU_FORMAT_INFO vku_formats[264] = {
     { VKU_FORMAT_COMPATIBILITY_CLASS_NONE, 0, 0, {0, 0, 0}, 0, {} },
     { VKU_FORMAT_COMPATIBILITY_CLASS_8BIT, 1, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 4}, {VKU_FORMAT_COMPONENT_TYPE_G, 4}} },
     { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 4}, {VKU_FORMAT_COMPONENT_TYPE_G, 4}, {VKU_FORMAT_COMPONENT_TYPE_B, 4}, {VKU_FORMAT_COMPONENT_TYPE_A, 4}} },
@@ -602,6 +605,20 @@ const struct VKU_FORMAT_INFO vku_formats[250] = {
     { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}} },
     { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 1}, {VKU_FORMAT_COMPONENT_TYPE_B, 5}, {VKU_FORMAT_COMPONENT_TYPE_G, 5}, {VKU_FORMAT_COMPONENT_TYPE_R, 5}} },
     { VKU_FORMAT_COMPATIBILITY_CLASS_8BIT_ALPHA, 1, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_A, 8}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 10}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_64BIT_R10G10B10A10, 8, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 10}, {VKU_FORMAT_COMPONENT_TYPE_G, 10}, {VKU_FORMAT_COMPONENT_TYPE_B, 10}, {VKU_FORMAT_COMPONENT_TYPE_A, 10}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 12}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 12}, {VKU_FORMAT_COMPONENT_TYPE_G, 12}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_64BIT_R12G12B12A12, 8, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 12}, {VKU_FORMAT_COMPONENT_TYPE_G, 12}, {VKU_FORMAT_COMPONENT_TYPE_B, 12}, {VKU_FORMAT_COMPONENT_TYPE_A, 12}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 14}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 14}, {VKU_FORMAT_COMPONENT_TYPE_G, 14}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_64BIT_R14G14B14A14, 8, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 14}, {VKU_FORMAT_COMPONENT_TYPE_G, 14}, {VKU_FORMAT_COMPONENT_TYPE_B, 14}, {VKU_FORMAT_COMPONENT_TYPE_A, 14}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 14}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 14}, {VKU_FORMAT_COMPONENT_TYPE_G, 14}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_64BIT_R14G14B14A14, 8, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 14}, {VKU_FORMAT_COMPONENT_TYPE_G, 14}, {VKU_FORMAT_COMPONENT_TYPE_B, 14}, {VKU_FORMAT_COMPONENT_TYPE_A, 14}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_14BIT_2PLANE_420, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 14}, {VKU_FORMAT_COMPONENT_TYPE_B, 14}, {VKU_FORMAT_COMPONENT_TYPE_R, 14}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_14BIT_2PLANE_422, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 14}, {VKU_FORMAT_COMPONENT_TYPE_B, 14}, {VKU_FORMAT_COMPONENT_TYPE_R, 14}} },
 };
 inline const struct VKU_FORMAT_INFO vkuGetFormatInfo(VkFormat format) {
     if (VK_FORMAT_UNDEFINED <= format && format <= VK_FORMAT_ASTC_12x12_SRGB_BLOCK ) { return vku_formats[format - VK_FORMAT_UNDEFINED + 0]; }
@@ -612,6 +629,7 @@ inline const struct VKU_FORMAT_INFO vkuGetFormatInfo(VkFormat format) {
     else if (VK_FORMAT_A4R4G4B4_UNORM_PACK16 <= format && format <= VK_FORMAT_A4B4G4R4_UNORM_PACK16 ) { return vku_formats[format - VK_FORMAT_A4R4G4B4_UNORM_PACK16 + 245]; }
     else if (VK_FORMAT_R16G16_SFIXED5_NV <= format && format <= VK_FORMAT_R16G16_SFIXED5_NV ) { return vku_formats[format - VK_FORMAT_R16G16_SFIXED5_NV + 247]; }
     else if (VK_FORMAT_A1B5G5R5_UNORM_PACK16 <= format && format <= VK_FORMAT_A8_UNORM ) { return vku_formats[format - VK_FORMAT_A1B5G5R5_UNORM_PACK16 + 248]; }
+    else if (VK_FORMAT_R10X6_UINT_PACK16_ARM <= format && format <= VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM ) { return vku_formats[format - VK_FORMAT_R10X6_UINT_PACK16_ARM + 250]; }
     // Default case - return VK_FORMAT_UNDEFINED
     else {
         return vku_formats[0];
@@ -704,6 +722,12 @@ inline const struct VKU_FORMAT_MULTIPLANE_COMPATIBILITY vkuGetFormatCompatibilit
         case VK_FORMAT_G16_B16R16_2PLANE_444_UNORM: {
             struct VKU_FORMAT_MULTIPLANE_COMPATIBILITY out = {{{1, 1, VK_FORMAT_R16_UNORM }, {1, 1, VK_FORMAT_R16G16_UNORM }, {1, 1, VK_FORMAT_UNDEFINED }}};
             return out; }
+        case VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM: {
+            struct VKU_FORMAT_MULTIPLANE_COMPATIBILITY out = {{{1, 1, VK_FORMAT_R14X2_UNORM_PACK16_ARM }, {2, 2, VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM }, {1, 1, VK_FORMAT_UNDEFINED }}};
+            return out; }
+        case VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM: {
+            struct VKU_FORMAT_MULTIPLANE_COMPATIBILITY out = {{{1, 1, VK_FORMAT_R14X2_UNORM_PACK16_ARM }, {2, 1, VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM }, {1, 1, VK_FORMAT_UNDEFINED }}};
+            return out; }
         default: {
             struct VKU_FORMAT_MULTIPLANE_COMPATIBILITY out = {{{1, 1, VK_FORMAT_UNDEFINED}, {1, 1, VK_FORMAT_UNDEFINED}, {1, 1, VK_FORMAT_UNDEFINED}}};
             return out; }
@@ -914,6 +938,15 @@ bool vkuFormatIsUINT(VkFormat format) {
         case VK_FORMAT_R64G64B64_UINT:
         case VK_FORMAT_R64G64B64A64_UINT:
         case VK_FORMAT_S8_UINT:
+        case VK_FORMAT_R10X6_UINT_PACK16_ARM:
+        case VK_FORMAT_R10X6G10X6_UINT_2PACK16_ARM:
+        case VK_FORMAT_R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM:
+        case VK_FORMAT_R12X4_UINT_PACK16_ARM:
+        case VK_FORMAT_R12X4G12X4_UINT_2PACK16_ARM:
+        case VK_FORMAT_R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM:
+        case VK_FORMAT_R14X2_UINT_PACK16_ARM:
+        case VK_FORMAT_R14X2G14X2_UINT_2PACK16_ARM:
+        case VK_FORMAT_R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM:
             return true;
         default:
             return false;
@@ -1018,6 +1051,11 @@ bool vkuFormatIsUNORM(VkFormat format) {
         case VK_FORMAT_G16_B16R16_2PLANE_444_UNORM:
         case VK_FORMAT_A4R4G4B4_UNORM_PACK16:
         case VK_FORMAT_A4B4G4R4_UNORM_PACK16:
+        case VK_FORMAT_R14X2_UNORM_PACK16_ARM:
+        case VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM:
+        case VK_FORMAT_R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM:
+        case VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM:
+        case VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM:
             return true;
         default:
             return false;
@@ -1363,6 +1401,20 @@ bool vkuFormatIsPacked(VkFormat format) {
         case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16:
         case VK_FORMAT_A4R4G4B4_UNORM_PACK16:
         case VK_FORMAT_A4B4G4R4_UNORM_PACK16:
+        case VK_FORMAT_R10X6_UINT_PACK16_ARM:
+        case VK_FORMAT_R10X6G10X6_UINT_2PACK16_ARM:
+        case VK_FORMAT_R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM:
+        case VK_FORMAT_R12X4_UINT_PACK16_ARM:
+        case VK_FORMAT_R12X4G12X4_UINT_2PACK16_ARM:
+        case VK_FORMAT_R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM:
+        case VK_FORMAT_R14X2_UINT_PACK16_ARM:
+        case VK_FORMAT_R14X2G14X2_UINT_2PACK16_ARM:
+        case VK_FORMAT_R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM:
+        case VK_FORMAT_R14X2_UNORM_PACK16_ARM:
+        case VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM:
+        case VK_FORMAT_R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM:
+        case VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM:
+        case VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM:
             return true;
         default:
             return false;
@@ -1408,6 +1460,8 @@ bool vkuFormatRequiresYcbcrConversion(VkFormat format) {
         case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16:
         case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16:
         case VK_FORMAT_G16_B16R16_2PLANE_444_UNORM:
+        case VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM:
+        case VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM:
             return true;
         default:
             return false;
@@ -1440,6 +1494,8 @@ bool vkuFormatIsXChromaSubsampled(VkFormat format) {
         case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
         case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
         case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
+        case VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM:
+        case VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM:
             return true;
         default:
             return false;
@@ -1456,6 +1512,7 @@ bool vkuFormatIsYChromaSubsampled(VkFormat format) {
         case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
         case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
         case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
+        case VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM:
             return true;
         default:
             return false;
@@ -1493,6 +1550,8 @@ uint32_t vkuFormatPlaneCount(VkFormat format) {
         case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16:
         case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16:
         case VK_FORMAT_G16_B16R16_2PLANE_444_UNORM:
+        case VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM:
+        case VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM:
             return 2;
         case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
         case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index 1092242..32358f7 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -20593,6 +20593,24 @@ struct safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT {
         return reinterpret_cast<VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT const*>(this);
     }
 };
+struct safe_VkPhysicalDeviceFormatPackFeaturesARM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 formatPack;
+
+    safe_VkPhysicalDeviceFormatPackFeaturesARM(const VkPhysicalDeviceFormatPackFeaturesARM* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceFormatPackFeaturesARM(const safe_VkPhysicalDeviceFormatPackFeaturesARM& copy_src);
+    safe_VkPhysicalDeviceFormatPackFeaturesARM& operator=(const safe_VkPhysicalDeviceFormatPackFeaturesARM& copy_src);
+    safe_VkPhysicalDeviceFormatPackFeaturesARM();
+    ~safe_VkPhysicalDeviceFormatPackFeaturesARM();
+    void initialize(const VkPhysicalDeviceFormatPackFeaturesARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceFormatPackFeaturesARM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceFormatPackFeaturesARM* ptr() { return reinterpret_cast<VkPhysicalDeviceFormatPackFeaturesARM*>(this); }
+    VkPhysicalDeviceFormatPackFeaturesARM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceFormatPackFeaturesARM const*>(this);
+    }
+};
 #ifdef VK_ENABLE_BETA_EXTENSIONS
 struct safe_VkSetPresentConfigNV {
     VkStructureType sType;
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index 1c77fba..581f997 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -1069,6 +1069,7 @@ template <> inline VkStructureType GetSType<VkMemoryMetalHandlePropertiesEXT>()
 template <> inline VkStructureType GetSType<VkMemoryGetMetalHandleInfoEXT>() { return VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT; }
 #endif  // VK_USE_PLATFORM_METAL_EXT
 template <> inline VkStructureType GetSType<VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceFormatPackFeaturesARM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM; }
 #ifdef VK_ENABLE_BETA_EXTENSIONS
 template <> inline VkStructureType GetSType<VkSetPresentConfigNV>() { return VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDevicePresentMeteringFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index 680f218..4921053 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -2152,6 +2152,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR:
@@ -2918,6 +2920,34 @@ static inline const char* string_VkFormat(VkFormat input_value) {
             return "VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG";
         case VK_FORMAT_R16G16_SFIXED5_NV:
             return "VK_FORMAT_R16G16_SFIXED5_NV";
+        case VK_FORMAT_R10X6_UINT_PACK16_ARM:
+            return "VK_FORMAT_R10X6_UINT_PACK16_ARM";
+        case VK_FORMAT_R10X6G10X6_UINT_2PACK16_ARM:
+            return "VK_FORMAT_R10X6G10X6_UINT_2PACK16_ARM";
+        case VK_FORMAT_R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM:
+            return "VK_FORMAT_R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM";
+        case VK_FORMAT_R12X4_UINT_PACK16_ARM:
+            return "VK_FORMAT_R12X4_UINT_PACK16_ARM";
+        case VK_FORMAT_R12X4G12X4_UINT_2PACK16_ARM:
+            return "VK_FORMAT_R12X4G12X4_UINT_2PACK16_ARM";
+        case VK_FORMAT_R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM:
+            return "VK_FORMAT_R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM";
+        case VK_FORMAT_R14X2_UINT_PACK16_ARM:
+            return "VK_FORMAT_R14X2_UINT_PACK16_ARM";
+        case VK_FORMAT_R14X2G14X2_UINT_2PACK16_ARM:
+            return "VK_FORMAT_R14X2G14X2_UINT_2PACK16_ARM";
+        case VK_FORMAT_R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM:
+            return "VK_FORMAT_R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM";
+        case VK_FORMAT_R14X2_UNORM_PACK16_ARM:
+            return "VK_FORMAT_R14X2_UNORM_PACK16_ARM";
+        case VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM:
+            return "VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM";
+        case VK_FORMAT_R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM:
+            return "VK_FORMAT_R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM";
+        case VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM:
+            return "VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM";
+        case VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM:
+            return "VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM";
         default:
             return "Unhandled VkFormat";
     }
@@ -12407,6 +12437,8 @@ static inline const char* string_VkStructureName(VkStructureType input_value) {
 #endif  // VK_USE_PLATFORM_METAL_EXT
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
             return "VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM:
+            return "VkPhysicalDeviceFormatPackFeaturesARM";
 #ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV:
             return "VkSetPresentConfigNV";
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 258ff02..71c8952 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.4.315"
+            "commit": "v1.4.316"
         },
         {
             "name": "googletest",
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index 095c758..79e058c 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -2060,6 +2060,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
                 safe_pNext = new safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM:
+                safe_pNext = new safe_VkPhysicalDeviceFormatPackFeaturesARM(reinterpret_cast<const VkPhysicalDeviceFormatPackFeaturesARM *>(pNext), copy_state, false);
+                break;
 #ifdef VK_ENABLE_BETA_EXTENSIONS
             case VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV:
                 safe_pNext = new safe_VkSetPresentConfigNV(reinterpret_cast<const VkSetPresentConfigNV *>(pNext), copy_state, false);
@@ -4147,6 +4150,9 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT:
             delete reinterpret_cast<safe_VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM:
+            delete reinterpret_cast<safe_VkPhysicalDeviceFormatPackFeaturesARM *>(header);
+            break;
 #ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV:
             delete reinterpret_cast<safe_VkSetPresentConfigNV *>(header);
diff --git a/src/vulkan/vk_safe_struct_vendor.cpp b/src/vulkan/vk_safe_struct_vendor.cpp
index 8d84afd..9891ca4 100644
--- a/src/vulkan/vk_safe_struct_vendor.cpp
+++ b/src/vulkan/vk_safe_struct_vendor.cpp
@@ -18338,6 +18338,54 @@ void safe_VkPhysicalDevicePipelineOpacityMicromapFeaturesARM::initialize(
     pipelineOpacityMicromap = copy_src->pipelineOpacityMicromap;
     pNext = SafePnextCopy(copy_src->pNext);
 }
+
+safe_VkPhysicalDeviceFormatPackFeaturesARM::safe_VkPhysicalDeviceFormatPackFeaturesARM(
+    const VkPhysicalDeviceFormatPackFeaturesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), formatPack(in_struct->formatPack) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceFormatPackFeaturesARM::safe_VkPhysicalDeviceFormatPackFeaturesARM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM), pNext(nullptr), formatPack() {}
+
+safe_VkPhysicalDeviceFormatPackFeaturesARM::safe_VkPhysicalDeviceFormatPackFeaturesARM(
+    const safe_VkPhysicalDeviceFormatPackFeaturesARM& copy_src) {
+    sType = copy_src.sType;
+    formatPack = copy_src.formatPack;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceFormatPackFeaturesARM& safe_VkPhysicalDeviceFormatPackFeaturesARM::operator=(
+    const safe_VkPhysicalDeviceFormatPackFeaturesARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    formatPack = copy_src.formatPack;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceFormatPackFeaturesARM::~safe_VkPhysicalDeviceFormatPackFeaturesARM() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceFormatPackFeaturesARM::initialize(const VkPhysicalDeviceFormatPackFeaturesARM* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    formatPack = in_struct->formatPack;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceFormatPackFeaturesARM::initialize(const safe_VkPhysicalDeviceFormatPackFeaturesARM* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    formatPack = copy_src->formatPack;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
 #ifdef VK_ENABLE_BETA_EXTENSIONS
 
 safe_VkSetPresentConfigNV::safe_VkSetPresentConfigNV(const VkSetPresentConfigNV* in_struct,

From e48ae20a7938b01aee62806bfcdafe8a0883b1e4 Mon Sep 17 00:00:00 2001
From: Mike Schuchardt <mikes@lunarg.com>
Date: Fri, 6 Jun 2025 08:37:59 -0700
Subject: [PATCH 106/106] build: Update to header 1.4.317

---
 include/vulkan/utility/vk_dispatch_table.h  |   24 +
 include/vulkan/utility/vk_format_utils.h    |   26 +-
 include/vulkan/utility/vk_safe_struct.hpp   |  747 ++++++++
 include/vulkan/utility/vk_struct_helper.hpp |   42 +
 include/vulkan/vk_enum_string_helper.h      |  335 +++-
 scripts/known_good.json                     |    2 +-
 src/vulkan/vk_safe_struct_ext.cpp           |  105 ++
 src/vulkan/vk_safe_struct_khr.cpp           |  789 +++++++++
 src/vulkan/vk_safe_struct_utils.cpp         |  162 ++
 src/vulkan/vk_safe_struct_vendor.cpp        | 1775 +++++++++++++++++++
 10 files changed, 3984 insertions(+), 23 deletions(-)

diff --git a/include/vulkan/utility/vk_dispatch_table.h b/include/vulkan/utility/vk_dispatch_table.h
index 1c0f82a..1a4a031 100644
--- a/include/vulkan/utility/vk_dispatch_table.h
+++ b/include/vulkan/utility/vk_dispatch_table.h
@@ -160,6 +160,7 @@ typedef struct VkuInstanceDispatchTable_ {
     PFN_vkCreateScreenSurfaceQNX CreateScreenSurfaceQNX;
     PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX GetPhysicalDeviceScreenPresentationSupportQNX;
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
+    PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM GetPhysicalDeviceExternalTensorPropertiesARM;
     PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV GetPhysicalDeviceOpticalFlowImageFormatsNV;
     PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV GetPhysicalDeviceCooperativeVectorPropertiesNV;
     PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV;
@@ -480,6 +481,7 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkGetRenderingAreaGranularityKHR GetRenderingAreaGranularityKHR;
     PFN_vkGetDeviceImageSubresourceLayoutKHR GetDeviceImageSubresourceLayoutKHR;
     PFN_vkGetImageSubresourceLayout2KHR GetImageSubresourceLayout2KHR;
+    PFN_vkWaitForPresent2KHR WaitForPresent2KHR;
     PFN_vkCreatePipelineBinariesKHR CreatePipelineBinariesKHR;
     PFN_vkDestroyPipelineBinaryKHR DestroyPipelineBinaryKHR;
     PFN_vkGetPipelineKeyKHR GetPipelineKeyKHR;
@@ -742,6 +744,16 @@ typedef struct VkuDeviceDispatchTable_ {
     PFN_vkCmdSetShadingRateImageEnableNV CmdSetShadingRateImageEnableNV;
     PFN_vkCmdSetRepresentativeFragmentTestEnableNV CmdSetRepresentativeFragmentTestEnableNV;
     PFN_vkCmdSetCoverageReductionModeNV CmdSetCoverageReductionModeNV;
+    PFN_vkCreateTensorARM CreateTensorARM;
+    PFN_vkDestroyTensorARM DestroyTensorARM;
+    PFN_vkCreateTensorViewARM CreateTensorViewARM;
+    PFN_vkDestroyTensorViewARM DestroyTensorViewARM;
+    PFN_vkGetTensorMemoryRequirementsARM GetTensorMemoryRequirementsARM;
+    PFN_vkBindTensorMemoryARM BindTensorMemoryARM;
+    PFN_vkGetDeviceTensorMemoryRequirementsARM GetDeviceTensorMemoryRequirementsARM;
+    PFN_vkCmdCopyTensorARM CmdCopyTensorARM;
+    PFN_vkGetTensorOpaqueCaptureDescriptorDataARM GetTensorOpaqueCaptureDescriptorDataARM;
+    PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM GetTensorViewOpaqueCaptureDescriptorDataARM;
     PFN_vkGetShaderModuleIdentifierEXT GetShaderModuleIdentifierEXT;
     PFN_vkGetShaderModuleCreateInfoIdentifierEXT GetShaderModuleCreateInfoIdentifierEXT;
     PFN_vkCreateOpticalFlowSessionNV CreateOpticalFlowSessionNV;
@@ -1132,6 +1144,7 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
     table->GetRenderingAreaGranularityKHR = (PFN_vkGetRenderingAreaGranularityKHR)gdpa(device, "vkGetRenderingAreaGranularityKHR");
     table->GetDeviceImageSubresourceLayoutKHR = (PFN_vkGetDeviceImageSubresourceLayoutKHR)gdpa(device, "vkGetDeviceImageSubresourceLayoutKHR");
     table->GetImageSubresourceLayout2KHR = (PFN_vkGetImageSubresourceLayout2KHR)gdpa(device, "vkGetImageSubresourceLayout2KHR");
+    table->WaitForPresent2KHR = (PFN_vkWaitForPresent2KHR)gdpa(device, "vkWaitForPresent2KHR");
     table->CreatePipelineBinariesKHR = (PFN_vkCreatePipelineBinariesKHR)gdpa(device, "vkCreatePipelineBinariesKHR");
     table->DestroyPipelineBinaryKHR = (PFN_vkDestroyPipelineBinaryKHR)gdpa(device, "vkDestroyPipelineBinaryKHR");
     table->GetPipelineKeyKHR = (PFN_vkGetPipelineKeyKHR)gdpa(device, "vkGetPipelineKeyKHR");
@@ -1394,6 +1407,16 @@ static inline void vkuInitDeviceDispatchTable(VkDevice device, VkuDeviceDispatch
     table->CmdSetShadingRateImageEnableNV = (PFN_vkCmdSetShadingRateImageEnableNV)gdpa(device, "vkCmdSetShadingRateImageEnableNV");
     table->CmdSetRepresentativeFragmentTestEnableNV = (PFN_vkCmdSetRepresentativeFragmentTestEnableNV)gdpa(device, "vkCmdSetRepresentativeFragmentTestEnableNV");
     table->CmdSetCoverageReductionModeNV = (PFN_vkCmdSetCoverageReductionModeNV)gdpa(device, "vkCmdSetCoverageReductionModeNV");
+    table->CreateTensorARM = (PFN_vkCreateTensorARM)gdpa(device, "vkCreateTensorARM");
+    table->DestroyTensorARM = (PFN_vkDestroyTensorARM)gdpa(device, "vkDestroyTensorARM");
+    table->CreateTensorViewARM = (PFN_vkCreateTensorViewARM)gdpa(device, "vkCreateTensorViewARM");
+    table->DestroyTensorViewARM = (PFN_vkDestroyTensorViewARM)gdpa(device, "vkDestroyTensorViewARM");
+    table->GetTensorMemoryRequirementsARM = (PFN_vkGetTensorMemoryRequirementsARM)gdpa(device, "vkGetTensorMemoryRequirementsARM");
+    table->BindTensorMemoryARM = (PFN_vkBindTensorMemoryARM)gdpa(device, "vkBindTensorMemoryARM");
+    table->GetDeviceTensorMemoryRequirementsARM = (PFN_vkGetDeviceTensorMemoryRequirementsARM)gdpa(device, "vkGetDeviceTensorMemoryRequirementsARM");
+    table->CmdCopyTensorARM = (PFN_vkCmdCopyTensorARM)gdpa(device, "vkCmdCopyTensorARM");
+    table->GetTensorOpaqueCaptureDescriptorDataARM = (PFN_vkGetTensorOpaqueCaptureDescriptorDataARM)gdpa(device, "vkGetTensorOpaqueCaptureDescriptorDataARM");
+    table->GetTensorViewOpaqueCaptureDescriptorDataARM = (PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM)gdpa(device, "vkGetTensorViewOpaqueCaptureDescriptorDataARM");
     table->GetShaderModuleIdentifierEXT = (PFN_vkGetShaderModuleIdentifierEXT)gdpa(device, "vkGetShaderModuleIdentifierEXT");
     table->GetShaderModuleCreateInfoIdentifierEXT = (PFN_vkGetShaderModuleCreateInfoIdentifierEXT)gdpa(device, "vkGetShaderModuleCreateInfoIdentifierEXT");
     table->CreateOpticalFlowSessionNV = (PFN_vkCreateOpticalFlowSessionNV)gdpa(device, "vkCreateOpticalFlowSessionNV");
@@ -1607,6 +1630,7 @@ static inline void vkuInitInstanceDispatchTable(VkInstance instance, VkuInstance
     table->CreateScreenSurfaceQNX = (PFN_vkCreateScreenSurfaceQNX)gipa(instance, "vkCreateScreenSurfaceQNX");
     table->GetPhysicalDeviceScreenPresentationSupportQNX = (PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX)gipa(instance, "vkGetPhysicalDeviceScreenPresentationSupportQNX");
 #endif  // VK_USE_PLATFORM_SCREEN_QNX
+    table->GetPhysicalDeviceExternalTensorPropertiesARM = (PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM)gipa(instance, "vkGetPhysicalDeviceExternalTensorPropertiesARM");
     table->GetPhysicalDeviceOpticalFlowImageFormatsNV = (PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV)gipa(instance, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV");
     table->GetPhysicalDeviceCooperativeVectorPropertiesNV = (PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV)gipa(instance, "vkGetPhysicalDeviceCooperativeVectorPropertiesNV");
     table->GetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = (PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV)gipa(instance, "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV");
diff --git a/include/vulkan/utility/vk_format_utils.h b/include/vulkan/utility/vk_format_utils.h
index d182b05..177c97c 100644
--- a/include/vulkan/utility/vk_format_utils.h
+++ b/include/vulkan/utility/vk_format_utils.h
@@ -24,6 +24,7 @@ extern "C" {
 
 enum VKU_FORMAT_NUMERICAL_TYPE {
     VKU_FORMAT_NUMERICAL_TYPE_NONE = 0,
+    VKU_FORMAT_NUMERICAL_TYPE_BOOL,
     VKU_FORMAT_NUMERICAL_TYPE_SFIXED5,
     VKU_FORMAT_NUMERICAL_TYPE_SFLOAT,
     VKU_FORMAT_NUMERICAL_TYPE_SINT,
@@ -132,6 +133,10 @@ enum VKU_FORMAT_COMPATIBILITY_CLASS {
 //     <any other value> -> VKU_FORMAT_INVALID_INDEX
 inline uint32_t vkuGetPlaneIndex(VkImageAspectFlagBits aspect);
 
+// Returns whether a VkFormat is of the numerical format BOOL
+// Format must only contain one numerical format, so formats like D16_UNORM_S8_UINT always return false
+inline bool vkuFormatIsBOOL(VkFormat format);
+
 // Returns whether a VkFormat is of the numerical format SFIXED5
 // Format must only contain one numerical format, so formats like D16_UNORM_S8_UINT always return false
 inline bool vkuFormatIsSFIXED5(VkFormat format);
@@ -354,7 +359,7 @@ struct VKU_FORMAT_INFO {
     uint32_t component_count;
     struct VKU_FORMAT_COMPONENT_INFO components[VKU_FORMAT_MAX_COMPONENTS];
 };
-const struct VKU_FORMAT_INFO vku_formats[264] = {
+const struct VKU_FORMAT_INFO vku_formats[265] = {
     { VKU_FORMAT_COMPATIBILITY_CLASS_NONE, 0, 0, {0, 0, 0}, 0, {} },
     { VKU_FORMAT_COMPATIBILITY_CLASS_8BIT, 1, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 4}, {VKU_FORMAT_COMPONENT_TYPE_G, 4}} },
     { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_R, 4}, {VKU_FORMAT_COMPONENT_TYPE_G, 4}, {VKU_FORMAT_COMPONENT_TYPE_B, 4}, {VKU_FORMAT_COMPONENT_TYPE_A, 4}} },
@@ -602,6 +607,7 @@ const struct VKU_FORMAT_INFO vku_formats[264] = {
     { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT_2PLANE_444, 6, 1, {1, 1, 1}, 3, {{VKU_FORMAT_COMPONENT_TYPE_G, 16}, {VKU_FORMAT_COMPONENT_TYPE_B, 16}, {VKU_FORMAT_COMPONENT_TYPE_R, 16}} },
     { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 4}, {VKU_FORMAT_COMPONENT_TYPE_R, 4}, {VKU_FORMAT_COMPONENT_TYPE_G, 4}, {VKU_FORMAT_COMPONENT_TYPE_B, 4}} },
     { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 4}, {VKU_FORMAT_COMPONENT_TYPE_B, 4}, {VKU_FORMAT_COMPONENT_TYPE_G, 4}, {VKU_FORMAT_COMPONENT_TYPE_R, 4}} },
+    { VKU_FORMAT_COMPATIBILITY_CLASS_8BIT, 1, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_R, 8}} },
     { VKU_FORMAT_COMPATIBILITY_CLASS_32BIT, 4, 1, {1, 1, 1}, 2, {{VKU_FORMAT_COMPONENT_TYPE_R, 16}, {VKU_FORMAT_COMPONENT_TYPE_G, 16}} },
     { VKU_FORMAT_COMPATIBILITY_CLASS_16BIT, 2, 1, {1, 1, 1}, 4, {{VKU_FORMAT_COMPONENT_TYPE_A, 1}, {VKU_FORMAT_COMPONENT_TYPE_B, 5}, {VKU_FORMAT_COMPONENT_TYPE_G, 5}, {VKU_FORMAT_COMPONENT_TYPE_R, 5}} },
     { VKU_FORMAT_COMPATIBILITY_CLASS_8BIT_ALPHA, 1, 1, {1, 1, 1}, 1, {{VKU_FORMAT_COMPONENT_TYPE_A, 8}} },
@@ -627,9 +633,10 @@ inline const struct VKU_FORMAT_INFO vkuGetFormatInfo(VkFormat format) {
     else if (VK_FORMAT_G8B8G8R8_422_UNORM <= format && format <= VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM ) { return vku_formats[format - VK_FORMAT_G8B8G8R8_422_UNORM + 207]; }
     else if (VK_FORMAT_G8_B8R8_2PLANE_444_UNORM <= format && format <= VK_FORMAT_G16_B16R16_2PLANE_444_UNORM ) { return vku_formats[format - VK_FORMAT_G8_B8R8_2PLANE_444_UNORM + 241]; }
     else if (VK_FORMAT_A4R4G4B4_UNORM_PACK16 <= format && format <= VK_FORMAT_A4B4G4R4_UNORM_PACK16 ) { return vku_formats[format - VK_FORMAT_A4R4G4B4_UNORM_PACK16 + 245]; }
-    else if (VK_FORMAT_R16G16_SFIXED5_NV <= format && format <= VK_FORMAT_R16G16_SFIXED5_NV ) { return vku_formats[format - VK_FORMAT_R16G16_SFIXED5_NV + 247]; }
-    else if (VK_FORMAT_A1B5G5R5_UNORM_PACK16 <= format && format <= VK_FORMAT_A8_UNORM ) { return vku_formats[format - VK_FORMAT_A1B5G5R5_UNORM_PACK16 + 248]; }
-    else if (VK_FORMAT_R10X6_UINT_PACK16_ARM <= format && format <= VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM ) { return vku_formats[format - VK_FORMAT_R10X6_UINT_PACK16_ARM + 250]; }
+    else if (VK_FORMAT_R8_BOOL_ARM <= format && format <= VK_FORMAT_R8_BOOL_ARM ) { return vku_formats[format - VK_FORMAT_R8_BOOL_ARM + 247]; }
+    else if (VK_FORMAT_R16G16_SFIXED5_NV <= format && format <= VK_FORMAT_R16G16_SFIXED5_NV ) { return vku_formats[format - VK_FORMAT_R16G16_SFIXED5_NV + 248]; }
+    else if (VK_FORMAT_A1B5G5R5_UNORM_PACK16 <= format && format <= VK_FORMAT_A8_UNORM ) { return vku_formats[format - VK_FORMAT_A1B5G5R5_UNORM_PACK16 + 249]; }
+    else if (VK_FORMAT_R10X6_UINT_PACK16_ARM <= format && format <= VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM ) { return vku_formats[format - VK_FORMAT_R10X6_UINT_PACK16_ARM + 251]; }
     // Default case - return VK_FORMAT_UNDEFINED
     else {
         return vku_formats[0];
@@ -734,6 +741,16 @@ inline const struct VKU_FORMAT_MULTIPLANE_COMPATIBILITY vkuGetFormatCompatibilit
     };
 }
 
+// Return true if all components in a format are an BOOL
+bool vkuFormatIsBOOL(VkFormat format) {
+    switch (format) {
+        case VK_FORMAT_R8_BOOL_ARM:
+            return true;
+        default:
+            return false;
+    }
+}
+
 // Return true if all components in a format are an SFIXED5
 bool vkuFormatIsSFIXED5(VkFormat format) {
     switch (format) {
@@ -1693,6 +1710,7 @@ inline bool vkuFormatIs8bit(VkFormat format) {
         case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
         case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM:
         case VK_FORMAT_G8_B8R8_2PLANE_444_UNORM:
+        case VK_FORMAT_R8_BOOL_ARM:
             return true;
         default:
             return false;
diff --git a/include/vulkan/utility/vk_safe_struct.hpp b/include/vulkan/utility/vk_safe_struct.hpp
index 32358f7..6efbbf3 100644
--- a/include/vulkan/utility/vk_safe_struct.hpp
+++ b/include/vulkan/utility/vk_safe_struct.hpp
@@ -8488,6 +8488,110 @@ struct safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR {
         return reinterpret_cast<VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const*>(this);
     }
 };
+struct safe_VkSurfaceCapabilitiesPresentId2KHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 presentId2Supported;
+
+    safe_VkSurfaceCapabilitiesPresentId2KHR(const VkSurfaceCapabilitiesPresentId2KHR* in_struct, PNextCopyState* copy_state = {},
+                                            bool copy_pnext = true);
+    safe_VkSurfaceCapabilitiesPresentId2KHR(const safe_VkSurfaceCapabilitiesPresentId2KHR& copy_src);
+    safe_VkSurfaceCapabilitiesPresentId2KHR& operator=(const safe_VkSurfaceCapabilitiesPresentId2KHR& copy_src);
+    safe_VkSurfaceCapabilitiesPresentId2KHR();
+    ~safe_VkSurfaceCapabilitiesPresentId2KHR();
+    void initialize(const VkSurfaceCapabilitiesPresentId2KHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSurfaceCapabilitiesPresentId2KHR* copy_src, PNextCopyState* copy_state = {});
+    VkSurfaceCapabilitiesPresentId2KHR* ptr() { return reinterpret_cast<VkSurfaceCapabilitiesPresentId2KHR*>(this); }
+    VkSurfaceCapabilitiesPresentId2KHR const* ptr() const {
+        return reinterpret_cast<VkSurfaceCapabilitiesPresentId2KHR const*>(this);
+    }
+};
+struct safe_VkPresentId2KHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t swapchainCount;
+    const uint64_t* pPresentIds{};
+
+    safe_VkPresentId2KHR(const VkPresentId2KHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPresentId2KHR(const safe_VkPresentId2KHR& copy_src);
+    safe_VkPresentId2KHR& operator=(const safe_VkPresentId2KHR& copy_src);
+    safe_VkPresentId2KHR();
+    ~safe_VkPresentId2KHR();
+    void initialize(const VkPresentId2KHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPresentId2KHR* copy_src, PNextCopyState* copy_state = {});
+    VkPresentId2KHR* ptr() { return reinterpret_cast<VkPresentId2KHR*>(this); }
+    VkPresentId2KHR const* ptr() const { return reinterpret_cast<VkPresentId2KHR const*>(this); }
+};
+struct safe_VkPhysicalDevicePresentId2FeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 presentId2;
+
+    safe_VkPhysicalDevicePresentId2FeaturesKHR(const VkPhysicalDevicePresentId2FeaturesKHR* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDevicePresentId2FeaturesKHR(const safe_VkPhysicalDevicePresentId2FeaturesKHR& copy_src);
+    safe_VkPhysicalDevicePresentId2FeaturesKHR& operator=(const safe_VkPhysicalDevicePresentId2FeaturesKHR& copy_src);
+    safe_VkPhysicalDevicePresentId2FeaturesKHR();
+    ~safe_VkPhysicalDevicePresentId2FeaturesKHR();
+    void initialize(const VkPhysicalDevicePresentId2FeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePresentId2FeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePresentId2FeaturesKHR* ptr() { return reinterpret_cast<VkPhysicalDevicePresentId2FeaturesKHR*>(this); }
+    VkPhysicalDevicePresentId2FeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePresentId2FeaturesKHR const*>(this);
+    }
+};
+struct safe_VkSurfaceCapabilitiesPresentWait2KHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 presentWait2Supported;
+
+    safe_VkSurfaceCapabilitiesPresentWait2KHR(const VkSurfaceCapabilitiesPresentWait2KHR* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkSurfaceCapabilitiesPresentWait2KHR(const safe_VkSurfaceCapabilitiesPresentWait2KHR& copy_src);
+    safe_VkSurfaceCapabilitiesPresentWait2KHR& operator=(const safe_VkSurfaceCapabilitiesPresentWait2KHR& copy_src);
+    safe_VkSurfaceCapabilitiesPresentWait2KHR();
+    ~safe_VkSurfaceCapabilitiesPresentWait2KHR();
+    void initialize(const VkSurfaceCapabilitiesPresentWait2KHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkSurfaceCapabilitiesPresentWait2KHR* copy_src, PNextCopyState* copy_state = {});
+    VkSurfaceCapabilitiesPresentWait2KHR* ptr() { return reinterpret_cast<VkSurfaceCapabilitiesPresentWait2KHR*>(this); }
+    VkSurfaceCapabilitiesPresentWait2KHR const* ptr() const {
+        return reinterpret_cast<VkSurfaceCapabilitiesPresentWait2KHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDevicePresentWait2FeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 presentWait2;
+
+    safe_VkPhysicalDevicePresentWait2FeaturesKHR(const VkPhysicalDevicePresentWait2FeaturesKHR* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDevicePresentWait2FeaturesKHR(const safe_VkPhysicalDevicePresentWait2FeaturesKHR& copy_src);
+    safe_VkPhysicalDevicePresentWait2FeaturesKHR& operator=(const safe_VkPhysicalDevicePresentWait2FeaturesKHR& copy_src);
+    safe_VkPhysicalDevicePresentWait2FeaturesKHR();
+    ~safe_VkPhysicalDevicePresentWait2FeaturesKHR();
+    void initialize(const VkPhysicalDevicePresentWait2FeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDevicePresentWait2FeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDevicePresentWait2FeaturesKHR* ptr() { return reinterpret_cast<VkPhysicalDevicePresentWait2FeaturesKHR*>(this); }
+    VkPhysicalDevicePresentWait2FeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDevicePresentWait2FeaturesKHR const*>(this);
+    }
+};
+struct safe_VkPresentWait2InfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    uint64_t presentId;
+    uint64_t timeout;
+
+    safe_VkPresentWait2InfoKHR(const VkPresentWait2InfoKHR* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPresentWait2InfoKHR(const safe_VkPresentWait2InfoKHR& copy_src);
+    safe_VkPresentWait2InfoKHR& operator=(const safe_VkPresentWait2InfoKHR& copy_src);
+    safe_VkPresentWait2InfoKHR();
+    ~safe_VkPresentWait2InfoKHR();
+    void initialize(const VkPresentWait2InfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPresentWait2InfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPresentWait2InfoKHR* ptr() { return reinterpret_cast<VkPresentWait2InfoKHR*>(this); }
+    VkPresentWait2InfoKHR const* ptr() const { return reinterpret_cast<VkPresentWait2InfoKHR const*>(this); }
+};
 struct safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR {
     VkStructureType sType;
     void* pNext{};
@@ -9172,6 +9276,76 @@ struct safe_VkVideoEncodeAV1RateControlLayerInfoKHR {
         return reinterpret_cast<VkVideoEncodeAV1RateControlLayerInfoKHR const*>(this);
     }
 };
+struct safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 videoDecodeVP9;
+
+    safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR(const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR(const safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR& operator=(const safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR();
+    ~safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR();
+    void initialize(const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceVideoDecodeVP9FeaturesKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceVideoDecodeVP9FeaturesKHR*>(this); }
+    VkPhysicalDeviceVideoDecodeVP9FeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceVideoDecodeVP9FeaturesKHR const*>(this);
+    }
+};
+struct safe_VkVideoDecodeVP9ProfileInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    StdVideoVP9Profile stdProfile;
+
+    safe_VkVideoDecodeVP9ProfileInfoKHR(const VkVideoDecodeVP9ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkVideoDecodeVP9ProfileInfoKHR(const safe_VkVideoDecodeVP9ProfileInfoKHR& copy_src);
+    safe_VkVideoDecodeVP9ProfileInfoKHR& operator=(const safe_VkVideoDecodeVP9ProfileInfoKHR& copy_src);
+    safe_VkVideoDecodeVP9ProfileInfoKHR();
+    ~safe_VkVideoDecodeVP9ProfileInfoKHR();
+    void initialize(const VkVideoDecodeVP9ProfileInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoDecodeVP9ProfileInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeVP9ProfileInfoKHR* ptr() { return reinterpret_cast<VkVideoDecodeVP9ProfileInfoKHR*>(this); }
+    VkVideoDecodeVP9ProfileInfoKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeVP9ProfileInfoKHR const*>(this); }
+};
+struct safe_VkVideoDecodeVP9CapabilitiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    StdVideoVP9Level maxLevel;
+
+    safe_VkVideoDecodeVP9CapabilitiesKHR(const VkVideoDecodeVP9CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkVideoDecodeVP9CapabilitiesKHR(const safe_VkVideoDecodeVP9CapabilitiesKHR& copy_src);
+    safe_VkVideoDecodeVP9CapabilitiesKHR& operator=(const safe_VkVideoDecodeVP9CapabilitiesKHR& copy_src);
+    safe_VkVideoDecodeVP9CapabilitiesKHR();
+    ~safe_VkVideoDecodeVP9CapabilitiesKHR();
+    void initialize(const VkVideoDecodeVP9CapabilitiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoDecodeVP9CapabilitiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeVP9CapabilitiesKHR* ptr() { return reinterpret_cast<VkVideoDecodeVP9CapabilitiesKHR*>(this); }
+    VkVideoDecodeVP9CapabilitiesKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeVP9CapabilitiesKHR const*>(this); }
+};
+struct safe_VkVideoDecodeVP9PictureInfoKHR {
+    VkStructureType sType;
+    const void* pNext{};
+    const StdVideoDecodeVP9PictureInfo* pStdPictureInfo{};
+    int32_t referenceNameSlotIndices[VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR];
+    uint32_t uncompressedHeaderOffset;
+    uint32_t compressedHeaderOffset;
+    uint32_t tilesOffset;
+
+    safe_VkVideoDecodeVP9PictureInfoKHR(const VkVideoDecodeVP9PictureInfoKHR* in_struct, PNextCopyState* copy_state = {},
+                                        bool copy_pnext = true);
+    safe_VkVideoDecodeVP9PictureInfoKHR(const safe_VkVideoDecodeVP9PictureInfoKHR& copy_src);
+    safe_VkVideoDecodeVP9PictureInfoKHR& operator=(const safe_VkVideoDecodeVP9PictureInfoKHR& copy_src);
+    safe_VkVideoDecodeVP9PictureInfoKHR();
+    ~safe_VkVideoDecodeVP9PictureInfoKHR();
+    void initialize(const VkVideoDecodeVP9PictureInfoKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkVideoDecodeVP9PictureInfoKHR* copy_src, PNextCopyState* copy_state = {});
+    VkVideoDecodeVP9PictureInfoKHR* ptr() { return reinterpret_cast<VkVideoDecodeVP9PictureInfoKHR*>(this); }
+    VkVideoDecodeVP9PictureInfoKHR const* ptr() const { return reinterpret_cast<VkVideoDecodeVP9PictureInfoKHR const*>(this); }
+};
 struct safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR {
     VkStructureType sType;
     void* pNext{};
@@ -9210,6 +9384,44 @@ struct safe_VkVideoInlineQueryInfoKHR {
     VkVideoInlineQueryInfoKHR* ptr() { return reinterpret_cast<VkVideoInlineQueryInfoKHR*>(this); }
     VkVideoInlineQueryInfoKHR const* ptr() const { return reinterpret_cast<VkVideoInlineQueryInfoKHR const*>(this); }
 };
+struct safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 unifiedImageLayouts;
+    VkBool32 unifiedImageLayoutsVideo;
+
+    safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR(const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR* in_struct,
+                                                        PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR(const safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR& operator=(
+        const safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR();
+    ~safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR();
+    void initialize(const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR*>(this);
+    }
+    VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR const*>(this);
+    }
+};
+struct safe_VkAttachmentFeedbackLoopInfoEXT {
+    VkStructureType sType;
+    const void* pNext{};
+    VkBool32 feedbackLoopEnable;
+
+    safe_VkAttachmentFeedbackLoopInfoEXT(const VkAttachmentFeedbackLoopInfoEXT* in_struct, PNextCopyState* copy_state = {},
+                                         bool copy_pnext = true);
+    safe_VkAttachmentFeedbackLoopInfoEXT(const safe_VkAttachmentFeedbackLoopInfoEXT& copy_src);
+    safe_VkAttachmentFeedbackLoopInfoEXT& operator=(const safe_VkAttachmentFeedbackLoopInfoEXT& copy_src);
+    safe_VkAttachmentFeedbackLoopInfoEXT();
+    ~safe_VkAttachmentFeedbackLoopInfoEXT();
+    void initialize(const VkAttachmentFeedbackLoopInfoEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkAttachmentFeedbackLoopInfoEXT* copy_src, PNextCopyState* copy_state = {});
+    VkAttachmentFeedbackLoopInfoEXT* ptr() { return reinterpret_cast<VkAttachmentFeedbackLoopInfoEXT*>(this); }
+    VkAttachmentFeedbackLoopInfoEXT const* ptr() const { return reinterpret_cast<VkAttachmentFeedbackLoopInfoEXT const*>(this); }
+};
 struct safe_VkCalibratedTimestampInfoKHR {
     VkStructureType sType;
     const void* pNext{};
@@ -9648,6 +9860,63 @@ struct safe_VkMemoryBarrierAccessFlags3KHR {
     VkMemoryBarrierAccessFlags3KHR* ptr() { return reinterpret_cast<VkMemoryBarrierAccessFlags3KHR*>(this); }
     VkMemoryBarrierAccessFlags3KHR const* ptr() const { return reinterpret_cast<VkMemoryBarrierAccessFlags3KHR const*>(this); }
 };
+struct safe_VkPhysicalDeviceMaintenance9FeaturesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 maintenance9;
+
+    safe_VkPhysicalDeviceMaintenance9FeaturesKHR(const VkPhysicalDeviceMaintenance9FeaturesKHR* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceMaintenance9FeaturesKHR(const safe_VkPhysicalDeviceMaintenance9FeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceMaintenance9FeaturesKHR& operator=(const safe_VkPhysicalDeviceMaintenance9FeaturesKHR& copy_src);
+    safe_VkPhysicalDeviceMaintenance9FeaturesKHR();
+    ~safe_VkPhysicalDeviceMaintenance9FeaturesKHR();
+    void initialize(const VkPhysicalDeviceMaintenance9FeaturesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMaintenance9FeaturesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMaintenance9FeaturesKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceMaintenance9FeaturesKHR*>(this); }
+    VkPhysicalDeviceMaintenance9FeaturesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMaintenance9FeaturesKHR const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceMaintenance9PropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 image2DViewOf3DSparse;
+    VkDefaultVertexAttributeValueKHR defaultVertexAttributeValue;
+
+    safe_VkPhysicalDeviceMaintenance9PropertiesKHR(const VkPhysicalDeviceMaintenance9PropertiesKHR* in_struct,
+                                                   PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceMaintenance9PropertiesKHR(const safe_VkPhysicalDeviceMaintenance9PropertiesKHR& copy_src);
+    safe_VkPhysicalDeviceMaintenance9PropertiesKHR& operator=(const safe_VkPhysicalDeviceMaintenance9PropertiesKHR& copy_src);
+    safe_VkPhysicalDeviceMaintenance9PropertiesKHR();
+    ~safe_VkPhysicalDeviceMaintenance9PropertiesKHR();
+    void initialize(const VkPhysicalDeviceMaintenance9PropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceMaintenance9PropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceMaintenance9PropertiesKHR* ptr() { return reinterpret_cast<VkPhysicalDeviceMaintenance9PropertiesKHR*>(this); }
+    VkPhysicalDeviceMaintenance9PropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceMaintenance9PropertiesKHR const*>(this);
+    }
+};
+struct safe_VkQueueFamilyOwnershipTransferPropertiesKHR {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t optimalImageTransferToQueueFamilies;
+
+    safe_VkQueueFamilyOwnershipTransferPropertiesKHR(const VkQueueFamilyOwnershipTransferPropertiesKHR* in_struct,
+                                                     PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkQueueFamilyOwnershipTransferPropertiesKHR(const safe_VkQueueFamilyOwnershipTransferPropertiesKHR& copy_src);
+    safe_VkQueueFamilyOwnershipTransferPropertiesKHR& operator=(const safe_VkQueueFamilyOwnershipTransferPropertiesKHR& copy_src);
+    safe_VkQueueFamilyOwnershipTransferPropertiesKHR();
+    ~safe_VkQueueFamilyOwnershipTransferPropertiesKHR();
+    void initialize(const VkQueueFamilyOwnershipTransferPropertiesKHR* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkQueueFamilyOwnershipTransferPropertiesKHR* copy_src, PNextCopyState* copy_state = {});
+    VkQueueFamilyOwnershipTransferPropertiesKHR* ptr() {
+        return reinterpret_cast<VkQueueFamilyOwnershipTransferPropertiesKHR*>(this);
+    }
+    VkQueueFamilyOwnershipTransferPropertiesKHR const* ptr() const {
+        return reinterpret_cast<VkQueueFamilyOwnershipTransferPropertiesKHR const*>(this);
+    }
+};
 struct safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR {
     VkStructureType sType;
     void* pNext{};
@@ -17841,6 +18110,465 @@ struct safe_VkDirectDriverLoadingListLUNARG {
     VkDirectDriverLoadingListLUNARG* ptr() { return reinterpret_cast<VkDirectDriverLoadingListLUNARG*>(this); }
     VkDirectDriverLoadingListLUNARG const* ptr() const { return reinterpret_cast<VkDirectDriverLoadingListLUNARG const*>(this); }
 };
+struct safe_VkTensorDescriptionARM {
+    VkStructureType sType;
+    const void* pNext{};
+    VkTensorTilingARM tiling;
+    VkFormat format;
+    uint32_t dimensionCount;
+    const int64_t* pDimensions{};
+    const int64_t* pStrides{};
+    VkTensorUsageFlagsARM usage;
+
+    safe_VkTensorDescriptionARM(const VkTensorDescriptionARM* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkTensorDescriptionARM(const safe_VkTensorDescriptionARM& copy_src);
+    safe_VkTensorDescriptionARM& operator=(const safe_VkTensorDescriptionARM& copy_src);
+    safe_VkTensorDescriptionARM();
+    ~safe_VkTensorDescriptionARM();
+    void initialize(const VkTensorDescriptionARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkTensorDescriptionARM* copy_src, PNextCopyState* copy_state = {});
+    VkTensorDescriptionARM* ptr() { return reinterpret_cast<VkTensorDescriptionARM*>(this); }
+    VkTensorDescriptionARM const* ptr() const { return reinterpret_cast<VkTensorDescriptionARM const*>(this); }
+};
+struct safe_VkTensorCreateInfoARM {
+    VkStructureType sType;
+    const void* pNext{};
+    VkTensorCreateFlagsARM flags;
+    safe_VkTensorDescriptionARM* pDescription{};
+    VkSharingMode sharingMode;
+    uint32_t queueFamilyIndexCount;
+    const uint32_t* pQueueFamilyIndices{};
+
+    safe_VkTensorCreateInfoARM(const VkTensorCreateInfoARM* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkTensorCreateInfoARM(const safe_VkTensorCreateInfoARM& copy_src);
+    safe_VkTensorCreateInfoARM& operator=(const safe_VkTensorCreateInfoARM& copy_src);
+    safe_VkTensorCreateInfoARM();
+    ~safe_VkTensorCreateInfoARM();
+    void initialize(const VkTensorCreateInfoARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkTensorCreateInfoARM* copy_src, PNextCopyState* copy_state = {});
+    VkTensorCreateInfoARM* ptr() { return reinterpret_cast<VkTensorCreateInfoARM*>(this); }
+    VkTensorCreateInfoARM const* ptr() const { return reinterpret_cast<VkTensorCreateInfoARM const*>(this); }
+};
+struct safe_VkTensorViewCreateInfoARM {
+    VkStructureType sType;
+    const void* pNext{};
+    VkTensorViewCreateFlagsARM flags;
+    VkTensorARM tensor;
+    VkFormat format;
+
+    safe_VkTensorViewCreateInfoARM(const VkTensorViewCreateInfoARM* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    safe_VkTensorViewCreateInfoARM(const safe_VkTensorViewCreateInfoARM& copy_src);
+    safe_VkTensorViewCreateInfoARM& operator=(const safe_VkTensorViewCreateInfoARM& copy_src);
+    safe_VkTensorViewCreateInfoARM();
+    ~safe_VkTensorViewCreateInfoARM();
+    void initialize(const VkTensorViewCreateInfoARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkTensorViewCreateInfoARM* copy_src, PNextCopyState* copy_state = {});
+    VkTensorViewCreateInfoARM* ptr() { return reinterpret_cast<VkTensorViewCreateInfoARM*>(this); }
+    VkTensorViewCreateInfoARM const* ptr() const { return reinterpret_cast<VkTensorViewCreateInfoARM const*>(this); }
+};
+struct safe_VkTensorMemoryRequirementsInfoARM {
+    VkStructureType sType;
+    const void* pNext{};
+    VkTensorARM tensor;
+
+    safe_VkTensorMemoryRequirementsInfoARM(const VkTensorMemoryRequirementsInfoARM* in_struct, PNextCopyState* copy_state = {},
+                                           bool copy_pnext = true);
+    safe_VkTensorMemoryRequirementsInfoARM(const safe_VkTensorMemoryRequirementsInfoARM& copy_src);
+    safe_VkTensorMemoryRequirementsInfoARM& operator=(const safe_VkTensorMemoryRequirementsInfoARM& copy_src);
+    safe_VkTensorMemoryRequirementsInfoARM();
+    ~safe_VkTensorMemoryRequirementsInfoARM();
+    void initialize(const VkTensorMemoryRequirementsInfoARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkTensorMemoryRequirementsInfoARM* copy_src, PNextCopyState* copy_state = {});
+    VkTensorMemoryRequirementsInfoARM* ptr() { return reinterpret_cast<VkTensorMemoryRequirementsInfoARM*>(this); }
+    VkTensorMemoryRequirementsInfoARM const* ptr() const {
+        return reinterpret_cast<VkTensorMemoryRequirementsInfoARM const*>(this);
+    }
+};
+struct safe_VkBindTensorMemoryInfoARM {
+    VkStructureType sType;
+    const void* pNext{};
+    VkTensorARM tensor;
+    VkDeviceMemory memory;
+    VkDeviceSize memoryOffset;
+
+    safe_VkBindTensorMemoryInfoARM(const VkBindTensorMemoryInfoARM* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    safe_VkBindTensorMemoryInfoARM(const safe_VkBindTensorMemoryInfoARM& copy_src);
+    safe_VkBindTensorMemoryInfoARM& operator=(const safe_VkBindTensorMemoryInfoARM& copy_src);
+    safe_VkBindTensorMemoryInfoARM();
+    ~safe_VkBindTensorMemoryInfoARM();
+    void initialize(const VkBindTensorMemoryInfoARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkBindTensorMemoryInfoARM* copy_src, PNextCopyState* copy_state = {});
+    VkBindTensorMemoryInfoARM* ptr() { return reinterpret_cast<VkBindTensorMemoryInfoARM*>(this); }
+    VkBindTensorMemoryInfoARM const* ptr() const { return reinterpret_cast<VkBindTensorMemoryInfoARM const*>(this); }
+};
+struct safe_VkWriteDescriptorSetTensorARM {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t tensorViewCount;
+    VkTensorViewARM* pTensorViews{};
+
+    safe_VkWriteDescriptorSetTensorARM(const VkWriteDescriptorSetTensorARM* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    safe_VkWriteDescriptorSetTensorARM(const safe_VkWriteDescriptorSetTensorARM& copy_src);
+    safe_VkWriteDescriptorSetTensorARM& operator=(const safe_VkWriteDescriptorSetTensorARM& copy_src);
+    safe_VkWriteDescriptorSetTensorARM();
+    ~safe_VkWriteDescriptorSetTensorARM();
+    void initialize(const VkWriteDescriptorSetTensorARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkWriteDescriptorSetTensorARM* copy_src, PNextCopyState* copy_state = {});
+    VkWriteDescriptorSetTensorARM* ptr() { return reinterpret_cast<VkWriteDescriptorSetTensorARM*>(this); }
+    VkWriteDescriptorSetTensorARM const* ptr() const { return reinterpret_cast<VkWriteDescriptorSetTensorARM const*>(this); }
+};
+struct safe_VkTensorFormatPropertiesARM {
+    VkStructureType sType;
+    const void* pNext{};
+    VkFormatFeatureFlags2 optimalTilingTensorFeatures;
+    VkFormatFeatureFlags2 linearTilingTensorFeatures;
+
+    safe_VkTensorFormatPropertiesARM(const VkTensorFormatPropertiesARM* in_struct, PNextCopyState* copy_state = {},
+                                     bool copy_pnext = true);
+    safe_VkTensorFormatPropertiesARM(const safe_VkTensorFormatPropertiesARM& copy_src);
+    safe_VkTensorFormatPropertiesARM& operator=(const safe_VkTensorFormatPropertiesARM& copy_src);
+    safe_VkTensorFormatPropertiesARM();
+    ~safe_VkTensorFormatPropertiesARM();
+    void initialize(const VkTensorFormatPropertiesARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkTensorFormatPropertiesARM* copy_src, PNextCopyState* copy_state = {});
+    VkTensorFormatPropertiesARM* ptr() { return reinterpret_cast<VkTensorFormatPropertiesARM*>(this); }
+    VkTensorFormatPropertiesARM const* ptr() const { return reinterpret_cast<VkTensorFormatPropertiesARM const*>(this); }
+};
+struct safe_VkPhysicalDeviceTensorPropertiesARM {
+    VkStructureType sType;
+    void* pNext{};
+    uint32_t maxTensorDimensionCount;
+    uint64_t maxTensorElements;
+    uint64_t maxPerDimensionTensorElements;
+    int64_t maxTensorStride;
+    uint64_t maxTensorSize;
+    uint32_t maxTensorShaderAccessArrayLength;
+    uint32_t maxTensorShaderAccessSize;
+    uint32_t maxDescriptorSetStorageTensors;
+    uint32_t maxPerStageDescriptorSetStorageTensors;
+    uint32_t maxDescriptorSetUpdateAfterBindStorageTensors;
+    uint32_t maxPerStageDescriptorUpdateAfterBindStorageTensors;
+    VkBool32 shaderStorageTensorArrayNonUniformIndexingNative;
+    VkShaderStageFlags shaderTensorSupportedStages;
+
+    safe_VkPhysicalDeviceTensorPropertiesARM(const VkPhysicalDeviceTensorPropertiesARM* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkPhysicalDeviceTensorPropertiesARM(const safe_VkPhysicalDeviceTensorPropertiesARM& copy_src);
+    safe_VkPhysicalDeviceTensorPropertiesARM& operator=(const safe_VkPhysicalDeviceTensorPropertiesARM& copy_src);
+    safe_VkPhysicalDeviceTensorPropertiesARM();
+    ~safe_VkPhysicalDeviceTensorPropertiesARM();
+    void initialize(const VkPhysicalDeviceTensorPropertiesARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceTensorPropertiesARM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceTensorPropertiesARM* ptr() { return reinterpret_cast<VkPhysicalDeviceTensorPropertiesARM*>(this); }
+    VkPhysicalDeviceTensorPropertiesARM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceTensorPropertiesARM const*>(this);
+    }
+};
+struct safe_VkTensorMemoryBarrierARM {
+    VkStructureType sType;
+    const void* pNext{};
+    VkPipelineStageFlags2 srcStageMask;
+    VkAccessFlags2 srcAccessMask;
+    VkPipelineStageFlags2 dstStageMask;
+    VkAccessFlags2 dstAccessMask;
+    uint32_t srcQueueFamilyIndex;
+    uint32_t dstQueueFamilyIndex;
+    VkTensorARM tensor;
+
+    safe_VkTensorMemoryBarrierARM(const VkTensorMemoryBarrierARM* in_struct, PNextCopyState* copy_state = {},
+                                  bool copy_pnext = true);
+    safe_VkTensorMemoryBarrierARM(const safe_VkTensorMemoryBarrierARM& copy_src);
+    safe_VkTensorMemoryBarrierARM& operator=(const safe_VkTensorMemoryBarrierARM& copy_src);
+    safe_VkTensorMemoryBarrierARM();
+    ~safe_VkTensorMemoryBarrierARM();
+    void initialize(const VkTensorMemoryBarrierARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkTensorMemoryBarrierARM* copy_src, PNextCopyState* copy_state = {});
+    VkTensorMemoryBarrierARM* ptr() { return reinterpret_cast<VkTensorMemoryBarrierARM*>(this); }
+    VkTensorMemoryBarrierARM const* ptr() const { return reinterpret_cast<VkTensorMemoryBarrierARM const*>(this); }
+};
+struct safe_VkTensorDependencyInfoARM {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t tensorMemoryBarrierCount;
+    safe_VkTensorMemoryBarrierARM* pTensorMemoryBarriers{};
+
+    safe_VkTensorDependencyInfoARM(const VkTensorDependencyInfoARM* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    safe_VkTensorDependencyInfoARM(const safe_VkTensorDependencyInfoARM& copy_src);
+    safe_VkTensorDependencyInfoARM& operator=(const safe_VkTensorDependencyInfoARM& copy_src);
+    safe_VkTensorDependencyInfoARM();
+    ~safe_VkTensorDependencyInfoARM();
+    void initialize(const VkTensorDependencyInfoARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkTensorDependencyInfoARM* copy_src, PNextCopyState* copy_state = {});
+    VkTensorDependencyInfoARM* ptr() { return reinterpret_cast<VkTensorDependencyInfoARM*>(this); }
+    VkTensorDependencyInfoARM const* ptr() const { return reinterpret_cast<VkTensorDependencyInfoARM const*>(this); }
+};
+struct safe_VkPhysicalDeviceTensorFeaturesARM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 tensorNonPacked;
+    VkBool32 shaderTensorAccess;
+    VkBool32 shaderStorageTensorArrayDynamicIndexing;
+    VkBool32 shaderStorageTensorArrayNonUniformIndexing;
+    VkBool32 descriptorBindingStorageTensorUpdateAfterBind;
+    VkBool32 tensors;
+
+    safe_VkPhysicalDeviceTensorFeaturesARM(const VkPhysicalDeviceTensorFeaturesARM* in_struct, PNextCopyState* copy_state = {},
+                                           bool copy_pnext = true);
+    safe_VkPhysicalDeviceTensorFeaturesARM(const safe_VkPhysicalDeviceTensorFeaturesARM& copy_src);
+    safe_VkPhysicalDeviceTensorFeaturesARM& operator=(const safe_VkPhysicalDeviceTensorFeaturesARM& copy_src);
+    safe_VkPhysicalDeviceTensorFeaturesARM();
+    ~safe_VkPhysicalDeviceTensorFeaturesARM();
+    void initialize(const VkPhysicalDeviceTensorFeaturesARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceTensorFeaturesARM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceTensorFeaturesARM* ptr() { return reinterpret_cast<VkPhysicalDeviceTensorFeaturesARM*>(this); }
+    VkPhysicalDeviceTensorFeaturesARM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceTensorFeaturesARM const*>(this);
+    }
+};
+struct safe_VkDeviceTensorMemoryRequirementsARM {
+    VkStructureType sType;
+    const void* pNext{};
+    safe_VkTensorCreateInfoARM* pCreateInfo{};
+
+    safe_VkDeviceTensorMemoryRequirementsARM(const VkDeviceTensorMemoryRequirementsARM* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkDeviceTensorMemoryRequirementsARM(const safe_VkDeviceTensorMemoryRequirementsARM& copy_src);
+    safe_VkDeviceTensorMemoryRequirementsARM& operator=(const safe_VkDeviceTensorMemoryRequirementsARM& copy_src);
+    safe_VkDeviceTensorMemoryRequirementsARM();
+    ~safe_VkDeviceTensorMemoryRequirementsARM();
+    void initialize(const VkDeviceTensorMemoryRequirementsARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDeviceTensorMemoryRequirementsARM* copy_src, PNextCopyState* copy_state = {});
+    VkDeviceTensorMemoryRequirementsARM* ptr() { return reinterpret_cast<VkDeviceTensorMemoryRequirementsARM*>(this); }
+    VkDeviceTensorMemoryRequirementsARM const* ptr() const {
+        return reinterpret_cast<VkDeviceTensorMemoryRequirementsARM const*>(this);
+    }
+};
+struct safe_VkTensorCopyARM {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t dimensionCount;
+    const uint64_t* pSrcOffset{};
+    const uint64_t* pDstOffset{};
+    const uint64_t* pExtent{};
+
+    safe_VkTensorCopyARM(const VkTensorCopyARM* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkTensorCopyARM(const safe_VkTensorCopyARM& copy_src);
+    safe_VkTensorCopyARM& operator=(const safe_VkTensorCopyARM& copy_src);
+    safe_VkTensorCopyARM();
+    ~safe_VkTensorCopyARM();
+    void initialize(const VkTensorCopyARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkTensorCopyARM* copy_src, PNextCopyState* copy_state = {});
+    VkTensorCopyARM* ptr() { return reinterpret_cast<VkTensorCopyARM*>(this); }
+    VkTensorCopyARM const* ptr() const { return reinterpret_cast<VkTensorCopyARM const*>(this); }
+};
+struct safe_VkCopyTensorInfoARM {
+    VkStructureType sType;
+    const void* pNext{};
+    VkTensorARM srcTensor;
+    VkTensorARM dstTensor;
+    uint32_t regionCount;
+    safe_VkTensorCopyARM* pRegions{};
+
+    safe_VkCopyTensorInfoARM(const VkCopyTensorInfoARM* in_struct, PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkCopyTensorInfoARM(const safe_VkCopyTensorInfoARM& copy_src);
+    safe_VkCopyTensorInfoARM& operator=(const safe_VkCopyTensorInfoARM& copy_src);
+    safe_VkCopyTensorInfoARM();
+    ~safe_VkCopyTensorInfoARM();
+    void initialize(const VkCopyTensorInfoARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkCopyTensorInfoARM* copy_src, PNextCopyState* copy_state = {});
+    VkCopyTensorInfoARM* ptr() { return reinterpret_cast<VkCopyTensorInfoARM*>(this); }
+    VkCopyTensorInfoARM const* ptr() const { return reinterpret_cast<VkCopyTensorInfoARM const*>(this); }
+};
+struct safe_VkMemoryDedicatedAllocateInfoTensorARM {
+    VkStructureType sType;
+    const void* pNext{};
+    VkTensorARM tensor;
+
+    safe_VkMemoryDedicatedAllocateInfoTensorARM(const VkMemoryDedicatedAllocateInfoTensorARM* in_struct,
+                                                PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkMemoryDedicatedAllocateInfoTensorARM(const safe_VkMemoryDedicatedAllocateInfoTensorARM& copy_src);
+    safe_VkMemoryDedicatedAllocateInfoTensorARM& operator=(const safe_VkMemoryDedicatedAllocateInfoTensorARM& copy_src);
+    safe_VkMemoryDedicatedAllocateInfoTensorARM();
+    ~safe_VkMemoryDedicatedAllocateInfoTensorARM();
+    void initialize(const VkMemoryDedicatedAllocateInfoTensorARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkMemoryDedicatedAllocateInfoTensorARM* copy_src, PNextCopyState* copy_state = {});
+    VkMemoryDedicatedAllocateInfoTensorARM* ptr() { return reinterpret_cast<VkMemoryDedicatedAllocateInfoTensorARM*>(this); }
+    VkMemoryDedicatedAllocateInfoTensorARM const* ptr() const {
+        return reinterpret_cast<VkMemoryDedicatedAllocateInfoTensorARM const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceExternalTensorInfoARM {
+    VkStructureType sType;
+    const void* pNext{};
+    VkTensorCreateFlagsARM flags;
+    safe_VkTensorDescriptionARM* pDescription{};
+    VkExternalMemoryHandleTypeFlagBits handleType;
+
+    safe_VkPhysicalDeviceExternalTensorInfoARM(const VkPhysicalDeviceExternalTensorInfoARM* in_struct,
+                                               PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceExternalTensorInfoARM(const safe_VkPhysicalDeviceExternalTensorInfoARM& copy_src);
+    safe_VkPhysicalDeviceExternalTensorInfoARM& operator=(const safe_VkPhysicalDeviceExternalTensorInfoARM& copy_src);
+    safe_VkPhysicalDeviceExternalTensorInfoARM();
+    ~safe_VkPhysicalDeviceExternalTensorInfoARM();
+    void initialize(const VkPhysicalDeviceExternalTensorInfoARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceExternalTensorInfoARM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceExternalTensorInfoARM* ptr() { return reinterpret_cast<VkPhysicalDeviceExternalTensorInfoARM*>(this); }
+    VkPhysicalDeviceExternalTensorInfoARM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceExternalTensorInfoARM const*>(this);
+    }
+};
+struct safe_VkExternalTensorPropertiesARM {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalMemoryProperties externalMemoryProperties;
+
+    safe_VkExternalTensorPropertiesARM(const VkExternalTensorPropertiesARM* in_struct, PNextCopyState* copy_state = {},
+                                       bool copy_pnext = true);
+    safe_VkExternalTensorPropertiesARM(const safe_VkExternalTensorPropertiesARM& copy_src);
+    safe_VkExternalTensorPropertiesARM& operator=(const safe_VkExternalTensorPropertiesARM& copy_src);
+    safe_VkExternalTensorPropertiesARM();
+    ~safe_VkExternalTensorPropertiesARM();
+    void initialize(const VkExternalTensorPropertiesARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExternalTensorPropertiesARM* copy_src, PNextCopyState* copy_state = {});
+    VkExternalTensorPropertiesARM* ptr() { return reinterpret_cast<VkExternalTensorPropertiesARM*>(this); }
+    VkExternalTensorPropertiesARM const* ptr() const { return reinterpret_cast<VkExternalTensorPropertiesARM const*>(this); }
+};
+struct safe_VkExternalMemoryTensorCreateInfoARM {
+    VkStructureType sType;
+    const void* pNext{};
+    VkExternalMemoryHandleTypeFlags handleTypes;
+
+    safe_VkExternalMemoryTensorCreateInfoARM(const VkExternalMemoryTensorCreateInfoARM* in_struct, PNextCopyState* copy_state = {},
+                                             bool copy_pnext = true);
+    safe_VkExternalMemoryTensorCreateInfoARM(const safe_VkExternalMemoryTensorCreateInfoARM& copy_src);
+    safe_VkExternalMemoryTensorCreateInfoARM& operator=(const safe_VkExternalMemoryTensorCreateInfoARM& copy_src);
+    safe_VkExternalMemoryTensorCreateInfoARM();
+    ~safe_VkExternalMemoryTensorCreateInfoARM();
+    void initialize(const VkExternalMemoryTensorCreateInfoARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkExternalMemoryTensorCreateInfoARM* copy_src, PNextCopyState* copy_state = {});
+    VkExternalMemoryTensorCreateInfoARM* ptr() { return reinterpret_cast<VkExternalMemoryTensorCreateInfoARM*>(this); }
+    VkExternalMemoryTensorCreateInfoARM const* ptr() const {
+        return reinterpret_cast<VkExternalMemoryTensorCreateInfoARM const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 descriptorBufferTensorDescriptors;
+
+    safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM(const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM* in_struct,
+                                                           PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM(const safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM& copy_src);
+    safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM& operator=(
+        const safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM& copy_src);
+    safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM();
+    ~safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM();
+    void initialize(const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDescriptorBufferTensorFeaturesARM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorBufferTensorFeaturesARM*>(this);
+    }
+    VkPhysicalDeviceDescriptorBufferTensorFeaturesARM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorBufferTensorFeaturesARM const*>(this);
+    }
+};
+struct safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM {
+    VkStructureType sType;
+    const void* pNext{};
+    size_t tensorCaptureReplayDescriptorDataSize;
+    size_t tensorViewCaptureReplayDescriptorDataSize;
+    size_t tensorDescriptorSize;
+
+    safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM(const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM* in_struct,
+                                                             PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM(
+        const safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM& copy_src);
+    safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM& operator=(
+        const safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM& copy_src);
+    safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM();
+    ~safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM();
+    void initialize(const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceDescriptorBufferTensorPropertiesARM* ptr() {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorBufferTensorPropertiesARM*>(this);
+    }
+    VkPhysicalDeviceDescriptorBufferTensorPropertiesARM const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceDescriptorBufferTensorPropertiesARM const*>(this);
+    }
+};
+struct safe_VkDescriptorGetTensorInfoARM {
+    VkStructureType sType;
+    const void* pNext{};
+    VkTensorViewARM tensorView;
+
+    safe_VkDescriptorGetTensorInfoARM(const VkDescriptorGetTensorInfoARM* in_struct, PNextCopyState* copy_state = {},
+                                      bool copy_pnext = true);
+    safe_VkDescriptorGetTensorInfoARM(const safe_VkDescriptorGetTensorInfoARM& copy_src);
+    safe_VkDescriptorGetTensorInfoARM& operator=(const safe_VkDescriptorGetTensorInfoARM& copy_src);
+    safe_VkDescriptorGetTensorInfoARM();
+    ~safe_VkDescriptorGetTensorInfoARM();
+    void initialize(const VkDescriptorGetTensorInfoARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkDescriptorGetTensorInfoARM* copy_src, PNextCopyState* copy_state = {});
+    VkDescriptorGetTensorInfoARM* ptr() { return reinterpret_cast<VkDescriptorGetTensorInfoARM*>(this); }
+    VkDescriptorGetTensorInfoARM const* ptr() const { return reinterpret_cast<VkDescriptorGetTensorInfoARM const*>(this); }
+};
+struct safe_VkTensorCaptureDescriptorDataInfoARM {
+    VkStructureType sType;
+    const void* pNext{};
+    VkTensorARM tensor;
+
+    safe_VkTensorCaptureDescriptorDataInfoARM(const VkTensorCaptureDescriptorDataInfoARM* in_struct,
+                                              PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkTensorCaptureDescriptorDataInfoARM(const safe_VkTensorCaptureDescriptorDataInfoARM& copy_src);
+    safe_VkTensorCaptureDescriptorDataInfoARM& operator=(const safe_VkTensorCaptureDescriptorDataInfoARM& copy_src);
+    safe_VkTensorCaptureDescriptorDataInfoARM();
+    ~safe_VkTensorCaptureDescriptorDataInfoARM();
+    void initialize(const VkTensorCaptureDescriptorDataInfoARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkTensorCaptureDescriptorDataInfoARM* copy_src, PNextCopyState* copy_state = {});
+    VkTensorCaptureDescriptorDataInfoARM* ptr() { return reinterpret_cast<VkTensorCaptureDescriptorDataInfoARM*>(this); }
+    VkTensorCaptureDescriptorDataInfoARM const* ptr() const {
+        return reinterpret_cast<VkTensorCaptureDescriptorDataInfoARM const*>(this);
+    }
+};
+struct safe_VkTensorViewCaptureDescriptorDataInfoARM {
+    VkStructureType sType;
+    const void* pNext{};
+    VkTensorViewARM tensorView;
+
+    safe_VkTensorViewCaptureDescriptorDataInfoARM(const VkTensorViewCaptureDescriptorDataInfoARM* in_struct,
+                                                  PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkTensorViewCaptureDescriptorDataInfoARM(const safe_VkTensorViewCaptureDescriptorDataInfoARM& copy_src);
+    safe_VkTensorViewCaptureDescriptorDataInfoARM& operator=(const safe_VkTensorViewCaptureDescriptorDataInfoARM& copy_src);
+    safe_VkTensorViewCaptureDescriptorDataInfoARM();
+    ~safe_VkTensorViewCaptureDescriptorDataInfoARM();
+    void initialize(const VkTensorViewCaptureDescriptorDataInfoARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkTensorViewCaptureDescriptorDataInfoARM* copy_src, PNextCopyState* copy_state = {});
+    VkTensorViewCaptureDescriptorDataInfoARM* ptr() { return reinterpret_cast<VkTensorViewCaptureDescriptorDataInfoARM*>(this); }
+    VkTensorViewCaptureDescriptorDataInfoARM const* ptr() const {
+        return reinterpret_cast<VkTensorViewCaptureDescriptorDataInfoARM const*>(this);
+    }
+};
+struct safe_VkFrameBoundaryTensorsARM {
+    VkStructureType sType;
+    const void* pNext{};
+    uint32_t tensorCount;
+    VkTensorARM* pTensors{};
+
+    safe_VkFrameBoundaryTensorsARM(const VkFrameBoundaryTensorsARM* in_struct, PNextCopyState* copy_state = {},
+                                   bool copy_pnext = true);
+    safe_VkFrameBoundaryTensorsARM(const safe_VkFrameBoundaryTensorsARM& copy_src);
+    safe_VkFrameBoundaryTensorsARM& operator=(const safe_VkFrameBoundaryTensorsARM& copy_src);
+    safe_VkFrameBoundaryTensorsARM();
+    ~safe_VkFrameBoundaryTensorsARM();
+    void initialize(const VkFrameBoundaryTensorsARM* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkFrameBoundaryTensorsARM* copy_src, PNextCopyState* copy_state = {});
+    VkFrameBoundaryTensorsARM* ptr() { return reinterpret_cast<VkFrameBoundaryTensorsARM*>(this); }
+    VkFrameBoundaryTensorsARM const* ptr() const { return reinterpret_cast<VkFrameBoundaryTensorsARM const*>(this); }
+};
 struct safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT {
     VkStructureType sType;
     void* pNext{};
@@ -19579,6 +20307,25 @@ struct safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT {
         return reinterpret_cast<VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT const*>(this);
     }
 };
+struct safe_VkPhysicalDeviceShaderFloat8FeaturesEXT {
+    VkStructureType sType;
+    void* pNext{};
+    VkBool32 shaderFloat8;
+    VkBool32 shaderFloat8CooperativeMatrix;
+
+    safe_VkPhysicalDeviceShaderFloat8FeaturesEXT(const VkPhysicalDeviceShaderFloat8FeaturesEXT* in_struct,
+                                                 PNextCopyState* copy_state = {}, bool copy_pnext = true);
+    safe_VkPhysicalDeviceShaderFloat8FeaturesEXT(const safe_VkPhysicalDeviceShaderFloat8FeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceShaderFloat8FeaturesEXT& operator=(const safe_VkPhysicalDeviceShaderFloat8FeaturesEXT& copy_src);
+    safe_VkPhysicalDeviceShaderFloat8FeaturesEXT();
+    ~safe_VkPhysicalDeviceShaderFloat8FeaturesEXT();
+    void initialize(const VkPhysicalDeviceShaderFloat8FeaturesEXT* in_struct, PNextCopyState* copy_state = {});
+    void initialize(const safe_VkPhysicalDeviceShaderFloat8FeaturesEXT* copy_src, PNextCopyState* copy_state = {});
+    VkPhysicalDeviceShaderFloat8FeaturesEXT* ptr() { return reinterpret_cast<VkPhysicalDeviceShaderFloat8FeaturesEXT*>(this); }
+    VkPhysicalDeviceShaderFloat8FeaturesEXT const* ptr() const {
+        return reinterpret_cast<VkPhysicalDeviceShaderFloat8FeaturesEXT const*>(this);
+    }
+};
 struct safe_VkPhysicalDeviceRayTracingValidationFeaturesNV {
     VkStructureType sType;
     void* pNext{};
diff --git a/include/vulkan/utility/vk_struct_helper.hpp b/include/vulkan/utility/vk_struct_helper.hpp
index 581f997..38c27cb 100644
--- a/include/vulkan/utility/vk_struct_helper.hpp
+++ b/include/vulkan/utility/vk_struct_helper.hpp
@@ -451,6 +451,12 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderSubgroupUnifor
 template <> inline VkStructureType GetSType<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkSurfaceCapabilitiesPresentId2KHR>() { return VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR; }
+template <> inline VkStructureType GetSType<VkPresentId2KHR>() { return VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDevicePresentId2FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkSurfaceCapabilitiesPresentWait2KHR>() { return VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDevicePresentWait2FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkPresentWait2InfoKHR>() { return VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDevicePipelineBinaryFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDevicePipelineBinaryPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR; }
@@ -483,8 +489,14 @@ template <> inline VkStructureType GetSType<VkVideoEncodeAV1ProfileInfoKHR>() {
 template <> inline VkStructureType GetSType<VkVideoEncodeAV1GopRemainingFrameInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkVideoEncodeAV1RateControlInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkVideoEncodeAV1RateControlLayerInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceVideoDecodeVP9FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkVideoDecodeVP9ProfileInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkVideoDecodeVP9CapabilitiesKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR; }
+template <> inline VkStructureType GetSType<VkVideoDecodeVP9PictureInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceVideoMaintenance1FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkVideoInlineQueryInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkAttachmentFeedbackLoopInfoEXT>() { return VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkCalibratedTimestampInfoKHR>() { return VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkSetDescriptorBufferOffsetsInfoEXT>() { return VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkBindDescriptorBufferEmbeddedSamplersInfoEXT>() { return VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT; }
@@ -506,6 +518,9 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceLayeredApiProperties
 template <> inline VkStructureType GetSType<VkPhysicalDeviceLayeredApiVulkanPropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance8FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkMemoryBarrierAccessFlags3KHR>() { return VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance9FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceMaintenance9PropertiesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR; }
+template <> inline VkStructureType GetSType<VkQueueFamilyOwnershipTransferPropertiesKHR>() { return VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceVideoMaintenance2FeaturesKHR>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR; }
 template <> inline VkStructureType GetSType<VkVideoDecodeH264InlineSessionParametersInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR; }
 template <> inline VkStructureType GetSType<VkVideoDecodeH265InlineSessionParametersInfoKHR>() { return VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR; }
@@ -933,6 +948,30 @@ template <> inline VkStructureType GetSType<VkRenderPassCreationFeedbackCreateIn
 template <> inline VkStructureType GetSType<VkRenderPassSubpassFeedbackCreateInfoEXT>() { return VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT; }
 template <> inline VkStructureType GetSType<VkDirectDriverLoadingInfoLUNARG>() { return VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG; }
 template <> inline VkStructureType GetSType<VkDirectDriverLoadingListLUNARG>() { return VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG; }
+template <> inline VkStructureType GetSType<VkTensorDescriptionARM>() { return VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM; }
+template <> inline VkStructureType GetSType<VkTensorCreateInfoARM>() { return VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM; }
+template <> inline VkStructureType GetSType<VkTensorViewCreateInfoARM>() { return VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM; }
+template <> inline VkStructureType GetSType<VkTensorMemoryRequirementsInfoARM>() { return VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM; }
+template <> inline VkStructureType GetSType<VkBindTensorMemoryInfoARM>() { return VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM; }
+template <> inline VkStructureType GetSType<VkWriteDescriptorSetTensorARM>() { return VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM; }
+template <> inline VkStructureType GetSType<VkTensorFormatPropertiesARM>() { return VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceTensorPropertiesARM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM; }
+template <> inline VkStructureType GetSType<VkTensorMemoryBarrierARM>() { return VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM; }
+template <> inline VkStructureType GetSType<VkTensorDependencyInfoARM>() { return VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceTensorFeaturesARM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM; }
+template <> inline VkStructureType GetSType<VkDeviceTensorMemoryRequirementsARM>() { return VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM; }
+template <> inline VkStructureType GetSType<VkTensorCopyARM>() { return VK_STRUCTURE_TYPE_TENSOR_COPY_ARM; }
+template <> inline VkStructureType GetSType<VkCopyTensorInfoARM>() { return VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM; }
+template <> inline VkStructureType GetSType<VkMemoryDedicatedAllocateInfoTensorARM>() { return VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceExternalTensorInfoARM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM; }
+template <> inline VkStructureType GetSType<VkExternalTensorPropertiesARM>() { return VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM; }
+template <> inline VkStructureType GetSType<VkExternalMemoryTensorCreateInfoARM>() { return VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceDescriptorBufferTensorFeaturesARM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceDescriptorBufferTensorPropertiesARM>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM; }
+template <> inline VkStructureType GetSType<VkDescriptorGetTensorInfoARM>() { return VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM; }
+template <> inline VkStructureType GetSType<VkTensorCaptureDescriptorDataInfoARM>() { return VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM; }
+template <> inline VkStructureType GetSType<VkTensorViewCaptureDescriptorDataInfoARM>() { return VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM; }
+template <> inline VkStructureType GetSType<VkFrameBoundaryTensorsARM>() { return VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT; }
 template <> inline VkStructureType GetSType<VkPipelineShaderStageModuleIdentifierCreateInfoEXT>() { return VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT; }
@@ -1022,6 +1061,7 @@ template <> inline VkStructureType GetSType<VkPhysicalDeviceExternalComputeQueue
 template <> inline VkStructureType GetSType<VkPhysicalDeviceCommandBufferInheritanceFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; }
+template <> inline VkStructureType GetSType<VkPhysicalDeviceShaderFloat8FeaturesEXT>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceRayTracingValidationFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceClusterAccelerationStructureFeaturesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV; }
 template <> inline VkStructureType GetSType<VkPhysicalDeviceClusterAccelerationStructurePropertiesNV>() { return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV; }
@@ -1224,6 +1264,8 @@ template<> inline VkObjectType GetObjectType<VkAccelerationStructureKHR>() { ret
 template<> inline VkObjectType GetObjectType<VkBufferCollectionFUCHSIA>() { return VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA; }
 #endif  // VK_USE_PLATFORM_FUCHSIA
 template<> inline VkObjectType GetObjectType<VkMicromapEXT>() { return VK_OBJECT_TYPE_MICROMAP_EXT; }
+template<> inline VkObjectType GetObjectType<VkTensorARM>() { return VK_OBJECT_TYPE_TENSOR_ARM; }
+template<> inline VkObjectType GetObjectType<VkTensorViewARM>() { return VK_OBJECT_TYPE_TENSOR_VIEW_ARM; }
 template<> inline VkObjectType GetObjectType<VkOpticalFlowSessionNV>() { return VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV; }
 template<> inline VkObjectType GetObjectType<VkShaderEXT>() { return VK_OBJECT_TYPE_SHADER_EXT; }
 template<> inline VkObjectType GetObjectType<VkExternalComputeQueueNV>() { return VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV; }
diff --git a/include/vulkan/vk_enum_string_helper.h b/include/vulkan/vk_enum_string_helper.h
index 4921053..6df410d 100644
--- a/include/vulkan/vk_enum_string_helper.h
+++ b/include/vulkan/vk_enum_string_helper.h
@@ -1768,6 +1768,54 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG";
         case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG:
             return "VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG";
+        case VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM:
+            return "VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM";
+        case VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM:
+            return "VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM";
+        case VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM:
+            return "VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM";
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM:
+            return "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM";
+        case VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM:
+            return "VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM";
+        case VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM:
+            return "VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM";
+        case VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM:
+            return "VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM";
+        case VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM:
+            return "VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM";
+        case VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM:
+            return "VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM";
+        case VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM:
+            return "VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM";
+        case VK_STRUCTURE_TYPE_TENSOR_COPY_ARM:
+            return "VK_STRUCTURE_TYPE_TENSOR_COPY_ARM";
+        case VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM:
+            return "VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM";
+        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM:
+            return "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM";
+        case VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM:
+            return "VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM";
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM:
+            return "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM";
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM:
+            return "VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM";
+        case VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM:
+            return "VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM";
+        case VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM:
+            return "VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM";
+        case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM:
+            return "VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT:
@@ -1806,6 +1854,18 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD";
         case VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD:
             return "VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD";
+        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR:
+            return "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR";
+        case VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR:
+            return "VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR";
+        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR:
+            return "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR";
+        case VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT:
@@ -1942,6 +2002,14 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR";
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR:
             return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR:
+            return "VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR";
         case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR:
@@ -1968,6 +2036,10 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR";
+        case VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT:
+            return "VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT";
         case VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX:
             return "VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX";
         case VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX:
@@ -2050,6 +2122,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV:
@@ -2122,6 +2196,12 @@ static inline const char* string_VkStructureType(VkStructureType input_value) {
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT";
         case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT:
             return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR";
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR:
+            return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR";
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR:
@@ -2246,6 +2326,8 @@ static inline const char* string_VkImageLayout(VkImageLayout input_value) {
             return "VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR";
         case VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT:
             return "VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT";
+        case VK_IMAGE_LAYOUT_TENSOR_ALIASING_ARM:
+            return "VK_IMAGE_LAYOUT_TENSOR_ALIASING_ARM";
         case VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR:
             return "VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR";
         case VK_IMAGE_LAYOUT_ZERO_INITIALIZED_EXT:
@@ -2356,6 +2438,10 @@ static inline const char* string_VkObjectType(VkObjectType input_value) {
             return "VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA";
         case VK_OBJECT_TYPE_MICROMAP_EXT:
             return "VK_OBJECT_TYPE_MICROMAP_EXT";
+        case VK_OBJECT_TYPE_TENSOR_ARM:
+            return "VK_OBJECT_TYPE_TENSOR_ARM";
+        case VK_OBJECT_TYPE_TENSOR_VIEW_ARM:
+            return "VK_OBJECT_TYPE_TENSOR_VIEW_ARM";
         case VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV:
             return "VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV";
         case VK_OBJECT_TYPE_SHADER_EXT:
@@ -2918,6 +3004,8 @@ static inline const char* string_VkFormat(VkFormat input_value) {
             return "VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG";
         case VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG:
             return "VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG";
+        case VK_FORMAT_R8_BOOL_ARM:
+            return "VK_FORMAT_R8_BOOL_ARM";
         case VK_FORMAT_R16G16_SFIXED5_NV:
             return "VK_FORMAT_R16G16_SFIXED5_NV";
         case VK_FORMAT_R10X6_UINT_PACK16_ARM:
@@ -3624,6 +3712,8 @@ static inline const char* string_VkDescriptorType(VkDescriptorType input_value)
             return "VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM";
         case VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM:
             return "VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM";
+        case VK_DESCRIPTOR_TYPE_TENSOR_ARM:
+            return "VK_DESCRIPTOR_TYPE_TENSOR_ARM";
         case VK_DESCRIPTOR_TYPE_MUTABLE_EXT:
             return "VK_DESCRIPTOR_TYPE_MUTABLE_EXT";
         case VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV:
@@ -4140,6 +4230,10 @@ static inline const char* string_VkComponentTypeKHR(VkComponentTypeKHR input_val
             return "VK_COMPONENT_TYPE_FLOAT_E4M3_NV";
         case VK_COMPONENT_TYPE_FLOAT_E5M2_NV:
             return "VK_COMPONENT_TYPE_FLOAT_E5M2_NV";
+        case VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT:
+            return "VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT";
+        case VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT:
+            return "VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT";
         default:
             return "Unhandled VkComponentTypeKHR";
     }
@@ -4214,6 +4308,16 @@ static inline const char* string_VkPhysicalDeviceLayeredApiKHR(VkPhysicalDeviceL
             return "Unhandled VkPhysicalDeviceLayeredApiKHR";
     }
 }
+static inline const char* string_VkDefaultVertexAttributeValueKHR(VkDefaultVertexAttributeValueKHR input_value) {
+    switch (input_value) {
+        case VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ZERO_KHR:
+            return "VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ZERO_KHR";
+        case VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ONE_KHR:
+            return "VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ONE_KHR";
+        default:
+            return "Unhandled VkDefaultVertexAttributeValueKHR";
+    }
+}
 static inline const char* string_VkDebugReportObjectTypeEXT(VkDebugReportObjectTypeEXT input_value) {
     switch (input_value) {
         case VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT:
@@ -4994,6 +5098,16 @@ static inline const char* string_VkDirectDriverLoadingModeLUNARG(VkDirectDriverL
             return "Unhandled VkDirectDriverLoadingModeLUNARG";
     }
 }
+static inline const char* string_VkTensorTilingARM(VkTensorTilingARM input_value) {
+    switch (input_value) {
+        case VK_TENSOR_TILING_OPTIMAL_ARM:
+            return "VK_TENSOR_TILING_OPTIMAL_ARM";
+        case VK_TENSOR_TILING_LINEAR_ARM:
+            return "VK_TENSOR_TILING_LINEAR_ARM";
+        default:
+            return "Unhandled VkTensorTilingARM";
+    }
+}
 static inline const char* string_VkOpticalFlowPerformanceLevelNV(VkOpticalFlowPerformanceLevelNV input_value) {
     switch (input_value) {
         case VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_NV:
@@ -5688,6 +5802,8 @@ static inline const char* string_VkImageUsageFlagBits(VkImageUsageFlagBits input
             return "VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM";
         case VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM:
             return "VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM";
+        case VK_IMAGE_USAGE_TENSOR_ALIASING_BIT_ARM:
+            return "VK_IMAGE_USAGE_TENSOR_ALIASING_BIT_ARM";
         case VK_IMAGE_USAGE_TILE_MEMORY_BIT_QCOM:
             return "VK_IMAGE_USAGE_TILE_MEMORY_BIT_QCOM";
         case VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR:
@@ -6131,6 +6247,31 @@ static inline std::string string_VkQueryPipelineStatisticFlags(VkQueryPipelineSt
     return ret;
 }
 #endif // __cplusplus
+static inline const char* string_VkQueryPoolCreateFlagBits(VkQueryPoolCreateFlagBits input_value) {
+    switch (input_value) {
+        case VK_QUERY_POOL_CREATE_RESET_BIT_KHR:
+            return "VK_QUERY_POOL_CREATE_RESET_BIT_KHR";
+        default:
+            return "Unhandled VkQueryPoolCreateFlagBits";
+    }
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkQueryPoolCreateFlags(VkQueryPoolCreateFlags input_value) {
+    std::string ret;
+    int index = 0;
+    while(input_value) {
+        if (input_value & 1) {
+            if( !ret.empty()) ret.append("|");
+            ret.append(string_VkQueryPoolCreateFlagBits(static_cast<VkQueryPoolCreateFlagBits>(1U << index)));
+        }
+        ++index;
+        input_value >>= 1;
+    }
+    if (ret.empty()) ret.append("VkQueryPoolCreateFlags(0)");
+    return ret;
+}
+#endif // __cplusplus
 static inline const char* string_VkQueryResultFlagBits(VkQueryResultFlagBits input_value) {
     switch (input_value) {
         case VK_QUERY_RESULT_64_BIT:
@@ -6785,6 +6926,8 @@ static inline const char* string_VkDependencyFlagBits(VkDependencyFlagBits input
             return "VK_DEPENDENCY_FEEDBACK_LOOP_BIT_EXT";
         case VK_DEPENDENCY_QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES_BIT_KHR:
             return "VK_DEPENDENCY_QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES_BIT_KHR";
+        case VK_DEPENDENCY_ASYMMETRIC_EVENT_BIT_KHR:
+            return "VK_DEPENDENCY_ASYMMETRIC_EVENT_BIT_KHR";
         default:
             return "Unhandled VkDependencyFlagBits";
     }
@@ -7433,8 +7576,8 @@ static inline const char* string_VkResolveModeFlagBits(VkResolveModeFlagBits inp
             return "VK_RESOLVE_MODE_MIN_BIT";
         case VK_RESOLVE_MODE_MAX_BIT:
             return "VK_RESOLVE_MODE_MAX_BIT";
-        case VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID:
-            return "VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID";
+        case VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_BIT_ANDROID:
+            return "VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_BIT_ANDROID";
         default:
             return "Unhandled VkResolveModeFlagBits";
     }
@@ -7806,6 +7949,8 @@ static inline const char* string_VkFormatFeatureFlagBits2(uint64_t input_value)
     if (input_value == VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM) return "VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM";
     if (input_value == VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM) return "VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM";
     if (input_value == VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM) return "VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM";
+    if (input_value == VK_FORMAT_FEATURE_2_TENSOR_SHADER_BIT_ARM) return "VK_FORMAT_FEATURE_2_TENSOR_SHADER_BIT_ARM";
+    if (input_value == VK_FORMAT_FEATURE_2_TENSOR_IMAGE_ALIASING_BIT_ARM) return "VK_FORMAT_FEATURE_2_TENSOR_IMAGE_ALIASING_BIT_ARM";
     if (input_value == VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV) return "VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV";
     if (input_value == VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV) return "VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV";
     if (input_value == VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV) return "VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV";
@@ -7966,8 +8111,8 @@ static inline std::string string_VkBufferUsageFlags2(VkBufferUsageFlags2 input_v
 #endif // __cplusplus
 static inline const char* string_VkHostImageCopyFlagBits(VkHostImageCopyFlagBits input_value) {
     switch (input_value) {
-        case VK_HOST_IMAGE_COPY_MEMCPY:
-            return "VK_HOST_IMAGE_COPY_MEMCPY";
+        case VK_HOST_IMAGE_COPY_MEMCPY_BIT:
+            return "VK_HOST_IMAGE_COPY_MEMCPY_BIT";
         default:
             return "Unhandled VkHostImageCopyFlagBits";
     }
@@ -8071,6 +8216,10 @@ static inline const char* string_VkSwapchainCreateFlagBitsKHR(VkSwapchainCreateF
             return "VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR";
         case VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT:
             return "VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT";
+        case VK_SWAPCHAIN_CREATE_PRESENT_ID_2_BIT_KHR:
+            return "VK_SWAPCHAIN_CREATE_PRESENT_ID_2_BIT_KHR";
+        case VK_SWAPCHAIN_CREATE_PRESENT_WAIT_2_BIT_KHR:
+            return "VK_SWAPCHAIN_CREATE_PRESENT_WAIT_2_BIT_KHR";
         default:
             return "Unhandled VkSwapchainCreateFlagBitsKHR";
     }
@@ -8170,6 +8319,8 @@ static inline const char* string_VkVideoCodecOperationFlagBitsKHR(VkVideoCodecOp
             return "VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR";
         case VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR:
             return "VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR";
+        case VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR:
+            return "VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR";
         default:
             return "Unhandled VkVideoCodecOperationFlagBitsKHR";
     }
@@ -9394,10 +9545,10 @@ static inline const char* string_VkGeometryInstanceFlagBitsKHR(VkGeometryInstanc
             return "VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR";
         case VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR:
             return "VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR";
-        case VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT:
-            return "VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT";
-        case VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT:
-            return "VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT";
+        case VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT:
+            return "VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT";
+        case VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT:
+            return "VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT";
         default:
             return "Unhandled VkGeometryInstanceFlagBitsKHR";
     }
@@ -9433,18 +9584,18 @@ static inline const char* string_VkBuildAccelerationStructureFlagBitsKHR(VkBuild
             return "VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR";
         case VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV:
             return "VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV";
-        case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT:
-            return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT";
-        case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT:
-            return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT";
-        case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT:
-            return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT";
+        case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT:
+            return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT";
+        case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT:
+            return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT";
+        case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT:
+            return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT";
 #ifdef VK_ENABLE_BETA_EXTENSIONS
-        case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV:
-            return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV";
+        case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV:
+            return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV";
 #endif  // VK_ENABLE_BETA_EXTENSIONS
-        case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_KHR:
-            return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_KHR";
+        case VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR:
+            return "VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR";
         default:
             return "Unhandled VkBuildAccelerationStructureFlagBitsKHR";
     }
@@ -9989,6 +10140,74 @@ static inline std::string string_VkMemoryDecompressionMethodFlagsNV(VkMemoryDeco
     return ret;
 }
 #endif // __cplusplus
+static inline const char* string_VkTensorCreateFlagBitsARM(uint64_t input_value) {
+    if (input_value == VK_TENSOR_CREATE_MUTABLE_FORMAT_BIT_ARM) return "VK_TENSOR_CREATE_MUTABLE_FORMAT_BIT_ARM";
+    if (input_value == VK_TENSOR_CREATE_PROTECTED_BIT_ARM) return "VK_TENSOR_CREATE_PROTECTED_BIT_ARM";
+    if (input_value == VK_TENSOR_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM) return "VK_TENSOR_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM";
+    return "Unhandled VkTensorCreateFlagBitsARM";
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkTensorCreateFlagsARM(VkTensorCreateFlagsARM input_value) {
+    std::string ret;
+    int index = 0;
+    while(input_value) {
+        if (input_value & 1) {
+            if( !ret.empty()) ret.append("|");
+            ret.append(string_VkTensorCreateFlagBitsARM(static_cast<uint64_t>(1ULL << index)));
+        }
+        ++index;
+        input_value >>= 1;
+    }
+    if (ret.empty()) ret.append("VkTensorCreateFlagsARM(0)");
+    return ret;
+}
+#endif // __cplusplus
+static inline const char* string_VkTensorViewCreateFlagBitsARM(uint64_t input_value) {
+    if (input_value == VK_TENSOR_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM) return "VK_TENSOR_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM";
+    return "Unhandled VkTensorViewCreateFlagBitsARM";
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkTensorViewCreateFlagsARM(VkTensorViewCreateFlagsARM input_value) {
+    std::string ret;
+    int index = 0;
+    while(input_value) {
+        if (input_value & 1) {
+            if( !ret.empty()) ret.append("|");
+            ret.append(string_VkTensorViewCreateFlagBitsARM(static_cast<uint64_t>(1ULL << index)));
+        }
+        ++index;
+        input_value >>= 1;
+    }
+    if (ret.empty()) ret.append("VkTensorViewCreateFlagsARM(0)");
+    return ret;
+}
+#endif // __cplusplus
+static inline const char* string_VkTensorUsageFlagBitsARM(uint64_t input_value) {
+    if (input_value == VK_TENSOR_USAGE_SHADER_BIT_ARM) return "VK_TENSOR_USAGE_SHADER_BIT_ARM";
+    if (input_value == VK_TENSOR_USAGE_TRANSFER_SRC_BIT_ARM) return "VK_TENSOR_USAGE_TRANSFER_SRC_BIT_ARM";
+    if (input_value == VK_TENSOR_USAGE_TRANSFER_DST_BIT_ARM) return "VK_TENSOR_USAGE_TRANSFER_DST_BIT_ARM";
+    if (input_value == VK_TENSOR_USAGE_IMAGE_ALIASING_BIT_ARM) return "VK_TENSOR_USAGE_IMAGE_ALIASING_BIT_ARM";
+    return "Unhandled VkTensorUsageFlagBitsARM";
+}
+
+#ifdef __cplusplus
+static inline std::string string_VkTensorUsageFlagsARM(VkTensorUsageFlagsARM input_value) {
+    std::string ret;
+    int index = 0;
+    while(input_value) {
+        if (input_value & 1) {
+            if( !ret.empty()) ret.append("|");
+            ret.append(string_VkTensorUsageFlagBitsARM(static_cast<uint64_t>(1ULL << index)));
+        }
+        ++index;
+        input_value >>= 1;
+    }
+    if (ret.empty()) ret.append("VkTensorUsageFlagsARM(0)");
+    return ret;
+}
+#endif // __cplusplus
 static inline const char* string_VkOpticalFlowGridSizeFlagBitsNV(VkOpticalFlowGridSizeFlagBitsNV input_value) {
     switch (input_value) {
         case VK_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_NV:
@@ -11241,6 +11460,18 @@ static inline const char* string_VkStructureName(VkStructureType input_value) {
             return "VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR:
             return "VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR";
+        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR:
+            return "VkSurfaceCapabilitiesPresentId2KHR";
+        case VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR:
+            return "VkPresentId2KHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR:
+            return "VkPhysicalDevicePresentId2FeaturesKHR";
+        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR:
+            return "VkSurfaceCapabilitiesPresentWait2KHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR:
+            return "VkPhysicalDevicePresentWait2FeaturesKHR";
+        case VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR:
+            return "VkPresentWait2InfoKHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
             return "VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR:
@@ -11305,10 +11536,22 @@ static inline const char* string_VkStructureName(VkStructureType input_value) {
             return "VkVideoEncodeAV1RateControlInfoKHR";
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR:
             return "VkVideoEncodeAV1RateControlLayerInfoKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR:
+            return "VkPhysicalDeviceVideoDecodeVP9FeaturesKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR:
+            return "VkVideoDecodeVP9ProfileInfoKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR:
+            return "VkVideoDecodeVP9CapabilitiesKHR";
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR:
+            return "VkVideoDecodeVP9PictureInfoKHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
             return "VkPhysicalDeviceVideoMaintenance1FeaturesKHR";
         case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR:
             return "VkVideoInlineQueryInfoKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR:
+            return "VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR";
+        case VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT:
+            return "VkAttachmentFeedbackLoopInfoEXT";
         case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR:
             return "VkCalibratedTimestampInfoKHR";
         case VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT:
@@ -11351,6 +11594,12 @@ static inline const char* string_VkStructureName(VkStructureType input_value) {
             return "VkPhysicalDeviceMaintenance8FeaturesKHR";
         case VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR:
             return "VkMemoryBarrierAccessFlags3KHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR:
+            return "VkPhysicalDeviceMaintenance9FeaturesKHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR:
+            return "VkPhysicalDeviceMaintenance9PropertiesKHR";
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR:
+            return "VkQueueFamilyOwnershipTransferPropertiesKHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR:
             return "VkPhysicalDeviceVideoMaintenance2FeaturesKHR";
         case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR:
@@ -12171,6 +12420,54 @@ static inline const char* string_VkStructureName(VkStructureType input_value) {
             return "VkDirectDriverLoadingInfoLUNARG";
         case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG:
             return "VkDirectDriverLoadingListLUNARG";
+        case VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM:
+            return "VkTensorDescriptionARM";
+        case VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM:
+            return "VkTensorCreateInfoARM";
+        case VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM:
+            return "VkTensorViewCreateInfoARM";
+        case VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM:
+            return "VkTensorMemoryRequirementsInfoARM";
+        case VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM:
+            return "VkBindTensorMemoryInfoARM";
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM:
+            return "VkWriteDescriptorSetTensorARM";
+        case VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM:
+            return "VkTensorFormatPropertiesARM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM:
+            return "VkPhysicalDeviceTensorPropertiesARM";
+        case VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM:
+            return "VkTensorMemoryBarrierARM";
+        case VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM:
+            return "VkTensorDependencyInfoARM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM:
+            return "VkPhysicalDeviceTensorFeaturesARM";
+        case VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM:
+            return "VkDeviceTensorMemoryRequirementsARM";
+        case VK_STRUCTURE_TYPE_TENSOR_COPY_ARM:
+            return "VkTensorCopyARM";
+        case VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM:
+            return "VkCopyTensorInfoARM";
+        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM:
+            return "VkMemoryDedicatedAllocateInfoTensorARM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM:
+            return "VkPhysicalDeviceExternalTensorInfoARM";
+        case VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM:
+            return "VkExternalTensorPropertiesARM";
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM:
+            return "VkExternalMemoryTensorCreateInfoARM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM:
+            return "VkPhysicalDeviceDescriptorBufferTensorFeaturesARM";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM:
+            return "VkPhysicalDeviceDescriptorBufferTensorPropertiesARM";
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM:
+            return "VkDescriptorGetTensorInfoARM";
+        case VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM:
+            return "VkTensorCaptureDescriptorDataInfoARM";
+        case VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM:
+            return "VkTensorViewCaptureDescriptorDataInfoARM";
+        case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM:
+            return "VkFrameBoundaryTensorsARM";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
             return "VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT:
@@ -12345,6 +12642,8 @@ static inline const char* string_VkStructureName(VkStructureType input_value) {
             return "VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT:
             return "VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT:
+            return "VkPhysicalDeviceShaderFloat8FeaturesEXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
             return "VkPhysicalDeviceRayTracingValidationFeaturesNV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV:
diff --git a/scripts/known_good.json b/scripts/known_good.json
index 71c8952..9bd946f 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.4.316"
+            "commit": "v1.4.317"
         },
         {
             "name": "googletest",
diff --git a/src/vulkan/vk_safe_struct_ext.cpp b/src/vulkan/vk_safe_struct_ext.cpp
index 3289616..e12aaba 100644
--- a/src/vulkan/vk_safe_struct_ext.cpp
+++ b/src/vulkan/vk_safe_struct_ext.cpp
@@ -22,6 +22,54 @@
 
 namespace vku {
 
+safe_VkAttachmentFeedbackLoopInfoEXT::safe_VkAttachmentFeedbackLoopInfoEXT(const VkAttachmentFeedbackLoopInfoEXT* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), feedbackLoopEnable(in_struct->feedbackLoopEnable) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkAttachmentFeedbackLoopInfoEXT::safe_VkAttachmentFeedbackLoopInfoEXT()
+    : sType(VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT), pNext(nullptr), feedbackLoopEnable() {}
+
+safe_VkAttachmentFeedbackLoopInfoEXT::safe_VkAttachmentFeedbackLoopInfoEXT(const safe_VkAttachmentFeedbackLoopInfoEXT& copy_src) {
+    sType = copy_src.sType;
+    feedbackLoopEnable = copy_src.feedbackLoopEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkAttachmentFeedbackLoopInfoEXT& safe_VkAttachmentFeedbackLoopInfoEXT::operator=(
+    const safe_VkAttachmentFeedbackLoopInfoEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    feedbackLoopEnable = copy_src.feedbackLoopEnable;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkAttachmentFeedbackLoopInfoEXT::~safe_VkAttachmentFeedbackLoopInfoEXT() { FreePnextChain(pNext); }
+
+void safe_VkAttachmentFeedbackLoopInfoEXT::initialize(const VkAttachmentFeedbackLoopInfoEXT* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    feedbackLoopEnable = in_struct->feedbackLoopEnable;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkAttachmentFeedbackLoopInfoEXT::initialize(const safe_VkAttachmentFeedbackLoopInfoEXT* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    feedbackLoopEnable = copy_src->feedbackLoopEnable;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkSetDescriptorBufferOffsetsInfoEXT::safe_VkSetDescriptorBufferOffsetsInfoEXT(
     const VkSetDescriptorBufferOffsetsInfoEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType),
@@ -14301,6 +14349,63 @@ void safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT::initialize(
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkPhysicalDeviceShaderFloat8FeaturesEXT::safe_VkPhysicalDeviceShaderFloat8FeaturesEXT(
+    const VkPhysicalDeviceShaderFloat8FeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      shaderFloat8(in_struct->shaderFloat8),
+      shaderFloat8CooperativeMatrix(in_struct->shaderFloat8CooperativeMatrix) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceShaderFloat8FeaturesEXT::safe_VkPhysicalDeviceShaderFloat8FeaturesEXT()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT),
+      pNext(nullptr),
+      shaderFloat8(),
+      shaderFloat8CooperativeMatrix() {}
+
+safe_VkPhysicalDeviceShaderFloat8FeaturesEXT::safe_VkPhysicalDeviceShaderFloat8FeaturesEXT(
+    const safe_VkPhysicalDeviceShaderFloat8FeaturesEXT& copy_src) {
+    sType = copy_src.sType;
+    shaderFloat8 = copy_src.shaderFloat8;
+    shaderFloat8CooperativeMatrix = copy_src.shaderFloat8CooperativeMatrix;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderFloat8FeaturesEXT& safe_VkPhysicalDeviceShaderFloat8FeaturesEXT::operator=(
+    const safe_VkPhysicalDeviceShaderFloat8FeaturesEXT& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    shaderFloat8 = copy_src.shaderFloat8;
+    shaderFloat8CooperativeMatrix = copy_src.shaderFloat8CooperativeMatrix;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderFloat8FeaturesEXT::~safe_VkPhysicalDeviceShaderFloat8FeaturesEXT() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceShaderFloat8FeaturesEXT::initialize(const VkPhysicalDeviceShaderFloat8FeaturesEXT* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    shaderFloat8 = in_struct->shaderFloat8;
+    shaderFloat8CooperativeMatrix = in_struct->shaderFloat8CooperativeMatrix;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceShaderFloat8FeaturesEXT::initialize(const safe_VkPhysicalDeviceShaderFloat8FeaturesEXT* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    shaderFloat8 = copy_src->shaderFloat8;
+    shaderFloat8CooperativeMatrix = copy_src->shaderFloat8CooperativeMatrix;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT::safe_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(
     const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
     bool copy_pnext)
diff --git a/src/vulkan/vk_safe_struct_khr.cpp b/src/vulkan/vk_safe_struct_khr.cpp
index 777704f..b74d2ee 100644
--- a/src/vulkan/vk_safe_struct_khr.cpp
+++ b/src/vulkan/vk_safe_struct_khr.cpp
@@ -11012,6 +11012,324 @@ void safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR::initialize(
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkSurfaceCapabilitiesPresentId2KHR::safe_VkSurfaceCapabilitiesPresentId2KHR(
+    const VkSurfaceCapabilitiesPresentId2KHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), presentId2Supported(in_struct->presentId2Supported) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSurfaceCapabilitiesPresentId2KHR::safe_VkSurfaceCapabilitiesPresentId2KHR()
+    : sType(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR), pNext(nullptr), presentId2Supported() {}
+
+safe_VkSurfaceCapabilitiesPresentId2KHR::safe_VkSurfaceCapabilitiesPresentId2KHR(
+    const safe_VkSurfaceCapabilitiesPresentId2KHR& copy_src) {
+    sType = copy_src.sType;
+    presentId2Supported = copy_src.presentId2Supported;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSurfaceCapabilitiesPresentId2KHR& safe_VkSurfaceCapabilitiesPresentId2KHR::operator=(
+    const safe_VkSurfaceCapabilitiesPresentId2KHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    presentId2Supported = copy_src.presentId2Supported;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSurfaceCapabilitiesPresentId2KHR::~safe_VkSurfaceCapabilitiesPresentId2KHR() { FreePnextChain(pNext); }
+
+void safe_VkSurfaceCapabilitiesPresentId2KHR::initialize(const VkSurfaceCapabilitiesPresentId2KHR* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    presentId2Supported = in_struct->presentId2Supported;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSurfaceCapabilitiesPresentId2KHR::initialize(const safe_VkSurfaceCapabilitiesPresentId2KHR* copy_src,
+                                                         [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    presentId2Supported = copy_src->presentId2Supported;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPresentId2KHR::safe_VkPresentId2KHR(const VkPresentId2KHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                           bool copy_pnext)
+    : sType(in_struct->sType), swapchainCount(in_struct->swapchainCount), pPresentIds(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pPresentIds) {
+        pPresentIds = new uint64_t[in_struct->swapchainCount];
+        memcpy((void*)pPresentIds, (void*)in_struct->pPresentIds, sizeof(uint64_t) * in_struct->swapchainCount);
+    }
+}
+
+safe_VkPresentId2KHR::safe_VkPresentId2KHR()
+    : sType(VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR), pNext(nullptr), swapchainCount(), pPresentIds(nullptr) {}
+
+safe_VkPresentId2KHR::safe_VkPresentId2KHR(const safe_VkPresentId2KHR& copy_src) {
+    sType = copy_src.sType;
+    swapchainCount = copy_src.swapchainCount;
+    pPresentIds = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pPresentIds) {
+        pPresentIds = new uint64_t[copy_src.swapchainCount];
+        memcpy((void*)pPresentIds, (void*)copy_src.pPresentIds, sizeof(uint64_t) * copy_src.swapchainCount);
+    }
+}
+
+safe_VkPresentId2KHR& safe_VkPresentId2KHR::operator=(const safe_VkPresentId2KHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pPresentIds) delete[] pPresentIds;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    swapchainCount = copy_src.swapchainCount;
+    pPresentIds = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pPresentIds) {
+        pPresentIds = new uint64_t[copy_src.swapchainCount];
+        memcpy((void*)pPresentIds, (void*)copy_src.pPresentIds, sizeof(uint64_t) * copy_src.swapchainCount);
+    }
+
+    return *this;
+}
+
+safe_VkPresentId2KHR::~safe_VkPresentId2KHR() {
+    if (pPresentIds) delete[] pPresentIds;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPresentId2KHR::initialize(const VkPresentId2KHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pPresentIds) delete[] pPresentIds;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    swapchainCount = in_struct->swapchainCount;
+    pPresentIds = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pPresentIds) {
+        pPresentIds = new uint64_t[in_struct->swapchainCount];
+        memcpy((void*)pPresentIds, (void*)in_struct->pPresentIds, sizeof(uint64_t) * in_struct->swapchainCount);
+    }
+}
+
+void safe_VkPresentId2KHR::initialize(const safe_VkPresentId2KHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    swapchainCount = copy_src->swapchainCount;
+    pPresentIds = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pPresentIds) {
+        pPresentIds = new uint64_t[copy_src->swapchainCount];
+        memcpy((void*)pPresentIds, (void*)copy_src->pPresentIds, sizeof(uint64_t) * copy_src->swapchainCount);
+    }
+}
+
+safe_VkPhysicalDevicePresentId2FeaturesKHR::safe_VkPhysicalDevicePresentId2FeaturesKHR(
+    const VkPhysicalDevicePresentId2FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), presentId2(in_struct->presentId2) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePresentId2FeaturesKHR::safe_VkPhysicalDevicePresentId2FeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR), pNext(nullptr), presentId2() {}
+
+safe_VkPhysicalDevicePresentId2FeaturesKHR::safe_VkPhysicalDevicePresentId2FeaturesKHR(
+    const safe_VkPhysicalDevicePresentId2FeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    presentId2 = copy_src.presentId2;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePresentId2FeaturesKHR& safe_VkPhysicalDevicePresentId2FeaturesKHR::operator=(
+    const safe_VkPhysicalDevicePresentId2FeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    presentId2 = copy_src.presentId2;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePresentId2FeaturesKHR::~safe_VkPhysicalDevicePresentId2FeaturesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDevicePresentId2FeaturesKHR::initialize(const VkPhysicalDevicePresentId2FeaturesKHR* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    presentId2 = in_struct->presentId2;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePresentId2FeaturesKHR::initialize(const safe_VkPhysicalDevicePresentId2FeaturesKHR* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    presentId2 = copy_src->presentId2;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkSurfaceCapabilitiesPresentWait2KHR::safe_VkSurfaceCapabilitiesPresentWait2KHR(
+    const VkSurfaceCapabilitiesPresentWait2KHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), presentWait2Supported(in_struct->presentWait2Supported) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkSurfaceCapabilitiesPresentWait2KHR::safe_VkSurfaceCapabilitiesPresentWait2KHR()
+    : sType(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR), pNext(nullptr), presentWait2Supported() {}
+
+safe_VkSurfaceCapabilitiesPresentWait2KHR::safe_VkSurfaceCapabilitiesPresentWait2KHR(
+    const safe_VkSurfaceCapabilitiesPresentWait2KHR& copy_src) {
+    sType = copy_src.sType;
+    presentWait2Supported = copy_src.presentWait2Supported;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkSurfaceCapabilitiesPresentWait2KHR& safe_VkSurfaceCapabilitiesPresentWait2KHR::operator=(
+    const safe_VkSurfaceCapabilitiesPresentWait2KHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    presentWait2Supported = copy_src.presentWait2Supported;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkSurfaceCapabilitiesPresentWait2KHR::~safe_VkSurfaceCapabilitiesPresentWait2KHR() { FreePnextChain(pNext); }
+
+void safe_VkSurfaceCapabilitiesPresentWait2KHR::initialize(const VkSurfaceCapabilitiesPresentWait2KHR* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    presentWait2Supported = in_struct->presentWait2Supported;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkSurfaceCapabilitiesPresentWait2KHR::initialize(const safe_VkSurfaceCapabilitiesPresentWait2KHR* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    presentWait2Supported = copy_src->presentWait2Supported;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDevicePresentWait2FeaturesKHR::safe_VkPhysicalDevicePresentWait2FeaturesKHR(
+    const VkPhysicalDevicePresentWait2FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), presentWait2(in_struct->presentWait2) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDevicePresentWait2FeaturesKHR::safe_VkPhysicalDevicePresentWait2FeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR), pNext(nullptr), presentWait2() {}
+
+safe_VkPhysicalDevicePresentWait2FeaturesKHR::safe_VkPhysicalDevicePresentWait2FeaturesKHR(
+    const safe_VkPhysicalDevicePresentWait2FeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    presentWait2 = copy_src.presentWait2;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDevicePresentWait2FeaturesKHR& safe_VkPhysicalDevicePresentWait2FeaturesKHR::operator=(
+    const safe_VkPhysicalDevicePresentWait2FeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    presentWait2 = copy_src.presentWait2;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePresentWait2FeaturesKHR::~safe_VkPhysicalDevicePresentWait2FeaturesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDevicePresentWait2FeaturesKHR::initialize(const VkPhysicalDevicePresentWait2FeaturesKHR* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    presentWait2 = in_struct->presentWait2;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDevicePresentWait2FeaturesKHR::initialize(const safe_VkPhysicalDevicePresentWait2FeaturesKHR* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    presentWait2 = copy_src->presentWait2;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPresentWait2InfoKHR::safe_VkPresentWait2InfoKHR(const VkPresentWait2InfoKHR* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), presentId(in_struct->presentId), timeout(in_struct->timeout) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPresentWait2InfoKHR::safe_VkPresentWait2InfoKHR()
+    : sType(VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR), pNext(nullptr), presentId(), timeout() {}
+
+safe_VkPresentWait2InfoKHR::safe_VkPresentWait2InfoKHR(const safe_VkPresentWait2InfoKHR& copy_src) {
+    sType = copy_src.sType;
+    presentId = copy_src.presentId;
+    timeout = copy_src.timeout;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPresentWait2InfoKHR& safe_VkPresentWait2InfoKHR::operator=(const safe_VkPresentWait2InfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    presentId = copy_src.presentId;
+    timeout = copy_src.timeout;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPresentWait2InfoKHR::~safe_VkPresentWait2InfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkPresentWait2InfoKHR::initialize(const VkPresentWait2InfoKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    presentId = in_struct->presentId;
+    timeout = in_struct->timeout;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPresentWait2InfoKHR::initialize(const safe_VkPresentWait2InfoKHR* copy_src,
+                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    presentId = copy_src->presentId;
+    timeout = copy_src->timeout;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
     const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
     bool copy_pnext)
@@ -13652,6 +13970,263 @@ void safe_VkVideoEncodeAV1RateControlLayerInfoKHR::initialize(const safe_VkVideo
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR::safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR(
+    const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), videoDecodeVP9(in_struct->videoDecodeVP9) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR::safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR), pNext(nullptr), videoDecodeVP9() {}
+
+safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR::safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR(
+    const safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    videoDecodeVP9 = copy_src.videoDecodeVP9;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR& safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    videoDecodeVP9 = copy_src.videoDecodeVP9;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR::~safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR::initialize(const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    videoDecodeVP9 = in_struct->videoDecodeVP9;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR::initialize(const safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    videoDecodeVP9 = copy_src->videoDecodeVP9;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoDecodeVP9ProfileInfoKHR::safe_VkVideoDecodeVP9ProfileInfoKHR(const VkVideoDecodeVP9ProfileInfoKHR* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType), stdProfile(in_struct->stdProfile) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoDecodeVP9ProfileInfoKHR::safe_VkVideoDecodeVP9ProfileInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR), pNext(nullptr), stdProfile() {}
+
+safe_VkVideoDecodeVP9ProfileInfoKHR::safe_VkVideoDecodeVP9ProfileInfoKHR(const safe_VkVideoDecodeVP9ProfileInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    stdProfile = copy_src.stdProfile;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoDecodeVP9ProfileInfoKHR& safe_VkVideoDecodeVP9ProfileInfoKHR::operator=(
+    const safe_VkVideoDecodeVP9ProfileInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    stdProfile = copy_src.stdProfile;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoDecodeVP9ProfileInfoKHR::~safe_VkVideoDecodeVP9ProfileInfoKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoDecodeVP9ProfileInfoKHR::initialize(const VkVideoDecodeVP9ProfileInfoKHR* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    stdProfile = in_struct->stdProfile;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoDecodeVP9ProfileInfoKHR::initialize(const safe_VkVideoDecodeVP9ProfileInfoKHR* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    stdProfile = copy_src->stdProfile;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoDecodeVP9CapabilitiesKHR::safe_VkVideoDecodeVP9CapabilitiesKHR(const VkVideoDecodeVP9CapabilitiesKHR* in_struct,
+                                                                           [[maybe_unused]] PNextCopyState* copy_state,
+                                                                           bool copy_pnext)
+    : sType(in_struct->sType), maxLevel(in_struct->maxLevel) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkVideoDecodeVP9CapabilitiesKHR::safe_VkVideoDecodeVP9CapabilitiesKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR), pNext(nullptr), maxLevel() {}
+
+safe_VkVideoDecodeVP9CapabilitiesKHR::safe_VkVideoDecodeVP9CapabilitiesKHR(const safe_VkVideoDecodeVP9CapabilitiesKHR& copy_src) {
+    sType = copy_src.sType;
+    maxLevel = copy_src.maxLevel;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkVideoDecodeVP9CapabilitiesKHR& safe_VkVideoDecodeVP9CapabilitiesKHR::operator=(
+    const safe_VkVideoDecodeVP9CapabilitiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxLevel = copy_src.maxLevel;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkVideoDecodeVP9CapabilitiesKHR::~safe_VkVideoDecodeVP9CapabilitiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkVideoDecodeVP9CapabilitiesKHR::initialize(const VkVideoDecodeVP9CapabilitiesKHR* in_struct,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxLevel = in_struct->maxLevel;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkVideoDecodeVP9CapabilitiesKHR::initialize(const safe_VkVideoDecodeVP9CapabilitiesKHR* copy_src,
+                                                      [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxLevel = copy_src->maxLevel;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkVideoDecodeVP9PictureInfoKHR::safe_VkVideoDecodeVP9PictureInfoKHR(const VkVideoDecodeVP9PictureInfoKHR* in_struct,
+                                                                         [[maybe_unused]] PNextCopyState* copy_state,
+                                                                         bool copy_pnext)
+    : sType(in_struct->sType),
+      pStdPictureInfo(nullptr),
+      uncompressedHeaderOffset(in_struct->uncompressedHeaderOffset),
+      compressedHeaderOffset(in_struct->compressedHeaderOffset),
+      tilesOffset(in_struct->tilesOffset) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoDecodeVP9PictureInfo(*in_struct->pStdPictureInfo);
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR; ++i) {
+        referenceNameSlotIndices[i] = in_struct->referenceNameSlotIndices[i];
+    }
+}
+
+safe_VkVideoDecodeVP9PictureInfoKHR::safe_VkVideoDecodeVP9PictureInfoKHR()
+    : sType(VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR),
+      pNext(nullptr),
+      pStdPictureInfo(nullptr),
+      uncompressedHeaderOffset(),
+      compressedHeaderOffset(),
+      tilesOffset() {}
+
+safe_VkVideoDecodeVP9PictureInfoKHR::safe_VkVideoDecodeVP9PictureInfoKHR(const safe_VkVideoDecodeVP9PictureInfoKHR& copy_src) {
+    sType = copy_src.sType;
+    pStdPictureInfo = nullptr;
+    uncompressedHeaderOffset = copy_src.uncompressedHeaderOffset;
+    compressedHeaderOffset = copy_src.compressedHeaderOffset;
+    tilesOffset = copy_src.tilesOffset;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoDecodeVP9PictureInfo(*copy_src.pStdPictureInfo);
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR; ++i) {
+        referenceNameSlotIndices[i] = copy_src.referenceNameSlotIndices[i];
+    }
+}
+
+safe_VkVideoDecodeVP9PictureInfoKHR& safe_VkVideoDecodeVP9PictureInfoKHR::operator=(
+    const safe_VkVideoDecodeVP9PictureInfoKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pStdPictureInfo) delete pStdPictureInfo;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pStdPictureInfo = nullptr;
+    uncompressedHeaderOffset = copy_src.uncompressedHeaderOffset;
+    compressedHeaderOffset = copy_src.compressedHeaderOffset;
+    tilesOffset = copy_src.tilesOffset;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoDecodeVP9PictureInfo(*copy_src.pStdPictureInfo);
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR; ++i) {
+        referenceNameSlotIndices[i] = copy_src.referenceNameSlotIndices[i];
+    }
+
+    return *this;
+}
+
+safe_VkVideoDecodeVP9PictureInfoKHR::~safe_VkVideoDecodeVP9PictureInfoKHR() {
+    if (pStdPictureInfo) delete pStdPictureInfo;
+    FreePnextChain(pNext);
+}
+
+void safe_VkVideoDecodeVP9PictureInfoKHR::initialize(const VkVideoDecodeVP9PictureInfoKHR* in_struct,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pStdPictureInfo) delete pStdPictureInfo;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pStdPictureInfo = nullptr;
+    uncompressedHeaderOffset = in_struct->uncompressedHeaderOffset;
+    compressedHeaderOffset = in_struct->compressedHeaderOffset;
+    tilesOffset = in_struct->tilesOffset;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoDecodeVP9PictureInfo(*in_struct->pStdPictureInfo);
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR; ++i) {
+        referenceNameSlotIndices[i] = in_struct->referenceNameSlotIndices[i];
+    }
+}
+
+void safe_VkVideoDecodeVP9PictureInfoKHR::initialize(const safe_VkVideoDecodeVP9PictureInfoKHR* copy_src,
+                                                     [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pStdPictureInfo = nullptr;
+    uncompressedHeaderOffset = copy_src->uncompressedHeaderOffset;
+    compressedHeaderOffset = copy_src->compressedHeaderOffset;
+    tilesOffset = copy_src->tilesOffset;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pStdPictureInfo) {
+        pStdPictureInfo = new StdVideoDecodeVP9PictureInfo(*copy_src->pStdPictureInfo);
+    }
+
+    for (uint32_t i = 0; i < VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR; ++i) {
+        referenceNameSlotIndices[i] = copy_src->referenceNameSlotIndices[i];
+    }
+}
+
 safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR::safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(
     const VkPhysicalDeviceVideoMaintenance1FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType), videoMaintenance1(in_struct->videoMaintenance1) {
@@ -13757,6 +14332,65 @@ void safe_VkVideoInlineQueryInfoKHR::initialize(const safe_VkVideoInlineQueryInf
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR::safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR(
+    const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      unifiedImageLayouts(in_struct->unifiedImageLayouts),
+      unifiedImageLayoutsVideo(in_struct->unifiedImageLayoutsVideo) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR::safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR),
+      pNext(nullptr),
+      unifiedImageLayouts(),
+      unifiedImageLayoutsVideo() {}
+
+safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR::safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR(
+    const safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    unifiedImageLayouts = copy_src.unifiedImageLayouts;
+    unifiedImageLayoutsVideo = copy_src.unifiedImageLayoutsVideo;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR& safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    unifiedImageLayouts = copy_src.unifiedImageLayouts;
+    unifiedImageLayoutsVideo = copy_src.unifiedImageLayoutsVideo;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR::~safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR::initialize(
+    const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    unifiedImageLayouts = in_struct->unifiedImageLayouts;
+    unifiedImageLayoutsVideo = in_struct->unifiedImageLayoutsVideo;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR::initialize(
+    const safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    unifiedImageLayouts = copy_src->unifiedImageLayouts;
+    unifiedImageLayoutsVideo = copy_src->unifiedImageLayoutsVideo;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkCalibratedTimestampInfoKHR::safe_VkCalibratedTimestampInfoKHR(const VkCalibratedTimestampInfoKHR* in_struct,
                                                                      [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType), timeDomain(in_struct->timeDomain) {
@@ -14835,6 +15469,161 @@ void safe_VkMemoryBarrierAccessFlags3KHR::initialize(const safe_VkMemoryBarrierA
     pNext = SafePnextCopy(copy_src->pNext);
 }
 
+safe_VkPhysicalDeviceMaintenance9FeaturesKHR::safe_VkPhysicalDeviceMaintenance9FeaturesKHR(
+    const VkPhysicalDeviceMaintenance9FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), maintenance9(in_struct->maintenance9) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMaintenance9FeaturesKHR::safe_VkPhysicalDeviceMaintenance9FeaturesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR), pNext(nullptr), maintenance9() {}
+
+safe_VkPhysicalDeviceMaintenance9FeaturesKHR::safe_VkPhysicalDeviceMaintenance9FeaturesKHR(
+    const safe_VkPhysicalDeviceMaintenance9FeaturesKHR& copy_src) {
+    sType = copy_src.sType;
+    maintenance9 = copy_src.maintenance9;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMaintenance9FeaturesKHR& safe_VkPhysicalDeviceMaintenance9FeaturesKHR::operator=(
+    const safe_VkPhysicalDeviceMaintenance9FeaturesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maintenance9 = copy_src.maintenance9;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMaintenance9FeaturesKHR::~safe_VkPhysicalDeviceMaintenance9FeaturesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceMaintenance9FeaturesKHR::initialize(const VkPhysicalDeviceMaintenance9FeaturesKHR* in_struct,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maintenance9 = in_struct->maintenance9;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMaintenance9FeaturesKHR::initialize(const safe_VkPhysicalDeviceMaintenance9FeaturesKHR* copy_src,
+                                                              [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maintenance9 = copy_src->maintenance9;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceMaintenance9PropertiesKHR::safe_VkPhysicalDeviceMaintenance9PropertiesKHR(
+    const VkPhysicalDeviceMaintenance9PropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      image2DViewOf3DSparse(in_struct->image2DViewOf3DSparse),
+      defaultVertexAttributeValue(in_struct->defaultVertexAttributeValue) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceMaintenance9PropertiesKHR::safe_VkPhysicalDeviceMaintenance9PropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR),
+      pNext(nullptr),
+      image2DViewOf3DSparse(),
+      defaultVertexAttributeValue() {}
+
+safe_VkPhysicalDeviceMaintenance9PropertiesKHR::safe_VkPhysicalDeviceMaintenance9PropertiesKHR(
+    const safe_VkPhysicalDeviceMaintenance9PropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    image2DViewOf3DSparse = copy_src.image2DViewOf3DSparse;
+    defaultVertexAttributeValue = copy_src.defaultVertexAttributeValue;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceMaintenance9PropertiesKHR& safe_VkPhysicalDeviceMaintenance9PropertiesKHR::operator=(
+    const safe_VkPhysicalDeviceMaintenance9PropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    image2DViewOf3DSparse = copy_src.image2DViewOf3DSparse;
+    defaultVertexAttributeValue = copy_src.defaultVertexAttributeValue;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceMaintenance9PropertiesKHR::~safe_VkPhysicalDeviceMaintenance9PropertiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceMaintenance9PropertiesKHR::initialize(const VkPhysicalDeviceMaintenance9PropertiesKHR* in_struct,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    image2DViewOf3DSparse = in_struct->image2DViewOf3DSparse;
+    defaultVertexAttributeValue = in_struct->defaultVertexAttributeValue;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceMaintenance9PropertiesKHR::initialize(const safe_VkPhysicalDeviceMaintenance9PropertiesKHR* copy_src,
+                                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    image2DViewOf3DSparse = copy_src->image2DViewOf3DSparse;
+    defaultVertexAttributeValue = copy_src->defaultVertexAttributeValue;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkQueueFamilyOwnershipTransferPropertiesKHR::safe_VkQueueFamilyOwnershipTransferPropertiesKHR(
+    const VkQueueFamilyOwnershipTransferPropertiesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), optimalImageTransferToQueueFamilies(in_struct->optimalImageTransferToQueueFamilies) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkQueueFamilyOwnershipTransferPropertiesKHR::safe_VkQueueFamilyOwnershipTransferPropertiesKHR()
+    : sType(VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR),
+      pNext(nullptr),
+      optimalImageTransferToQueueFamilies() {}
+
+safe_VkQueueFamilyOwnershipTransferPropertiesKHR::safe_VkQueueFamilyOwnershipTransferPropertiesKHR(
+    const safe_VkQueueFamilyOwnershipTransferPropertiesKHR& copy_src) {
+    sType = copy_src.sType;
+    optimalImageTransferToQueueFamilies = copy_src.optimalImageTransferToQueueFamilies;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkQueueFamilyOwnershipTransferPropertiesKHR& safe_VkQueueFamilyOwnershipTransferPropertiesKHR::operator=(
+    const safe_VkQueueFamilyOwnershipTransferPropertiesKHR& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    optimalImageTransferToQueueFamilies = copy_src.optimalImageTransferToQueueFamilies;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkQueueFamilyOwnershipTransferPropertiesKHR::~safe_VkQueueFamilyOwnershipTransferPropertiesKHR() { FreePnextChain(pNext); }
+
+void safe_VkQueueFamilyOwnershipTransferPropertiesKHR::initialize(const VkQueueFamilyOwnershipTransferPropertiesKHR* in_struct,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    optimalImageTransferToQueueFamilies = in_struct->optimalImageTransferToQueueFamilies;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkQueueFamilyOwnershipTransferPropertiesKHR::initialize(const safe_VkQueueFamilyOwnershipTransferPropertiesKHR* copy_src,
+                                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    optimalImageTransferToQueueFamilies = copy_src->optimalImageTransferToQueueFamilies;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
 safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR::safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR(
     const VkPhysicalDeviceVideoMaintenance2FeaturesKHR* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType), videoMaintenance2(in_struct->videoMaintenance2) {
diff --git a/src/vulkan/vk_safe_struct_utils.cpp b/src/vulkan/vk_safe_struct_utils.cpp
index 79e058c..9cddc4e 100644
--- a/src/vulkan/vk_safe_struct_utils.cpp
+++ b/src/vulkan/vk_safe_struct_utils.cpp
@@ -764,6 +764,21 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR:
                 safe_pNext = new safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR:
+                safe_pNext = new safe_VkSurfaceCapabilitiesPresentId2KHR(reinterpret_cast<const VkSurfaceCapabilitiesPresentId2KHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR:
+                safe_pNext = new safe_VkPresentId2KHR(reinterpret_cast<const VkPresentId2KHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDevicePresentId2FeaturesKHR(reinterpret_cast<const VkPhysicalDevicePresentId2FeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR:
+                safe_pNext = new safe_VkSurfaceCapabilitiesPresentWait2KHR(reinterpret_cast<const VkSurfaceCapabilitiesPresentWait2KHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDevicePresentWait2FeaturesKHR(reinterpret_cast<const VkPhysicalDevicePresentWait2FeaturesKHR *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
                 safe_pNext = new safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *>(pNext), copy_state, false);
                 break;
@@ -839,12 +854,30 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR:
                 safe_pNext = new safe_VkVideoEncodeAV1RateControlLayerInfoKHR(reinterpret_cast<const VkVideoEncodeAV1RateControlLayerInfoKHR *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR:
+                safe_pNext = new safe_VkVideoDecodeVP9ProfileInfoKHR(reinterpret_cast<const VkVideoDecodeVP9ProfileInfoKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR:
+                safe_pNext = new safe_VkVideoDecodeVP9CapabilitiesKHR(reinterpret_cast<const VkVideoDecodeVP9CapabilitiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR:
+                safe_pNext = new safe_VkVideoDecodeVP9PictureInfoKHR(reinterpret_cast<const VkVideoDecodeVP9PictureInfoKHR *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
                 safe_pNext = new safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *>(pNext), copy_state, false);
                 break;
             case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR:
                 safe_pNext = new safe_VkVideoInlineQueryInfoKHR(reinterpret_cast<const VkVideoInlineQueryInfoKHR *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT:
+                safe_pNext = new safe_VkAttachmentFeedbackLoopInfoEXT(reinterpret_cast<const VkAttachmentFeedbackLoopInfoEXT *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR:
                 safe_pNext = new safe_VkVideoEncodeQuantizationMapCapabilitiesKHR(reinterpret_cast<const VkVideoEncodeQuantizationMapCapabilitiesKHR *>(pNext), copy_state, false);
                 break;
@@ -896,6 +929,15 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR:
                 safe_pNext = new safe_VkMemoryBarrierAccessFlags3KHR(reinterpret_cast<const VkMemoryBarrierAccessFlags3KHR *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceMaintenance9FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceMaintenance9FeaturesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR:
+                safe_pNext = new safe_VkPhysicalDeviceMaintenance9PropertiesKHR(reinterpret_cast<const VkPhysicalDeviceMaintenance9PropertiesKHR *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR:
+                safe_pNext = new safe_VkQueueFamilyOwnershipTransferPropertiesKHR(reinterpret_cast<const VkQueueFamilyOwnershipTransferPropertiesKHR *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR:
                 safe_pNext = new safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceVideoMaintenance2FeaturesKHR *>(pNext), copy_state, false);
                 break;
@@ -1784,6 +1826,42 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG:
                 safe_pNext = new safe_VkDirectDriverLoadingListLUNARG(reinterpret_cast<const VkDirectDriverLoadingListLUNARG *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM:
+                safe_pNext = new safe_VkWriteDescriptorSetTensorARM(reinterpret_cast<const VkWriteDescriptorSetTensorARM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM:
+                safe_pNext = new safe_VkTensorFormatPropertiesARM(reinterpret_cast<const VkTensorFormatPropertiesARM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM:
+                safe_pNext = new safe_VkPhysicalDeviceTensorPropertiesARM(reinterpret_cast<const VkPhysicalDeviceTensorPropertiesARM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM:
+                safe_pNext = new safe_VkTensorMemoryBarrierARM(reinterpret_cast<const VkTensorMemoryBarrierARM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM:
+                safe_pNext = new safe_VkTensorDependencyInfoARM(reinterpret_cast<const VkTensorDependencyInfoARM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM:
+                safe_pNext = new safe_VkPhysicalDeviceTensorFeaturesARM(reinterpret_cast<const VkPhysicalDeviceTensorFeaturesARM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM:
+                safe_pNext = new safe_VkMemoryDedicatedAllocateInfoTensorARM(reinterpret_cast<const VkMemoryDedicatedAllocateInfoTensorARM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM:
+                safe_pNext = new safe_VkExternalMemoryTensorCreateInfoARM(reinterpret_cast<const VkExternalMemoryTensorCreateInfoARM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM:
+                safe_pNext = new safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM(reinterpret_cast<const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM:
+                safe_pNext = new safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM(reinterpret_cast<const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM:
+                safe_pNext = new safe_VkDescriptorGetTensorInfoARM(reinterpret_cast<const VkDescriptorGetTensorInfoARM *>(pNext), copy_state, false);
+                break;
+            case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM:
+                safe_pNext = new safe_VkFrameBoundaryTensorsARM(reinterpret_cast<const VkFrameBoundaryTensorsARM *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
                 safe_pNext = new safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *>(pNext), copy_state, false);
                 break;
@@ -1986,6 +2064,9 @@ void *SafePnextCopy(const void *pNext, PNextCopyState* copy_state) {
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT:
                 safe_pNext = new safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *>(pNext), copy_state, false);
                 break;
+            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT:
+                safe_pNext = new safe_VkPhysicalDeviceShaderFloat8FeaturesEXT(reinterpret_cast<const VkPhysicalDeviceShaderFloat8FeaturesEXT *>(pNext), copy_state, false);
+                break;
             case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
                 safe_pNext = new safe_VkPhysicalDeviceRayTracingValidationFeaturesNV(reinterpret_cast<const VkPhysicalDeviceRayTracingValidationFeaturesNV *>(pNext), copy_state, false);
                 break;
@@ -2854,6 +2935,21 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR:
             delete reinterpret_cast<safe_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *>(header);
             break;
+        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR:
+            delete reinterpret_cast<safe_VkSurfaceCapabilitiesPresentId2KHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR:
+            delete reinterpret_cast<safe_VkPresentId2KHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR:
+            delete reinterpret_cast<safe_VkPhysicalDevicePresentId2FeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR:
+            delete reinterpret_cast<safe_VkSurfaceCapabilitiesPresentWait2KHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR:
+            delete reinterpret_cast<safe_VkPhysicalDevicePresentWait2FeaturesKHR *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR:
             delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *>(header);
             break;
@@ -2929,12 +3025,30 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR:
             delete reinterpret_cast<safe_VkVideoEncodeAV1RateControlLayerInfoKHR *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR:
+            delete reinterpret_cast<safe_VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR:
+            delete reinterpret_cast<safe_VkVideoDecodeVP9ProfileInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR:
+            delete reinterpret_cast<safe_VkVideoDecodeVP9CapabilitiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR:
+            delete reinterpret_cast<safe_VkVideoDecodeVP9PictureInfoKHR *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR:
             delete reinterpret_cast<safe_VkPhysicalDeviceVideoMaintenance1FeaturesKHR *>(header);
             break;
         case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR:
             delete reinterpret_cast<safe_VkVideoInlineQueryInfoKHR *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR:
+            delete reinterpret_cast<safe_VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT:
+            delete reinterpret_cast<safe_VkAttachmentFeedbackLoopInfoEXT *>(header);
+            break;
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR:
             delete reinterpret_cast<safe_VkVideoEncodeQuantizationMapCapabilitiesKHR *>(header);
             break;
@@ -2986,6 +3100,15 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR:
             delete reinterpret_cast<safe_VkMemoryBarrierAccessFlags3KHR *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR:
+            delete reinterpret_cast<safe_VkPhysicalDeviceMaintenance9FeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR:
+            delete reinterpret_cast<safe_VkPhysicalDeviceMaintenance9PropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR:
+            delete reinterpret_cast<safe_VkQueueFamilyOwnershipTransferPropertiesKHR *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR:
             delete reinterpret_cast<safe_VkPhysicalDeviceVideoMaintenance2FeaturesKHR *>(header);
             break;
@@ -3874,6 +3997,42 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG:
             delete reinterpret_cast<safe_VkDirectDriverLoadingListLUNARG *>(header);
             break;
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM:
+            delete reinterpret_cast<safe_VkWriteDescriptorSetTensorARM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM:
+            delete reinterpret_cast<safe_VkTensorFormatPropertiesARM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM:
+            delete reinterpret_cast<safe_VkPhysicalDeviceTensorPropertiesARM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM:
+            delete reinterpret_cast<safe_VkTensorMemoryBarrierARM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM:
+            delete reinterpret_cast<safe_VkTensorDependencyInfoARM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM:
+            delete reinterpret_cast<safe_VkPhysicalDeviceTensorFeaturesARM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM:
+            delete reinterpret_cast<safe_VkMemoryDedicatedAllocateInfoTensorARM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM:
+            delete reinterpret_cast<safe_VkExternalMemoryTensorCreateInfoARM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM:
+            delete reinterpret_cast<safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM:
+            delete reinterpret_cast<safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM:
+            delete reinterpret_cast<safe_VkDescriptorGetTensorInfoARM *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM:
+            delete reinterpret_cast<safe_VkFrameBoundaryTensorsARM *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT:
             delete reinterpret_cast<safe_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *>(header);
             break;
@@ -4076,6 +4235,9 @@ void FreePnextChain(const void *pNext) {
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT:
             delete reinterpret_cast<safe_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *>(header);
             break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT:
+            delete reinterpret_cast<safe_VkPhysicalDeviceShaderFloat8FeaturesEXT *>(header);
+            break;
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV:
             delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingValidationFeaturesNV *>(header);
             break;
diff --git a/src/vulkan/vk_safe_struct_vendor.cpp b/src/vulkan/vk_safe_struct_vendor.cpp
index 9891ca4..a979a5a 100644
--- a/src/vulkan/vk_safe_struct_vendor.cpp
+++ b/src/vulkan/vk_safe_struct_vendor.cpp
@@ -12542,6 +12542,1781 @@ void safe_VkDirectDriverLoadingListLUNARG::initialize(const safe_VkDirectDriverL
     }
 }
 
+safe_VkTensorDescriptionARM::safe_VkTensorDescriptionARM(const VkTensorDescriptionARM* in_struct,
+                                                         [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      tiling(in_struct->tiling),
+      format(in_struct->format),
+      dimensionCount(in_struct->dimensionCount),
+      pDimensions(nullptr),
+      pStrides(nullptr),
+      usage(in_struct->usage) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pDimensions) {
+        pDimensions = new int64_t[in_struct->dimensionCount];
+        memcpy((void*)pDimensions, (void*)in_struct->pDimensions, sizeof(int64_t) * in_struct->dimensionCount);
+    }
+
+    if (in_struct->pStrides) {
+        pStrides = new int64_t[in_struct->dimensionCount];
+        memcpy((void*)pStrides, (void*)in_struct->pStrides, sizeof(int64_t) * in_struct->dimensionCount);
+    }
+}
+
+safe_VkTensorDescriptionARM::safe_VkTensorDescriptionARM()
+    : sType(VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM),
+      pNext(nullptr),
+      tiling(),
+      format(),
+      dimensionCount(),
+      pDimensions(nullptr),
+      pStrides(nullptr),
+      usage() {}
+
+safe_VkTensorDescriptionARM::safe_VkTensorDescriptionARM(const safe_VkTensorDescriptionARM& copy_src) {
+    sType = copy_src.sType;
+    tiling = copy_src.tiling;
+    format = copy_src.format;
+    dimensionCount = copy_src.dimensionCount;
+    pDimensions = nullptr;
+    pStrides = nullptr;
+    usage = copy_src.usage;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDimensions) {
+        pDimensions = new int64_t[copy_src.dimensionCount];
+        memcpy((void*)pDimensions, (void*)copy_src.pDimensions, sizeof(int64_t) * copy_src.dimensionCount);
+    }
+
+    if (copy_src.pStrides) {
+        pStrides = new int64_t[copy_src.dimensionCount];
+        memcpy((void*)pStrides, (void*)copy_src.pStrides, sizeof(int64_t) * copy_src.dimensionCount);
+    }
+}
+
+safe_VkTensorDescriptionARM& safe_VkTensorDescriptionARM::operator=(const safe_VkTensorDescriptionARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pDimensions) delete[] pDimensions;
+    if (pStrides) delete[] pStrides;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    tiling = copy_src.tiling;
+    format = copy_src.format;
+    dimensionCount = copy_src.dimensionCount;
+    pDimensions = nullptr;
+    pStrides = nullptr;
+    usage = copy_src.usage;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pDimensions) {
+        pDimensions = new int64_t[copy_src.dimensionCount];
+        memcpy((void*)pDimensions, (void*)copy_src.pDimensions, sizeof(int64_t) * copy_src.dimensionCount);
+    }
+
+    if (copy_src.pStrides) {
+        pStrides = new int64_t[copy_src.dimensionCount];
+        memcpy((void*)pStrides, (void*)copy_src.pStrides, sizeof(int64_t) * copy_src.dimensionCount);
+    }
+
+    return *this;
+}
+
+safe_VkTensorDescriptionARM::~safe_VkTensorDescriptionARM() {
+    if (pDimensions) delete[] pDimensions;
+    if (pStrides) delete[] pStrides;
+    FreePnextChain(pNext);
+}
+
+void safe_VkTensorDescriptionARM::initialize(const VkTensorDescriptionARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pDimensions) delete[] pDimensions;
+    if (pStrides) delete[] pStrides;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    tiling = in_struct->tiling;
+    format = in_struct->format;
+    dimensionCount = in_struct->dimensionCount;
+    pDimensions = nullptr;
+    pStrides = nullptr;
+    usage = in_struct->usage;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pDimensions) {
+        pDimensions = new int64_t[in_struct->dimensionCount];
+        memcpy((void*)pDimensions, (void*)in_struct->pDimensions, sizeof(int64_t) * in_struct->dimensionCount);
+    }
+
+    if (in_struct->pStrides) {
+        pStrides = new int64_t[in_struct->dimensionCount];
+        memcpy((void*)pStrides, (void*)in_struct->pStrides, sizeof(int64_t) * in_struct->dimensionCount);
+    }
+}
+
+void safe_VkTensorDescriptionARM::initialize(const safe_VkTensorDescriptionARM* copy_src,
+                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    tiling = copy_src->tiling;
+    format = copy_src->format;
+    dimensionCount = copy_src->dimensionCount;
+    pDimensions = nullptr;
+    pStrides = nullptr;
+    usage = copy_src->usage;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pDimensions) {
+        pDimensions = new int64_t[copy_src->dimensionCount];
+        memcpy((void*)pDimensions, (void*)copy_src->pDimensions, sizeof(int64_t) * copy_src->dimensionCount);
+    }
+
+    if (copy_src->pStrides) {
+        pStrides = new int64_t[copy_src->dimensionCount];
+        memcpy((void*)pStrides, (void*)copy_src->pStrides, sizeof(int64_t) * copy_src->dimensionCount);
+    }
+}
+
+safe_VkTensorCreateInfoARM::safe_VkTensorCreateInfoARM(const VkTensorCreateInfoARM* in_struct,
+                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      flags(in_struct->flags),
+      pDescription(nullptr),
+      sharingMode(in_struct->sharingMode),
+      queueFamilyIndexCount(0),
+      pQueueFamilyIndices(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pDescription) pDescription = new safe_VkTensorDescriptionARM(in_struct->pDescription);
+
+    if ((in_struct->sharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->pQueueFamilyIndices) {
+        pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
+        memcpy((void*)pQueueFamilyIndices, (void*)in_struct->pQueueFamilyIndices,
+               sizeof(uint32_t) * in_struct->queueFamilyIndexCount);
+        queueFamilyIndexCount = in_struct->queueFamilyIndexCount;
+    } else {
+        queueFamilyIndexCount = 0;
+    }
+}
+
+safe_VkTensorCreateInfoARM::safe_VkTensorCreateInfoARM()
+    : sType(VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM),
+      pNext(nullptr),
+      flags(),
+      pDescription(nullptr),
+      sharingMode(),
+      queueFamilyIndexCount(),
+      pQueueFamilyIndices(nullptr) {}
+
+safe_VkTensorCreateInfoARM::safe_VkTensorCreateInfoARM(const safe_VkTensorCreateInfoARM& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pDescription = nullptr;
+    sharingMode = copy_src.sharingMode;
+    pQueueFamilyIndices = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pDescription) pDescription = new safe_VkTensorDescriptionARM(*copy_src.pDescription);
+
+    if ((copy_src.sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src.pQueueFamilyIndices) {
+        pQueueFamilyIndices = new uint32_t[copy_src.queueFamilyIndexCount];
+        memcpy((void*)pQueueFamilyIndices, (void*)copy_src.pQueueFamilyIndices, sizeof(uint32_t) * copy_src.queueFamilyIndexCount);
+        queueFamilyIndexCount = copy_src.queueFamilyIndexCount;
+    } else {
+        queueFamilyIndexCount = 0;
+    }
+}
+
+safe_VkTensorCreateInfoARM& safe_VkTensorCreateInfoARM::operator=(const safe_VkTensorCreateInfoARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pDescription) delete pDescription;
+    if (pQueueFamilyIndices) delete[] pQueueFamilyIndices;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pDescription = nullptr;
+    sharingMode = copy_src.sharingMode;
+    pQueueFamilyIndices = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pDescription) pDescription = new safe_VkTensorDescriptionARM(*copy_src.pDescription);
+
+    if ((copy_src.sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src.pQueueFamilyIndices) {
+        pQueueFamilyIndices = new uint32_t[copy_src.queueFamilyIndexCount];
+        memcpy((void*)pQueueFamilyIndices, (void*)copy_src.pQueueFamilyIndices, sizeof(uint32_t) * copy_src.queueFamilyIndexCount);
+        queueFamilyIndexCount = copy_src.queueFamilyIndexCount;
+    } else {
+        queueFamilyIndexCount = 0;
+    }
+
+    return *this;
+}
+
+safe_VkTensorCreateInfoARM::~safe_VkTensorCreateInfoARM() {
+    if (pDescription) delete pDescription;
+    if (pQueueFamilyIndices) delete[] pQueueFamilyIndices;
+    FreePnextChain(pNext);
+}
+
+void safe_VkTensorCreateInfoARM::initialize(const VkTensorCreateInfoARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pDescription) delete pDescription;
+    if (pQueueFamilyIndices) delete[] pQueueFamilyIndices;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    pDescription = nullptr;
+    sharingMode = in_struct->sharingMode;
+    pQueueFamilyIndices = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (in_struct->pDescription) pDescription = new safe_VkTensorDescriptionARM(in_struct->pDescription);
+
+    if ((in_struct->sharingMode == VK_SHARING_MODE_CONCURRENT) && in_struct->pQueueFamilyIndices) {
+        pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
+        memcpy((void*)pQueueFamilyIndices, (void*)in_struct->pQueueFamilyIndices,
+               sizeof(uint32_t) * in_struct->queueFamilyIndexCount);
+        queueFamilyIndexCount = in_struct->queueFamilyIndexCount;
+    } else {
+        queueFamilyIndexCount = 0;
+    }
+}
+
+void safe_VkTensorCreateInfoARM::initialize(const safe_VkTensorCreateInfoARM* copy_src,
+                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pDescription = nullptr;
+    sharingMode = copy_src->sharingMode;
+    pQueueFamilyIndices = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (copy_src->pDescription) pDescription = new safe_VkTensorDescriptionARM(*copy_src->pDescription);
+
+    if ((copy_src->sharingMode == VK_SHARING_MODE_CONCURRENT) && copy_src->pQueueFamilyIndices) {
+        pQueueFamilyIndices = new uint32_t[copy_src->queueFamilyIndexCount];
+        memcpy((void*)pQueueFamilyIndices, (void*)copy_src->pQueueFamilyIndices,
+               sizeof(uint32_t) * copy_src->queueFamilyIndexCount);
+        queueFamilyIndexCount = copy_src->queueFamilyIndexCount;
+    } else {
+        queueFamilyIndexCount = 0;
+    }
+}
+
+safe_VkTensorViewCreateInfoARM::safe_VkTensorViewCreateInfoARM(const VkTensorViewCreateInfoARM* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags), tensor(in_struct->tensor), format(in_struct->format) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkTensorViewCreateInfoARM::safe_VkTensorViewCreateInfoARM()
+    : sType(VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM), pNext(nullptr), flags(), tensor(), format() {}
+
+safe_VkTensorViewCreateInfoARM::safe_VkTensorViewCreateInfoARM(const safe_VkTensorViewCreateInfoARM& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    tensor = copy_src.tensor;
+    format = copy_src.format;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkTensorViewCreateInfoARM& safe_VkTensorViewCreateInfoARM::operator=(const safe_VkTensorViewCreateInfoARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    tensor = copy_src.tensor;
+    format = copy_src.format;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkTensorViewCreateInfoARM::~safe_VkTensorViewCreateInfoARM() { FreePnextChain(pNext); }
+
+void safe_VkTensorViewCreateInfoARM::initialize(const VkTensorViewCreateInfoARM* in_struct,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    tensor = in_struct->tensor;
+    format = in_struct->format;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkTensorViewCreateInfoARM::initialize(const safe_VkTensorViewCreateInfoARM* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    tensor = copy_src->tensor;
+    format = copy_src->format;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkTensorMemoryRequirementsInfoARM::safe_VkTensorMemoryRequirementsInfoARM(const VkTensorMemoryRequirementsInfoARM* in_struct,
+                                                                               [[maybe_unused]] PNextCopyState* copy_state,
+                                                                               bool copy_pnext)
+    : sType(in_struct->sType), tensor(in_struct->tensor) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkTensorMemoryRequirementsInfoARM::safe_VkTensorMemoryRequirementsInfoARM()
+    : sType(VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM), pNext(nullptr), tensor() {}
+
+safe_VkTensorMemoryRequirementsInfoARM::safe_VkTensorMemoryRequirementsInfoARM(
+    const safe_VkTensorMemoryRequirementsInfoARM& copy_src) {
+    sType = copy_src.sType;
+    tensor = copy_src.tensor;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkTensorMemoryRequirementsInfoARM& safe_VkTensorMemoryRequirementsInfoARM::operator=(
+    const safe_VkTensorMemoryRequirementsInfoARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    tensor = copy_src.tensor;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkTensorMemoryRequirementsInfoARM::~safe_VkTensorMemoryRequirementsInfoARM() { FreePnextChain(pNext); }
+
+void safe_VkTensorMemoryRequirementsInfoARM::initialize(const VkTensorMemoryRequirementsInfoARM* in_struct,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    tensor = in_struct->tensor;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkTensorMemoryRequirementsInfoARM::initialize(const safe_VkTensorMemoryRequirementsInfoARM* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    tensor = copy_src->tensor;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkBindTensorMemoryInfoARM::safe_VkBindTensorMemoryInfoARM(const VkBindTensorMemoryInfoARM* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), tensor(in_struct->tensor), memory(in_struct->memory), memoryOffset(in_struct->memoryOffset) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkBindTensorMemoryInfoARM::safe_VkBindTensorMemoryInfoARM()
+    : sType(VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM), pNext(nullptr), tensor(), memory(), memoryOffset() {}
+
+safe_VkBindTensorMemoryInfoARM::safe_VkBindTensorMemoryInfoARM(const safe_VkBindTensorMemoryInfoARM& copy_src) {
+    sType = copy_src.sType;
+    tensor = copy_src.tensor;
+    memory = copy_src.memory;
+    memoryOffset = copy_src.memoryOffset;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkBindTensorMemoryInfoARM& safe_VkBindTensorMemoryInfoARM::operator=(const safe_VkBindTensorMemoryInfoARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    tensor = copy_src.tensor;
+    memory = copy_src.memory;
+    memoryOffset = copy_src.memoryOffset;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkBindTensorMemoryInfoARM::~safe_VkBindTensorMemoryInfoARM() { FreePnextChain(pNext); }
+
+void safe_VkBindTensorMemoryInfoARM::initialize(const VkBindTensorMemoryInfoARM* in_struct,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    tensor = in_struct->tensor;
+    memory = in_struct->memory;
+    memoryOffset = in_struct->memoryOffset;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkBindTensorMemoryInfoARM::initialize(const safe_VkBindTensorMemoryInfoARM* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    tensor = copy_src->tensor;
+    memory = copy_src->memory;
+    memoryOffset = copy_src->memoryOffset;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkWriteDescriptorSetTensorARM::safe_VkWriteDescriptorSetTensorARM(const VkWriteDescriptorSetTensorARM* in_struct,
+                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), tensorViewCount(in_struct->tensorViewCount), pTensorViews(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (tensorViewCount && in_struct->pTensorViews) {
+        pTensorViews = new VkTensorViewARM[tensorViewCount];
+        for (uint32_t i = 0; i < tensorViewCount; ++i) {
+            pTensorViews[i] = in_struct->pTensorViews[i];
+        }
+    }
+}
+
+safe_VkWriteDescriptorSetTensorARM::safe_VkWriteDescriptorSetTensorARM()
+    : sType(VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM), pNext(nullptr), tensorViewCount(), pTensorViews(nullptr) {}
+
+safe_VkWriteDescriptorSetTensorARM::safe_VkWriteDescriptorSetTensorARM(const safe_VkWriteDescriptorSetTensorARM& copy_src) {
+    sType = copy_src.sType;
+    tensorViewCount = copy_src.tensorViewCount;
+    pTensorViews = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (tensorViewCount && copy_src.pTensorViews) {
+        pTensorViews = new VkTensorViewARM[tensorViewCount];
+        for (uint32_t i = 0; i < tensorViewCount; ++i) {
+            pTensorViews[i] = copy_src.pTensorViews[i];
+        }
+    }
+}
+
+safe_VkWriteDescriptorSetTensorARM& safe_VkWriteDescriptorSetTensorARM::operator=(
+    const safe_VkWriteDescriptorSetTensorARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pTensorViews) delete[] pTensorViews;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    tensorViewCount = copy_src.tensorViewCount;
+    pTensorViews = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (tensorViewCount && copy_src.pTensorViews) {
+        pTensorViews = new VkTensorViewARM[tensorViewCount];
+        for (uint32_t i = 0; i < tensorViewCount; ++i) {
+            pTensorViews[i] = copy_src.pTensorViews[i];
+        }
+    }
+
+    return *this;
+}
+
+safe_VkWriteDescriptorSetTensorARM::~safe_VkWriteDescriptorSetTensorARM() {
+    if (pTensorViews) delete[] pTensorViews;
+    FreePnextChain(pNext);
+}
+
+void safe_VkWriteDescriptorSetTensorARM::initialize(const VkWriteDescriptorSetTensorARM* in_struct,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pTensorViews) delete[] pTensorViews;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    tensorViewCount = in_struct->tensorViewCount;
+    pTensorViews = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (tensorViewCount && in_struct->pTensorViews) {
+        pTensorViews = new VkTensorViewARM[tensorViewCount];
+        for (uint32_t i = 0; i < tensorViewCount; ++i) {
+            pTensorViews[i] = in_struct->pTensorViews[i];
+        }
+    }
+}
+
+void safe_VkWriteDescriptorSetTensorARM::initialize(const safe_VkWriteDescriptorSetTensorARM* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    tensorViewCount = copy_src->tensorViewCount;
+    pTensorViews = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (tensorViewCount && copy_src->pTensorViews) {
+        pTensorViews = new VkTensorViewARM[tensorViewCount];
+        for (uint32_t i = 0; i < tensorViewCount; ++i) {
+            pTensorViews[i] = copy_src->pTensorViews[i];
+        }
+    }
+}
+
+safe_VkTensorFormatPropertiesARM::safe_VkTensorFormatPropertiesARM(const VkTensorFormatPropertiesARM* in_struct,
+                                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      optimalTilingTensorFeatures(in_struct->optimalTilingTensorFeatures),
+      linearTilingTensorFeatures(in_struct->linearTilingTensorFeatures) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkTensorFormatPropertiesARM::safe_VkTensorFormatPropertiesARM()
+    : sType(VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM),
+      pNext(nullptr),
+      optimalTilingTensorFeatures(),
+      linearTilingTensorFeatures() {}
+
+safe_VkTensorFormatPropertiesARM::safe_VkTensorFormatPropertiesARM(const safe_VkTensorFormatPropertiesARM& copy_src) {
+    sType = copy_src.sType;
+    optimalTilingTensorFeatures = copy_src.optimalTilingTensorFeatures;
+    linearTilingTensorFeatures = copy_src.linearTilingTensorFeatures;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkTensorFormatPropertiesARM& safe_VkTensorFormatPropertiesARM::operator=(const safe_VkTensorFormatPropertiesARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    optimalTilingTensorFeatures = copy_src.optimalTilingTensorFeatures;
+    linearTilingTensorFeatures = copy_src.linearTilingTensorFeatures;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkTensorFormatPropertiesARM::~safe_VkTensorFormatPropertiesARM() { FreePnextChain(pNext); }
+
+void safe_VkTensorFormatPropertiesARM::initialize(const VkTensorFormatPropertiesARM* in_struct,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    optimalTilingTensorFeatures = in_struct->optimalTilingTensorFeatures;
+    linearTilingTensorFeatures = in_struct->linearTilingTensorFeatures;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkTensorFormatPropertiesARM::initialize(const safe_VkTensorFormatPropertiesARM* copy_src,
+                                                  [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    optimalTilingTensorFeatures = copy_src->optimalTilingTensorFeatures;
+    linearTilingTensorFeatures = copy_src->linearTilingTensorFeatures;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceTensorPropertiesARM::safe_VkPhysicalDeviceTensorPropertiesARM(
+    const VkPhysicalDeviceTensorPropertiesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      maxTensorDimensionCount(in_struct->maxTensorDimensionCount),
+      maxTensorElements(in_struct->maxTensorElements),
+      maxPerDimensionTensorElements(in_struct->maxPerDimensionTensorElements),
+      maxTensorStride(in_struct->maxTensorStride),
+      maxTensorSize(in_struct->maxTensorSize),
+      maxTensorShaderAccessArrayLength(in_struct->maxTensorShaderAccessArrayLength),
+      maxTensorShaderAccessSize(in_struct->maxTensorShaderAccessSize),
+      maxDescriptorSetStorageTensors(in_struct->maxDescriptorSetStorageTensors),
+      maxPerStageDescriptorSetStorageTensors(in_struct->maxPerStageDescriptorSetStorageTensors),
+      maxDescriptorSetUpdateAfterBindStorageTensors(in_struct->maxDescriptorSetUpdateAfterBindStorageTensors),
+      maxPerStageDescriptorUpdateAfterBindStorageTensors(in_struct->maxPerStageDescriptorUpdateAfterBindStorageTensors),
+      shaderStorageTensorArrayNonUniformIndexingNative(in_struct->shaderStorageTensorArrayNonUniformIndexingNative),
+      shaderTensorSupportedStages(in_struct->shaderTensorSupportedStages) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceTensorPropertiesARM::safe_VkPhysicalDeviceTensorPropertiesARM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM),
+      pNext(nullptr),
+      maxTensorDimensionCount(),
+      maxTensorElements(),
+      maxPerDimensionTensorElements(),
+      maxTensorStride(),
+      maxTensorSize(),
+      maxTensorShaderAccessArrayLength(),
+      maxTensorShaderAccessSize(),
+      maxDescriptorSetStorageTensors(),
+      maxPerStageDescriptorSetStorageTensors(),
+      maxDescriptorSetUpdateAfterBindStorageTensors(),
+      maxPerStageDescriptorUpdateAfterBindStorageTensors(),
+      shaderStorageTensorArrayNonUniformIndexingNative(),
+      shaderTensorSupportedStages() {}
+
+safe_VkPhysicalDeviceTensorPropertiesARM::safe_VkPhysicalDeviceTensorPropertiesARM(
+    const safe_VkPhysicalDeviceTensorPropertiesARM& copy_src) {
+    sType = copy_src.sType;
+    maxTensorDimensionCount = copy_src.maxTensorDimensionCount;
+    maxTensorElements = copy_src.maxTensorElements;
+    maxPerDimensionTensorElements = copy_src.maxPerDimensionTensorElements;
+    maxTensorStride = copy_src.maxTensorStride;
+    maxTensorSize = copy_src.maxTensorSize;
+    maxTensorShaderAccessArrayLength = copy_src.maxTensorShaderAccessArrayLength;
+    maxTensorShaderAccessSize = copy_src.maxTensorShaderAccessSize;
+    maxDescriptorSetStorageTensors = copy_src.maxDescriptorSetStorageTensors;
+    maxPerStageDescriptorSetStorageTensors = copy_src.maxPerStageDescriptorSetStorageTensors;
+    maxDescriptorSetUpdateAfterBindStorageTensors = copy_src.maxDescriptorSetUpdateAfterBindStorageTensors;
+    maxPerStageDescriptorUpdateAfterBindStorageTensors = copy_src.maxPerStageDescriptorUpdateAfterBindStorageTensors;
+    shaderStorageTensorArrayNonUniformIndexingNative = copy_src.shaderStorageTensorArrayNonUniformIndexingNative;
+    shaderTensorSupportedStages = copy_src.shaderTensorSupportedStages;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceTensorPropertiesARM& safe_VkPhysicalDeviceTensorPropertiesARM::operator=(
+    const safe_VkPhysicalDeviceTensorPropertiesARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    maxTensorDimensionCount = copy_src.maxTensorDimensionCount;
+    maxTensorElements = copy_src.maxTensorElements;
+    maxPerDimensionTensorElements = copy_src.maxPerDimensionTensorElements;
+    maxTensorStride = copy_src.maxTensorStride;
+    maxTensorSize = copy_src.maxTensorSize;
+    maxTensorShaderAccessArrayLength = copy_src.maxTensorShaderAccessArrayLength;
+    maxTensorShaderAccessSize = copy_src.maxTensorShaderAccessSize;
+    maxDescriptorSetStorageTensors = copy_src.maxDescriptorSetStorageTensors;
+    maxPerStageDescriptorSetStorageTensors = copy_src.maxPerStageDescriptorSetStorageTensors;
+    maxDescriptorSetUpdateAfterBindStorageTensors = copy_src.maxDescriptorSetUpdateAfterBindStorageTensors;
+    maxPerStageDescriptorUpdateAfterBindStorageTensors = copy_src.maxPerStageDescriptorUpdateAfterBindStorageTensors;
+    shaderStorageTensorArrayNonUniformIndexingNative = copy_src.shaderStorageTensorArrayNonUniformIndexingNative;
+    shaderTensorSupportedStages = copy_src.shaderTensorSupportedStages;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceTensorPropertiesARM::~safe_VkPhysicalDeviceTensorPropertiesARM() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceTensorPropertiesARM::initialize(const VkPhysicalDeviceTensorPropertiesARM* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    maxTensorDimensionCount = in_struct->maxTensorDimensionCount;
+    maxTensorElements = in_struct->maxTensorElements;
+    maxPerDimensionTensorElements = in_struct->maxPerDimensionTensorElements;
+    maxTensorStride = in_struct->maxTensorStride;
+    maxTensorSize = in_struct->maxTensorSize;
+    maxTensorShaderAccessArrayLength = in_struct->maxTensorShaderAccessArrayLength;
+    maxTensorShaderAccessSize = in_struct->maxTensorShaderAccessSize;
+    maxDescriptorSetStorageTensors = in_struct->maxDescriptorSetStorageTensors;
+    maxPerStageDescriptorSetStorageTensors = in_struct->maxPerStageDescriptorSetStorageTensors;
+    maxDescriptorSetUpdateAfterBindStorageTensors = in_struct->maxDescriptorSetUpdateAfterBindStorageTensors;
+    maxPerStageDescriptorUpdateAfterBindStorageTensors = in_struct->maxPerStageDescriptorUpdateAfterBindStorageTensors;
+    shaderStorageTensorArrayNonUniformIndexingNative = in_struct->shaderStorageTensorArrayNonUniformIndexingNative;
+    shaderTensorSupportedStages = in_struct->shaderTensorSupportedStages;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceTensorPropertiesARM::initialize(const safe_VkPhysicalDeviceTensorPropertiesARM* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    maxTensorDimensionCount = copy_src->maxTensorDimensionCount;
+    maxTensorElements = copy_src->maxTensorElements;
+    maxPerDimensionTensorElements = copy_src->maxPerDimensionTensorElements;
+    maxTensorStride = copy_src->maxTensorStride;
+    maxTensorSize = copy_src->maxTensorSize;
+    maxTensorShaderAccessArrayLength = copy_src->maxTensorShaderAccessArrayLength;
+    maxTensorShaderAccessSize = copy_src->maxTensorShaderAccessSize;
+    maxDescriptorSetStorageTensors = copy_src->maxDescriptorSetStorageTensors;
+    maxPerStageDescriptorSetStorageTensors = copy_src->maxPerStageDescriptorSetStorageTensors;
+    maxDescriptorSetUpdateAfterBindStorageTensors = copy_src->maxDescriptorSetUpdateAfterBindStorageTensors;
+    maxPerStageDescriptorUpdateAfterBindStorageTensors = copy_src->maxPerStageDescriptorUpdateAfterBindStorageTensors;
+    shaderStorageTensorArrayNonUniformIndexingNative = copy_src->shaderStorageTensorArrayNonUniformIndexingNative;
+    shaderTensorSupportedStages = copy_src->shaderTensorSupportedStages;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkTensorMemoryBarrierARM::safe_VkTensorMemoryBarrierARM(const VkTensorMemoryBarrierARM* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      srcStageMask(in_struct->srcStageMask),
+      srcAccessMask(in_struct->srcAccessMask),
+      dstStageMask(in_struct->dstStageMask),
+      dstAccessMask(in_struct->dstAccessMask),
+      srcQueueFamilyIndex(in_struct->srcQueueFamilyIndex),
+      dstQueueFamilyIndex(in_struct->dstQueueFamilyIndex),
+      tensor(in_struct->tensor) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkTensorMemoryBarrierARM::safe_VkTensorMemoryBarrierARM()
+    : sType(VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM),
+      pNext(nullptr),
+      srcStageMask(),
+      srcAccessMask(),
+      dstStageMask(),
+      dstAccessMask(),
+      srcQueueFamilyIndex(),
+      dstQueueFamilyIndex(),
+      tensor() {}
+
+safe_VkTensorMemoryBarrierARM::safe_VkTensorMemoryBarrierARM(const safe_VkTensorMemoryBarrierARM& copy_src) {
+    sType = copy_src.sType;
+    srcStageMask = copy_src.srcStageMask;
+    srcAccessMask = copy_src.srcAccessMask;
+    dstStageMask = copy_src.dstStageMask;
+    dstAccessMask = copy_src.dstAccessMask;
+    srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex;
+    dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex;
+    tensor = copy_src.tensor;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkTensorMemoryBarrierARM& safe_VkTensorMemoryBarrierARM::operator=(const safe_VkTensorMemoryBarrierARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    srcStageMask = copy_src.srcStageMask;
+    srcAccessMask = copy_src.srcAccessMask;
+    dstStageMask = copy_src.dstStageMask;
+    dstAccessMask = copy_src.dstAccessMask;
+    srcQueueFamilyIndex = copy_src.srcQueueFamilyIndex;
+    dstQueueFamilyIndex = copy_src.dstQueueFamilyIndex;
+    tensor = copy_src.tensor;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkTensorMemoryBarrierARM::~safe_VkTensorMemoryBarrierARM() { FreePnextChain(pNext); }
+
+void safe_VkTensorMemoryBarrierARM::initialize(const VkTensorMemoryBarrierARM* in_struct,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    srcStageMask = in_struct->srcStageMask;
+    srcAccessMask = in_struct->srcAccessMask;
+    dstStageMask = in_struct->dstStageMask;
+    dstAccessMask = in_struct->dstAccessMask;
+    srcQueueFamilyIndex = in_struct->srcQueueFamilyIndex;
+    dstQueueFamilyIndex = in_struct->dstQueueFamilyIndex;
+    tensor = in_struct->tensor;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkTensorMemoryBarrierARM::initialize(const safe_VkTensorMemoryBarrierARM* copy_src,
+                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    srcStageMask = copy_src->srcStageMask;
+    srcAccessMask = copy_src->srcAccessMask;
+    dstStageMask = copy_src->dstStageMask;
+    dstAccessMask = copy_src->dstAccessMask;
+    srcQueueFamilyIndex = copy_src->srcQueueFamilyIndex;
+    dstQueueFamilyIndex = copy_src->dstQueueFamilyIndex;
+    tensor = copy_src->tensor;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkTensorDependencyInfoARM::safe_VkTensorDependencyInfoARM(const VkTensorDependencyInfoARM* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), tensorMemoryBarrierCount(in_struct->tensorMemoryBarrierCount), pTensorMemoryBarriers(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pTensorMemoryBarriers)
+        pTensorMemoryBarriers = new safe_VkTensorMemoryBarrierARM(in_struct->pTensorMemoryBarriers);
+}
+
+safe_VkTensorDependencyInfoARM::safe_VkTensorDependencyInfoARM()
+    : sType(VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM),
+      pNext(nullptr),
+      tensorMemoryBarrierCount(),
+      pTensorMemoryBarriers(nullptr) {}
+
+safe_VkTensorDependencyInfoARM::safe_VkTensorDependencyInfoARM(const safe_VkTensorDependencyInfoARM& copy_src) {
+    sType = copy_src.sType;
+    tensorMemoryBarrierCount = copy_src.tensorMemoryBarrierCount;
+    pTensorMemoryBarriers = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pTensorMemoryBarriers) pTensorMemoryBarriers = new safe_VkTensorMemoryBarrierARM(*copy_src.pTensorMemoryBarriers);
+}
+
+safe_VkTensorDependencyInfoARM& safe_VkTensorDependencyInfoARM::operator=(const safe_VkTensorDependencyInfoARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pTensorMemoryBarriers) delete pTensorMemoryBarriers;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    tensorMemoryBarrierCount = copy_src.tensorMemoryBarrierCount;
+    pTensorMemoryBarriers = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pTensorMemoryBarriers) pTensorMemoryBarriers = new safe_VkTensorMemoryBarrierARM(*copy_src.pTensorMemoryBarriers);
+
+    return *this;
+}
+
+safe_VkTensorDependencyInfoARM::~safe_VkTensorDependencyInfoARM() {
+    if (pTensorMemoryBarriers) delete pTensorMemoryBarriers;
+    FreePnextChain(pNext);
+}
+
+void safe_VkTensorDependencyInfoARM::initialize(const VkTensorDependencyInfoARM* in_struct,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pTensorMemoryBarriers) delete pTensorMemoryBarriers;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    tensorMemoryBarrierCount = in_struct->tensorMemoryBarrierCount;
+    pTensorMemoryBarriers = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (in_struct->pTensorMemoryBarriers)
+        pTensorMemoryBarriers = new safe_VkTensorMemoryBarrierARM(in_struct->pTensorMemoryBarriers);
+}
+
+void safe_VkTensorDependencyInfoARM::initialize(const safe_VkTensorDependencyInfoARM* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    tensorMemoryBarrierCount = copy_src->tensorMemoryBarrierCount;
+    pTensorMemoryBarriers = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (copy_src->pTensorMemoryBarriers)
+        pTensorMemoryBarriers = new safe_VkTensorMemoryBarrierARM(*copy_src->pTensorMemoryBarriers);
+}
+
+safe_VkPhysicalDeviceTensorFeaturesARM::safe_VkPhysicalDeviceTensorFeaturesARM(const VkPhysicalDeviceTensorFeaturesARM* in_struct,
+                                                                               [[maybe_unused]] PNextCopyState* copy_state,
+                                                                               bool copy_pnext)
+    : sType(in_struct->sType),
+      tensorNonPacked(in_struct->tensorNonPacked),
+      shaderTensorAccess(in_struct->shaderTensorAccess),
+      shaderStorageTensorArrayDynamicIndexing(in_struct->shaderStorageTensorArrayDynamicIndexing),
+      shaderStorageTensorArrayNonUniformIndexing(in_struct->shaderStorageTensorArrayNonUniformIndexing),
+      descriptorBindingStorageTensorUpdateAfterBind(in_struct->descriptorBindingStorageTensorUpdateAfterBind),
+      tensors(in_struct->tensors) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceTensorFeaturesARM::safe_VkPhysicalDeviceTensorFeaturesARM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM),
+      pNext(nullptr),
+      tensorNonPacked(),
+      shaderTensorAccess(),
+      shaderStorageTensorArrayDynamicIndexing(),
+      shaderStorageTensorArrayNonUniformIndexing(),
+      descriptorBindingStorageTensorUpdateAfterBind(),
+      tensors() {}
+
+safe_VkPhysicalDeviceTensorFeaturesARM::safe_VkPhysicalDeviceTensorFeaturesARM(
+    const safe_VkPhysicalDeviceTensorFeaturesARM& copy_src) {
+    sType = copy_src.sType;
+    tensorNonPacked = copy_src.tensorNonPacked;
+    shaderTensorAccess = copy_src.shaderTensorAccess;
+    shaderStorageTensorArrayDynamicIndexing = copy_src.shaderStorageTensorArrayDynamicIndexing;
+    shaderStorageTensorArrayNonUniformIndexing = copy_src.shaderStorageTensorArrayNonUniformIndexing;
+    descriptorBindingStorageTensorUpdateAfterBind = copy_src.descriptorBindingStorageTensorUpdateAfterBind;
+    tensors = copy_src.tensors;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceTensorFeaturesARM& safe_VkPhysicalDeviceTensorFeaturesARM::operator=(
+    const safe_VkPhysicalDeviceTensorFeaturesARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    tensorNonPacked = copy_src.tensorNonPacked;
+    shaderTensorAccess = copy_src.shaderTensorAccess;
+    shaderStorageTensorArrayDynamicIndexing = copy_src.shaderStorageTensorArrayDynamicIndexing;
+    shaderStorageTensorArrayNonUniformIndexing = copy_src.shaderStorageTensorArrayNonUniformIndexing;
+    descriptorBindingStorageTensorUpdateAfterBind = copy_src.descriptorBindingStorageTensorUpdateAfterBind;
+    tensors = copy_src.tensors;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceTensorFeaturesARM::~safe_VkPhysicalDeviceTensorFeaturesARM() { FreePnextChain(pNext); }
+
+void safe_VkPhysicalDeviceTensorFeaturesARM::initialize(const VkPhysicalDeviceTensorFeaturesARM* in_struct,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    tensorNonPacked = in_struct->tensorNonPacked;
+    shaderTensorAccess = in_struct->shaderTensorAccess;
+    shaderStorageTensorArrayDynamicIndexing = in_struct->shaderStorageTensorArrayDynamicIndexing;
+    shaderStorageTensorArrayNonUniformIndexing = in_struct->shaderStorageTensorArrayNonUniformIndexing;
+    descriptorBindingStorageTensorUpdateAfterBind = in_struct->descriptorBindingStorageTensorUpdateAfterBind;
+    tensors = in_struct->tensors;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceTensorFeaturesARM::initialize(const safe_VkPhysicalDeviceTensorFeaturesARM* copy_src,
+                                                        [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    tensorNonPacked = copy_src->tensorNonPacked;
+    shaderTensorAccess = copy_src->shaderTensorAccess;
+    shaderStorageTensorArrayDynamicIndexing = copy_src->shaderStorageTensorArrayDynamicIndexing;
+    shaderStorageTensorArrayNonUniformIndexing = copy_src->shaderStorageTensorArrayNonUniformIndexing;
+    descriptorBindingStorageTensorUpdateAfterBind = copy_src->descriptorBindingStorageTensorUpdateAfterBind;
+    tensors = copy_src->tensors;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDeviceTensorMemoryRequirementsARM::safe_VkDeviceTensorMemoryRequirementsARM(
+    const VkDeviceTensorMemoryRequirementsARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), pCreateInfo(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pCreateInfo) pCreateInfo = new safe_VkTensorCreateInfoARM(in_struct->pCreateInfo);
+}
+
+safe_VkDeviceTensorMemoryRequirementsARM::safe_VkDeviceTensorMemoryRequirementsARM()
+    : sType(VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM), pNext(nullptr), pCreateInfo(nullptr) {}
+
+safe_VkDeviceTensorMemoryRequirementsARM::safe_VkDeviceTensorMemoryRequirementsARM(
+    const safe_VkDeviceTensorMemoryRequirementsARM& copy_src) {
+    sType = copy_src.sType;
+    pCreateInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pCreateInfo) pCreateInfo = new safe_VkTensorCreateInfoARM(*copy_src.pCreateInfo);
+}
+
+safe_VkDeviceTensorMemoryRequirementsARM& safe_VkDeviceTensorMemoryRequirementsARM::operator=(
+    const safe_VkDeviceTensorMemoryRequirementsARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pCreateInfo) delete pCreateInfo;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    pCreateInfo = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pCreateInfo) pCreateInfo = new safe_VkTensorCreateInfoARM(*copy_src.pCreateInfo);
+
+    return *this;
+}
+
+safe_VkDeviceTensorMemoryRequirementsARM::~safe_VkDeviceTensorMemoryRequirementsARM() {
+    if (pCreateInfo) delete pCreateInfo;
+    FreePnextChain(pNext);
+}
+
+void safe_VkDeviceTensorMemoryRequirementsARM::initialize(const VkDeviceTensorMemoryRequirementsARM* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pCreateInfo) delete pCreateInfo;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    pCreateInfo = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (in_struct->pCreateInfo) pCreateInfo = new safe_VkTensorCreateInfoARM(in_struct->pCreateInfo);
+}
+
+void safe_VkDeviceTensorMemoryRequirementsARM::initialize(const safe_VkDeviceTensorMemoryRequirementsARM* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    pCreateInfo = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (copy_src->pCreateInfo) pCreateInfo = new safe_VkTensorCreateInfoARM(*copy_src->pCreateInfo);
+}
+
+safe_VkTensorCopyARM::safe_VkTensorCopyARM(const VkTensorCopyARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+                                           bool copy_pnext)
+    : sType(in_struct->sType),
+      dimensionCount(in_struct->dimensionCount),
+      pSrcOffset(nullptr),
+      pDstOffset(nullptr),
+      pExtent(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pSrcOffset) {
+        pSrcOffset = new uint64_t[in_struct->dimensionCount];
+        memcpy((void*)pSrcOffset, (void*)in_struct->pSrcOffset, sizeof(uint64_t) * in_struct->dimensionCount);
+    }
+
+    if (in_struct->pDstOffset) {
+        pDstOffset = new uint64_t[in_struct->dimensionCount];
+        memcpy((void*)pDstOffset, (void*)in_struct->pDstOffset, sizeof(uint64_t) * in_struct->dimensionCount);
+    }
+
+    if (in_struct->pExtent) {
+        pExtent = new uint64_t[in_struct->dimensionCount];
+        memcpy((void*)pExtent, (void*)in_struct->pExtent, sizeof(uint64_t) * in_struct->dimensionCount);
+    }
+}
+
+safe_VkTensorCopyARM::safe_VkTensorCopyARM()
+    : sType(VK_STRUCTURE_TYPE_TENSOR_COPY_ARM),
+      pNext(nullptr),
+      dimensionCount(),
+      pSrcOffset(nullptr),
+      pDstOffset(nullptr),
+      pExtent(nullptr) {}
+
+safe_VkTensorCopyARM::safe_VkTensorCopyARM(const safe_VkTensorCopyARM& copy_src) {
+    sType = copy_src.sType;
+    dimensionCount = copy_src.dimensionCount;
+    pSrcOffset = nullptr;
+    pDstOffset = nullptr;
+    pExtent = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pSrcOffset) {
+        pSrcOffset = new uint64_t[copy_src.dimensionCount];
+        memcpy((void*)pSrcOffset, (void*)copy_src.pSrcOffset, sizeof(uint64_t) * copy_src.dimensionCount);
+    }
+
+    if (copy_src.pDstOffset) {
+        pDstOffset = new uint64_t[copy_src.dimensionCount];
+        memcpy((void*)pDstOffset, (void*)copy_src.pDstOffset, sizeof(uint64_t) * copy_src.dimensionCount);
+    }
+
+    if (copy_src.pExtent) {
+        pExtent = new uint64_t[copy_src.dimensionCount];
+        memcpy((void*)pExtent, (void*)copy_src.pExtent, sizeof(uint64_t) * copy_src.dimensionCount);
+    }
+}
+
+safe_VkTensorCopyARM& safe_VkTensorCopyARM::operator=(const safe_VkTensorCopyARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pSrcOffset) delete[] pSrcOffset;
+    if (pDstOffset) delete[] pDstOffset;
+    if (pExtent) delete[] pExtent;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    dimensionCount = copy_src.dimensionCount;
+    pSrcOffset = nullptr;
+    pDstOffset = nullptr;
+    pExtent = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    if (copy_src.pSrcOffset) {
+        pSrcOffset = new uint64_t[copy_src.dimensionCount];
+        memcpy((void*)pSrcOffset, (void*)copy_src.pSrcOffset, sizeof(uint64_t) * copy_src.dimensionCount);
+    }
+
+    if (copy_src.pDstOffset) {
+        pDstOffset = new uint64_t[copy_src.dimensionCount];
+        memcpy((void*)pDstOffset, (void*)copy_src.pDstOffset, sizeof(uint64_t) * copy_src.dimensionCount);
+    }
+
+    if (copy_src.pExtent) {
+        pExtent = new uint64_t[copy_src.dimensionCount];
+        memcpy((void*)pExtent, (void*)copy_src.pExtent, sizeof(uint64_t) * copy_src.dimensionCount);
+    }
+
+    return *this;
+}
+
+safe_VkTensorCopyARM::~safe_VkTensorCopyARM() {
+    if (pSrcOffset) delete[] pSrcOffset;
+    if (pDstOffset) delete[] pDstOffset;
+    if (pExtent) delete[] pExtent;
+    FreePnextChain(pNext);
+}
+
+void safe_VkTensorCopyARM::initialize(const VkTensorCopyARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pSrcOffset) delete[] pSrcOffset;
+    if (pDstOffset) delete[] pDstOffset;
+    if (pExtent) delete[] pExtent;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    dimensionCount = in_struct->dimensionCount;
+    pSrcOffset = nullptr;
+    pDstOffset = nullptr;
+    pExtent = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+
+    if (in_struct->pSrcOffset) {
+        pSrcOffset = new uint64_t[in_struct->dimensionCount];
+        memcpy((void*)pSrcOffset, (void*)in_struct->pSrcOffset, sizeof(uint64_t) * in_struct->dimensionCount);
+    }
+
+    if (in_struct->pDstOffset) {
+        pDstOffset = new uint64_t[in_struct->dimensionCount];
+        memcpy((void*)pDstOffset, (void*)in_struct->pDstOffset, sizeof(uint64_t) * in_struct->dimensionCount);
+    }
+
+    if (in_struct->pExtent) {
+        pExtent = new uint64_t[in_struct->dimensionCount];
+        memcpy((void*)pExtent, (void*)in_struct->pExtent, sizeof(uint64_t) * in_struct->dimensionCount);
+    }
+}
+
+void safe_VkTensorCopyARM::initialize(const safe_VkTensorCopyARM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    dimensionCount = copy_src->dimensionCount;
+    pSrcOffset = nullptr;
+    pDstOffset = nullptr;
+    pExtent = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+
+    if (copy_src->pSrcOffset) {
+        pSrcOffset = new uint64_t[copy_src->dimensionCount];
+        memcpy((void*)pSrcOffset, (void*)copy_src->pSrcOffset, sizeof(uint64_t) * copy_src->dimensionCount);
+    }
+
+    if (copy_src->pDstOffset) {
+        pDstOffset = new uint64_t[copy_src->dimensionCount];
+        memcpy((void*)pDstOffset, (void*)copy_src->pDstOffset, sizeof(uint64_t) * copy_src->dimensionCount);
+    }
+
+    if (copy_src->pExtent) {
+        pExtent = new uint64_t[copy_src->dimensionCount];
+        memcpy((void*)pExtent, (void*)copy_src->pExtent, sizeof(uint64_t) * copy_src->dimensionCount);
+    }
+}
+
+safe_VkCopyTensorInfoARM::safe_VkCopyTensorInfoARM(const VkCopyTensorInfoARM* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType),
+      srcTensor(in_struct->srcTensor),
+      dstTensor(in_struct->dstTensor),
+      regionCount(in_struct->regionCount),
+      pRegions(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (regionCount && in_struct->pRegions) {
+        pRegions = new safe_VkTensorCopyARM[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+safe_VkCopyTensorInfoARM::safe_VkCopyTensorInfoARM()
+    : sType(VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM), pNext(nullptr), srcTensor(), dstTensor(), regionCount(), pRegions(nullptr) {}
+
+safe_VkCopyTensorInfoARM::safe_VkCopyTensorInfoARM(const safe_VkCopyTensorInfoARM& copy_src) {
+    sType = copy_src.sType;
+    srcTensor = copy_src.srcTensor;
+    dstTensor = copy_src.dstTensor;
+    regionCount = copy_src.regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (regionCount && copy_src.pRegions) {
+        pRegions = new safe_VkTensorCopyARM[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+}
+
+safe_VkCopyTensorInfoARM& safe_VkCopyTensorInfoARM::operator=(const safe_VkCopyTensorInfoARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    srcTensor = copy_src.srcTensor;
+    dstTensor = copy_src.dstTensor;
+    regionCount = copy_src.regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (regionCount && copy_src.pRegions) {
+        pRegions = new safe_VkTensorCopyARM[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src.pRegions[i]);
+        }
+    }
+
+    return *this;
+}
+
+safe_VkCopyTensorInfoARM::~safe_VkCopyTensorInfoARM() {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+}
+
+void safe_VkCopyTensorInfoARM::initialize(const VkCopyTensorInfoARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pRegions) delete[] pRegions;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    srcTensor = in_struct->srcTensor;
+    dstTensor = in_struct->dstTensor;
+    regionCount = in_struct->regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (regionCount && in_struct->pRegions) {
+        pRegions = new safe_VkTensorCopyARM[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&in_struct->pRegions[i]);
+        }
+    }
+}
+
+void safe_VkCopyTensorInfoARM::initialize(const safe_VkCopyTensorInfoARM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    srcTensor = copy_src->srcTensor;
+    dstTensor = copy_src->dstTensor;
+    regionCount = copy_src->regionCount;
+    pRegions = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (regionCount && copy_src->pRegions) {
+        pRegions = new safe_VkTensorCopyARM[regionCount];
+        for (uint32_t i = 0; i < regionCount; ++i) {
+            pRegions[i].initialize(&copy_src->pRegions[i]);
+        }
+    }
+}
+
+safe_VkMemoryDedicatedAllocateInfoTensorARM::safe_VkMemoryDedicatedAllocateInfoTensorARM(
+    const VkMemoryDedicatedAllocateInfoTensorARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), tensor(in_struct->tensor) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkMemoryDedicatedAllocateInfoTensorARM::safe_VkMemoryDedicatedAllocateInfoTensorARM()
+    : sType(VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM), pNext(nullptr), tensor() {}
+
+safe_VkMemoryDedicatedAllocateInfoTensorARM::safe_VkMemoryDedicatedAllocateInfoTensorARM(
+    const safe_VkMemoryDedicatedAllocateInfoTensorARM& copy_src) {
+    sType = copy_src.sType;
+    tensor = copy_src.tensor;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkMemoryDedicatedAllocateInfoTensorARM& safe_VkMemoryDedicatedAllocateInfoTensorARM::operator=(
+    const safe_VkMemoryDedicatedAllocateInfoTensorARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    tensor = copy_src.tensor;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkMemoryDedicatedAllocateInfoTensorARM::~safe_VkMemoryDedicatedAllocateInfoTensorARM() { FreePnextChain(pNext); }
+
+void safe_VkMemoryDedicatedAllocateInfoTensorARM::initialize(const VkMemoryDedicatedAllocateInfoTensorARM* in_struct,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    tensor = in_struct->tensor;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkMemoryDedicatedAllocateInfoTensorARM::initialize(const safe_VkMemoryDedicatedAllocateInfoTensorARM* copy_src,
+                                                             [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    tensor = copy_src->tensor;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceExternalTensorInfoARM::safe_VkPhysicalDeviceExternalTensorInfoARM(
+    const VkPhysicalDeviceExternalTensorInfoARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), flags(in_struct->flags), pDescription(nullptr), handleType(in_struct->handleType) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (in_struct->pDescription) pDescription = new safe_VkTensorDescriptionARM(in_struct->pDescription);
+}
+
+safe_VkPhysicalDeviceExternalTensorInfoARM::safe_VkPhysicalDeviceExternalTensorInfoARM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM),
+      pNext(nullptr),
+      flags(),
+      pDescription(nullptr),
+      handleType() {}
+
+safe_VkPhysicalDeviceExternalTensorInfoARM::safe_VkPhysicalDeviceExternalTensorInfoARM(
+    const safe_VkPhysicalDeviceExternalTensorInfoARM& copy_src) {
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pDescription = nullptr;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pDescription) pDescription = new safe_VkTensorDescriptionARM(*copy_src.pDescription);
+}
+
+safe_VkPhysicalDeviceExternalTensorInfoARM& safe_VkPhysicalDeviceExternalTensorInfoARM::operator=(
+    const safe_VkPhysicalDeviceExternalTensorInfoARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pDescription) delete pDescription;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    flags = copy_src.flags;
+    pDescription = nullptr;
+    handleType = copy_src.handleType;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (copy_src.pDescription) pDescription = new safe_VkTensorDescriptionARM(*copy_src.pDescription);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceExternalTensorInfoARM::~safe_VkPhysicalDeviceExternalTensorInfoARM() {
+    if (pDescription) delete pDescription;
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceExternalTensorInfoARM::initialize(const VkPhysicalDeviceExternalTensorInfoARM* in_struct,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pDescription) delete pDescription;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    flags = in_struct->flags;
+    pDescription = nullptr;
+    handleType = in_struct->handleType;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (in_struct->pDescription) pDescription = new safe_VkTensorDescriptionARM(in_struct->pDescription);
+}
+
+void safe_VkPhysicalDeviceExternalTensorInfoARM::initialize(const safe_VkPhysicalDeviceExternalTensorInfoARM* copy_src,
+                                                            [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    flags = copy_src->flags;
+    pDescription = nullptr;
+    handleType = copy_src->handleType;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (copy_src->pDescription) pDescription = new safe_VkTensorDescriptionARM(*copy_src->pDescription);
+}
+
+safe_VkExternalTensorPropertiesARM::safe_VkExternalTensorPropertiesARM(const VkExternalTensorPropertiesARM* in_struct,
+                                                                       [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), externalMemoryProperties(in_struct->externalMemoryProperties) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkExternalTensorPropertiesARM::safe_VkExternalTensorPropertiesARM()
+    : sType(VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM), pNext(nullptr), externalMemoryProperties() {}
+
+safe_VkExternalTensorPropertiesARM::safe_VkExternalTensorPropertiesARM(const safe_VkExternalTensorPropertiesARM& copy_src) {
+    sType = copy_src.sType;
+    externalMemoryProperties = copy_src.externalMemoryProperties;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkExternalTensorPropertiesARM& safe_VkExternalTensorPropertiesARM::operator=(
+    const safe_VkExternalTensorPropertiesARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    externalMemoryProperties = copy_src.externalMemoryProperties;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkExternalTensorPropertiesARM::~safe_VkExternalTensorPropertiesARM() { FreePnextChain(pNext); }
+
+void safe_VkExternalTensorPropertiesARM::initialize(const VkExternalTensorPropertiesARM* in_struct,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    externalMemoryProperties = in_struct->externalMemoryProperties;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkExternalTensorPropertiesARM::initialize(const safe_VkExternalTensorPropertiesARM* copy_src,
+                                                    [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    externalMemoryProperties = copy_src->externalMemoryProperties;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkExternalMemoryTensorCreateInfoARM::safe_VkExternalMemoryTensorCreateInfoARM(
+    const VkExternalMemoryTensorCreateInfoARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), handleTypes(in_struct->handleTypes) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkExternalMemoryTensorCreateInfoARM::safe_VkExternalMemoryTensorCreateInfoARM()
+    : sType(VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM), pNext(nullptr), handleTypes() {}
+
+safe_VkExternalMemoryTensorCreateInfoARM::safe_VkExternalMemoryTensorCreateInfoARM(
+    const safe_VkExternalMemoryTensorCreateInfoARM& copy_src) {
+    sType = copy_src.sType;
+    handleTypes = copy_src.handleTypes;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkExternalMemoryTensorCreateInfoARM& safe_VkExternalMemoryTensorCreateInfoARM::operator=(
+    const safe_VkExternalMemoryTensorCreateInfoARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    handleTypes = copy_src.handleTypes;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkExternalMemoryTensorCreateInfoARM::~safe_VkExternalMemoryTensorCreateInfoARM() { FreePnextChain(pNext); }
+
+void safe_VkExternalMemoryTensorCreateInfoARM::initialize(const VkExternalMemoryTensorCreateInfoARM* in_struct,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    handleTypes = in_struct->handleTypes;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkExternalMemoryTensorCreateInfoARM::initialize(const safe_VkExternalMemoryTensorCreateInfoARM* copy_src,
+                                                          [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    handleTypes = copy_src->handleTypes;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM::safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM(
+    const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType), descriptorBufferTensorDescriptors(in_struct->descriptorBufferTensorDescriptors) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM::safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM),
+      pNext(nullptr),
+      descriptorBufferTensorDescriptors() {}
+
+safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM::safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM(
+    const safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM& copy_src) {
+    sType = copy_src.sType;
+    descriptorBufferTensorDescriptors = copy_src.descriptorBufferTensorDescriptors;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM& safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM::operator=(
+    const safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    descriptorBufferTensorDescriptors = copy_src.descriptorBufferTensorDescriptors;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM::~safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM::initialize(
+    const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    descriptorBufferTensorDescriptors = in_struct->descriptorBufferTensorDescriptors;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM::initialize(
+    const safe_VkPhysicalDeviceDescriptorBufferTensorFeaturesARM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    descriptorBufferTensorDescriptors = copy_src->descriptorBufferTensorDescriptors;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM::safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM(
+    const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state,
+    bool copy_pnext)
+    : sType(in_struct->sType),
+      tensorCaptureReplayDescriptorDataSize(in_struct->tensorCaptureReplayDescriptorDataSize),
+      tensorViewCaptureReplayDescriptorDataSize(in_struct->tensorViewCaptureReplayDescriptorDataSize),
+      tensorDescriptorSize(in_struct->tensorDescriptorSize) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM::safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM()
+    : sType(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM),
+      pNext(nullptr),
+      tensorCaptureReplayDescriptorDataSize(),
+      tensorViewCaptureReplayDescriptorDataSize(),
+      tensorDescriptorSize() {}
+
+safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM::safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM(
+    const safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM& copy_src) {
+    sType = copy_src.sType;
+    tensorCaptureReplayDescriptorDataSize = copy_src.tensorCaptureReplayDescriptorDataSize;
+    tensorViewCaptureReplayDescriptorDataSize = copy_src.tensorViewCaptureReplayDescriptorDataSize;
+    tensorDescriptorSize = copy_src.tensorDescriptorSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM& safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM::operator=(
+    const safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    tensorCaptureReplayDescriptorDataSize = copy_src.tensorCaptureReplayDescriptorDataSize;
+    tensorViewCaptureReplayDescriptorDataSize = copy_src.tensorViewCaptureReplayDescriptorDataSize;
+    tensorDescriptorSize = copy_src.tensorDescriptorSize;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM::~safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM() {
+    FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM::initialize(
+    const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    tensorCaptureReplayDescriptorDataSize = in_struct->tensorCaptureReplayDescriptorDataSize;
+    tensorViewCaptureReplayDescriptorDataSize = in_struct->tensorViewCaptureReplayDescriptorDataSize;
+    tensorDescriptorSize = in_struct->tensorDescriptorSize;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM::initialize(
+    const safe_VkPhysicalDeviceDescriptorBufferTensorPropertiesARM* copy_src, [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    tensorCaptureReplayDescriptorDataSize = copy_src->tensorCaptureReplayDescriptorDataSize;
+    tensorViewCaptureReplayDescriptorDataSize = copy_src->tensorViewCaptureReplayDescriptorDataSize;
+    tensorDescriptorSize = copy_src->tensorDescriptorSize;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkDescriptorGetTensorInfoARM::safe_VkDescriptorGetTensorInfoARM(const VkDescriptorGetTensorInfoARM* in_struct,
+                                                                     [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), tensorView(in_struct->tensorView) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkDescriptorGetTensorInfoARM::safe_VkDescriptorGetTensorInfoARM()
+    : sType(VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM), pNext(nullptr), tensorView() {}
+
+safe_VkDescriptorGetTensorInfoARM::safe_VkDescriptorGetTensorInfoARM(const safe_VkDescriptorGetTensorInfoARM& copy_src) {
+    sType = copy_src.sType;
+    tensorView = copy_src.tensorView;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkDescriptorGetTensorInfoARM& safe_VkDescriptorGetTensorInfoARM::operator=(const safe_VkDescriptorGetTensorInfoARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    tensorView = copy_src.tensorView;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkDescriptorGetTensorInfoARM::~safe_VkDescriptorGetTensorInfoARM() { FreePnextChain(pNext); }
+
+void safe_VkDescriptorGetTensorInfoARM::initialize(const VkDescriptorGetTensorInfoARM* in_struct,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    tensorView = in_struct->tensorView;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkDescriptorGetTensorInfoARM::initialize(const safe_VkDescriptorGetTensorInfoARM* copy_src,
+                                                   [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    tensorView = copy_src->tensorView;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkTensorCaptureDescriptorDataInfoARM::safe_VkTensorCaptureDescriptorDataInfoARM(
+    const VkTensorCaptureDescriptorDataInfoARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), tensor(in_struct->tensor) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkTensorCaptureDescriptorDataInfoARM::safe_VkTensorCaptureDescriptorDataInfoARM()
+    : sType(VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM), pNext(nullptr), tensor() {}
+
+safe_VkTensorCaptureDescriptorDataInfoARM::safe_VkTensorCaptureDescriptorDataInfoARM(
+    const safe_VkTensorCaptureDescriptorDataInfoARM& copy_src) {
+    sType = copy_src.sType;
+    tensor = copy_src.tensor;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkTensorCaptureDescriptorDataInfoARM& safe_VkTensorCaptureDescriptorDataInfoARM::operator=(
+    const safe_VkTensorCaptureDescriptorDataInfoARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    tensor = copy_src.tensor;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkTensorCaptureDescriptorDataInfoARM::~safe_VkTensorCaptureDescriptorDataInfoARM() { FreePnextChain(pNext); }
+
+void safe_VkTensorCaptureDescriptorDataInfoARM::initialize(const VkTensorCaptureDescriptorDataInfoARM* in_struct,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    tensor = in_struct->tensor;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkTensorCaptureDescriptorDataInfoARM::initialize(const safe_VkTensorCaptureDescriptorDataInfoARM* copy_src,
+                                                           [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    tensor = copy_src->tensor;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkTensorViewCaptureDescriptorDataInfoARM::safe_VkTensorViewCaptureDescriptorDataInfoARM(
+    const VkTensorViewCaptureDescriptorDataInfoARM* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), tensorView(in_struct->tensorView) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+}
+
+safe_VkTensorViewCaptureDescriptorDataInfoARM::safe_VkTensorViewCaptureDescriptorDataInfoARM()
+    : sType(VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM), pNext(nullptr), tensorView() {}
+
+safe_VkTensorViewCaptureDescriptorDataInfoARM::safe_VkTensorViewCaptureDescriptorDataInfoARM(
+    const safe_VkTensorViewCaptureDescriptorDataInfoARM& copy_src) {
+    sType = copy_src.sType;
+    tensorView = copy_src.tensorView;
+    pNext = SafePnextCopy(copy_src.pNext);
+}
+
+safe_VkTensorViewCaptureDescriptorDataInfoARM& safe_VkTensorViewCaptureDescriptorDataInfoARM::operator=(
+    const safe_VkTensorViewCaptureDescriptorDataInfoARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    tensorView = copy_src.tensorView;
+    pNext = SafePnextCopy(copy_src.pNext);
+
+    return *this;
+}
+
+safe_VkTensorViewCaptureDescriptorDataInfoARM::~safe_VkTensorViewCaptureDescriptorDataInfoARM() { FreePnextChain(pNext); }
+
+void safe_VkTensorViewCaptureDescriptorDataInfoARM::initialize(const VkTensorViewCaptureDescriptorDataInfoARM* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    tensorView = in_struct->tensorView;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+}
+
+void safe_VkTensorViewCaptureDescriptorDataInfoARM::initialize(const safe_VkTensorViewCaptureDescriptorDataInfoARM* copy_src,
+                                                               [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    tensorView = copy_src->tensorView;
+    pNext = SafePnextCopy(copy_src->pNext);
+}
+
+safe_VkFrameBoundaryTensorsARM::safe_VkFrameBoundaryTensorsARM(const VkFrameBoundaryTensorsARM* in_struct,
+                                                               [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
+    : sType(in_struct->sType), tensorCount(in_struct->tensorCount), pTensors(nullptr) {
+    if (copy_pnext) {
+        pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    }
+    if (tensorCount && in_struct->pTensors) {
+        pTensors = new VkTensorARM[tensorCount];
+        for (uint32_t i = 0; i < tensorCount; ++i) {
+            pTensors[i] = in_struct->pTensors[i];
+        }
+    }
+}
+
+safe_VkFrameBoundaryTensorsARM::safe_VkFrameBoundaryTensorsARM()
+    : sType(VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM), pNext(nullptr), tensorCount(), pTensors(nullptr) {}
+
+safe_VkFrameBoundaryTensorsARM::safe_VkFrameBoundaryTensorsARM(const safe_VkFrameBoundaryTensorsARM& copy_src) {
+    sType = copy_src.sType;
+    tensorCount = copy_src.tensorCount;
+    pTensors = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (tensorCount && copy_src.pTensors) {
+        pTensors = new VkTensorARM[tensorCount];
+        for (uint32_t i = 0; i < tensorCount; ++i) {
+            pTensors[i] = copy_src.pTensors[i];
+        }
+    }
+}
+
+safe_VkFrameBoundaryTensorsARM& safe_VkFrameBoundaryTensorsARM::operator=(const safe_VkFrameBoundaryTensorsARM& copy_src) {
+    if (&copy_src == this) return *this;
+
+    if (pTensors) delete[] pTensors;
+    FreePnextChain(pNext);
+
+    sType = copy_src.sType;
+    tensorCount = copy_src.tensorCount;
+    pTensors = nullptr;
+    pNext = SafePnextCopy(copy_src.pNext);
+    if (tensorCount && copy_src.pTensors) {
+        pTensors = new VkTensorARM[tensorCount];
+        for (uint32_t i = 0; i < tensorCount; ++i) {
+            pTensors[i] = copy_src.pTensors[i];
+        }
+    }
+
+    return *this;
+}
+
+safe_VkFrameBoundaryTensorsARM::~safe_VkFrameBoundaryTensorsARM() {
+    if (pTensors) delete[] pTensors;
+    FreePnextChain(pNext);
+}
+
+void safe_VkFrameBoundaryTensorsARM::initialize(const VkFrameBoundaryTensorsARM* in_struct,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    if (pTensors) delete[] pTensors;
+    FreePnextChain(pNext);
+    sType = in_struct->sType;
+    tensorCount = in_struct->tensorCount;
+    pTensors = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext, copy_state);
+    if (tensorCount && in_struct->pTensors) {
+        pTensors = new VkTensorARM[tensorCount];
+        for (uint32_t i = 0; i < tensorCount; ++i) {
+            pTensors[i] = in_struct->pTensors[i];
+        }
+    }
+}
+
+void safe_VkFrameBoundaryTensorsARM::initialize(const safe_VkFrameBoundaryTensorsARM* copy_src,
+                                                [[maybe_unused]] PNextCopyState* copy_state) {
+    sType = copy_src->sType;
+    tensorCount = copy_src->tensorCount;
+    pTensors = nullptr;
+    pNext = SafePnextCopy(copy_src->pNext);
+    if (tensorCount && copy_src->pTensors) {
+        pTensors = new VkTensorARM[tensorCount];
+        for (uint32_t i = 0; i < tensorCount; ++i) {
+            pTensors[i] = copy_src->pTensors[i];
+        }
+    }
+}
+
 safe_VkPhysicalDeviceOpticalFlowFeaturesNV::safe_VkPhysicalDeviceOpticalFlowFeaturesNV(
     const VkPhysicalDeviceOpticalFlowFeaturesNV* in_struct, [[maybe_unused]] PNextCopyState* copy_state, bool copy_pnext)
     : sType(in_struct->sType), opticalFlow(in_struct->opticalFlow) {